leecodecode【面试150】【2026.6.16打卡-java版本】

赎金信

要点：map

java 复制代码

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character,Integer> map1 = new HashMap<>();
        for(int  i = 0; i < ransomNote.length(); i++){
            map1.put(ransomNote.charAt(i), map1.getOrDefault(ransomNote.charAt(i),0) + 1);
        }

        Map<Character,Integer> map2 = new HashMap<>();
        for(int  i = 0; i < magazine.length(); i++){
            map2.put(magazine.charAt(i), map2.getOrDefault(magazine.charAt(i),0) + 1);
        }

        for(int  i = 0; i < ransomNote.length(); i++){
           char c = ransomNote.charAt(i);
           if(map2.get(c) == null){
            return false;
           }
           if(map1.get(c) > map2.get(c)){
            return false;
           }
        }


        return true;




        
    }
}

生命游戏

要点：纯模拟

java 复制代码

class Solution {
    public void gameOfLife(int[][] board) {
        int[] neighbors = {0, 1, -1};

        int rows = board.length;
        int cols = board[0].length;

        // 创建复制数组 copyBoard
        int[][] copyBoard = new int[rows][cols];

        // 从原数组复制一份到 copyBoard 中
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                copyBoard[row][col] = board[row][col];
            }
        }

        // 遍历面板每一个格子里的细胞
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {

                // 对于每一个细胞统计其八个相邻位置里的活细胞数量
                int liveNeighbors = 0;

                for (int i = 0; i < 3; i++) {
                    for (int j = 0; j < 3; j++) {

                        if (!(neighbors[i] == 0 && neighbors[j] == 0)) {
                            int r = (row + neighbors[i]);
                            int c = (col + neighbors[j]);

                            // 查看相邻的细胞是否是活细胞
                            if ((r < rows && r >= 0) && (c < cols && c >= 0) && (copyBoard[r][c] == 1)) {
                                liveNeighbors += 1;
                            }
                        }
                    }
                }

                // 规则 1 或规则 3      
                if ((copyBoard[row][col] == 1) && (liveNeighbors < 2 || liveNeighbors > 3)) {
                    board[row][col] = 0;
                }
                // 规则 4
                if (copyBoard[row][col] == 0 && liveNeighbors == 3) {
                    board[row][col] = 1;
                }
            }
        }
    }
}

同构字符串

要点：两个哈希

java 复制代码

class Solution {
    public boolean isIsomorphic(String s, String t) {
        //两个哈希表
        Map<Character, Character> sTot = new HashMap<>();
        Map<Character, Character> tTos = new HashMap<>();

        for(int i = 0; i < s.length(); i++){
            char st = s.charAt(i);
            char tt = t.charAt(i);

            if((sTot.containsKey(st) && sTot.get(st) != tt) || (tTos.containsKey(tt) && tTos.get(tt) != st)){
                return false;
            }

            sTot.put(st, tt);
            tTos.put(tt,st);
        }

        return true;

        
    }
}

单词规律

要点：split，也是两个hashmap对应两个类型的映射

java 复制代码

class Solution {
    public boolean wordPattern(String pattern, String s) {
        String[] words = s.split(" ");
        if (pattern.length() != words.length) {
            return false;
        }

        Map<Character, String> charToWord = new HashMap<>();
        Map<String, Character> wordToChar = new HashMap<>();

        for (int i = 0; i < pattern.length(); i++) {
            char c = pattern.charAt(i);
            String word = words[i];

            // 检查 char → word
            if (charToWord.containsKey(c) && !charToWord.get(c).equals(word)) {
                return false;
            }
            // 检查 word → char
            if (wordToChar.containsKey(word) && wordToChar.get(word) != c) {
                return false;
            }

            charToWord.put(c, word);
            wordToChar.put(word, c);
        }
        return true;
    }
}

有效的字母异位词

要点： int【】char = new interesting【26】 c - 'a'

java 复制代码

class Solution {
    public boolean isAnagram(String s, String t) {
        //字母对应的
        int[] cnt = new int[26];

        for(char c : s.toCharArray()){
            cnt[c - 'a']++;
        }

        for(char c : t.toCharArray()){
            cnt[c - 'a']--;
        }

        for(int num : cnt){
            if(num != 0){
                return false;
            }
        }

        return true;

        
    }
}

字母异位词分组

要点：str排序，map

java 复制代码

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        //每个str排序然后<key,value>

        Map<String ,List<String>> map = new HashMap<>();

        for(String str : strs){
            char[] c = str.toCharArray();
            Arrays.sort(c);
            String csort = new String(c);
            if(map.containsKey(csort)){
                List<String> ans = map.get(csort);
                ans.add(str);
                map.put(csort,ans);
            }else{
                List<String> ans = new ArrayList<>();
                ans.add(str);
                map.put(csort,ans);
            }

        }

        return new ArrayList<List<String>>(map.values());
    }
}

快乐数

要点：set破除循环

java 复制代码

class Solution {
    public boolean isHappy(int n) {
        //破循环
        Set<Integer> seen = new HashSet<>();
       while(n != 1 && !seen.contains(n)){
        seen.add(n);
        int next = Sqrt(n);
        n = next;

      }

      return n==1;


        
    }

    public int Sqrt(int n){
        int sum = 0;
        while(n > 0){
            int m =n%10;
            sum += m*m;
            n = n/10;
        }

        return sum;
    }
}

存在重复元素 II

要点：map记录最左边的数，因为是<k

java 复制代码

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        //小于记录最左边的就行了
        Map<Integer,Integer> map = new HashMap<>();

        for(int i = 0 ; i < nums.length ; i++){

            if(!map.containsKey(nums[i])){
                map.put(nums[i], i);
            }else{
                int start = map.get(nums[i]);
                map.put(nums[i],i);
                if(i - start <= k){
                    return true;
                }
            }
        }

        return false;
        
    }
}

最长连续序列

要点：set，找没有num--1的num开始找

java 复制代码

class Solution {
    public int longestConsecutive(int[] nums) {

        if(nums.length == 0 || nums ==null){
            return 0;
        }
        Set<Integer> set = new HashSet<>();

        for(int num : nums){
            set.add(num);
        }
        int max = 1;
        //在去重的数组里面做
        for(int num : set){
            if(set.contains(num-1)){
                continue;
            }else{
                int temp =num;
                int jishu =1;
                while(set.contains(temp+1)){
                    jishu++;
                    temp++;
                }
                max = Math.max(jishu,max);
            }
        }
        return max;
        
    }
}

碎碎念：后续会更新每天学习的八股和算法题，开始准备秋招的第37天。努力连续更新100天！以后每天就按，秋招项目【java +agent】，科研，必做项目，算法，八股，锻炼身体来总结。

总结：要掌控好自己的时间

1.算法面试150 69/150【早中晚】2h

2.秋招项目，【java 项目】，1/6；无

【agent 项目】1/6，无，

3.科研要跑一下，无

4.检测项目，准备数据集【5.5h】

6.背八股，【】

7.锻炼身体，【1h】

然后写简历写了2h，吹牛的感觉真不错呀哈哈哈哈