代码随想录算法训练营day06 | leetcode 242、349 、202、1

基础知识

哈希 常见的结构（不要忘记数组）

• 数组
• set （集合）
• map(映射)

注意 哈希冲突 哈希函数

LeetCode 242

分析1.0

HashMap<Character, Integer> 记录字符元素及其个数，再以字符序列对key进行排序，比较两个Map是否一致或者是遍历Map1的时候，在map2中对cur指针key查询对应个数

有一个用例未通过

原因：

引用类型比较值使用equals().方法map1.get(c).equals(map2.get(c)) 

class Solution {
    public boolean isAnagram(String s, String t) {
        int sizeS = 0, sizeT = 0;
        HashMap<Character,Integer> map1 = new HashMap();
        HashMap<Character,Integer> map2 = new HashMap();
        for(int i = 0; i < s.length(); i++){
            map1.put(s.charAt(i), map1.getOrDefault(s.charAt(i),0)+1);
        }
        for(int j = 0; j < t.length(); j++){
            map2.put(t.charAt(j), map2.getOrDefault(t.charAt(j),0)+1);
        }
        System.out.println(map1);
        System.out.println(map2);
        // 光size相同不行 要size同而且对应的元素也同
        sizeS = map1.size();
        sizeT = map2.size();
        if(sizeS != sizeT){
            return false;
        }
        for(Character c : map1.keySet()){
            if(map2.get(c) == null){
                return false;
            }
            if(map1.get(c) != map2.get(c)){
                return false;
            }
        }
        return true;
    }
}

分析2.0

数组也是一个hash表，它的key就是索引，元素就是value 要将普通的key一一对应为数组的index

LeetCode 349

分析1.0

两个数组，找他们的公共集合，集合元素不重复

思路：遍历较短数组，如果长数组中存在这个元素，加入Set，最后将Set转换成int[]

在第二个for循环中，可用contains()方法判断元素是否在集合中

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> set = new HashSet();
        for(int i = 0; i < nums1.length; i++){
            for(int j = 0; j < nums2.length; j++){
                if(nums1[i] == nums2[j]){
                    set.add(nums1[i]);
                }
            }
        }
        int[] ans = new int[set.size()];
        int index = 0;
        for(Integer temp : set){
            ans[index++] = temp.intValue();
        }
        return ans;
    }
}

LeetCode 202

分析1.0

元素是正整数，分离各个位置上的元素，求和判断是否为快乐数

如何判断循环终止条件-出现无限循环数，将所有数存进set，当存在相同数时即进入循环

class Solution {
    public boolean isHappy(int n) {
        HashSet<Integer> set = new HashSet();
        set.add(n);
        while(true){
            int val = getVal(n);
            System.out.println(val);
            if(val == 1){
                //System.out.println(set);
                return true;
            }
            if(set.contains(val)){
                //System.out.println(set);
                return false;
            }else{
                set.add(val);
                n = val;
            }
        }
    }
    public int getVal(int n){
        int ans = 0;
        while(n != 0){
            ans += (n%10)*(n%10);
            n = n / 10;
        }
        return ans;
    }
}

分析2.0

说白了就是找到循环退出的条件，循环继续下去的条件

LeetCode 1

分析1.0 

将数组元素去重存放进HashMap<Integer,Integer> （元素值，索引）达到去重功能，接着两层for循环解决问题，将结果添加进int[] ans返回

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap();
        int[] ans = new int[2];
        for(int i = 0; i < nums.length; i++){
            map.put(nums[i], i);
        }
        for(Integer val1 : map.keySet()){
            int cnt = 0;
            for(Integer val2 : map.keySet()){
                if(cnt == 0){
                    cnt++;
                    continue;
                }
                if(val1 + val2 == target){
                    ans[0] = map.get(val1).intValue();
                    ans[1] = map.get(val2).intValue();
                    return ans;
                }
            }
        }
        return ans;
    }
}

问题

1. [3,3] 6这样的用例就不行了
2. 这样遍历每次val1 val2初值是一样的
3. 其实哈希表的作用就在于去重+判断是否存在某个元素 怎么利用特性去写代码还是很要紧的

for(Integer val1 : map.keySet()){
    for(Integer val2 : map.keySet()){
        if(val1 + val2 == target){
            ans[0] = map.get(val1).intValue();
            ans[1] = map.get(val2).intValue();
            return ans;
        }
    }
}

已经遍历的部分+当前遍历元素+未遍历部分

for(int i = 0; i < nums.length; i++){
    int temp = target - nums[i];   // 遍历当前元素，并在map中寻找是否有匹配的key
    if(map.containsKey(temp)){
        res[1] = i;
        res[0] = map.get(temp);
        break;
    }
    map.put(nums[i], i);    // 如果没找到匹配对，就把访问过的元素和下标加入到map中
}

分析2.0 

这题具体情况具体分析不就是一个暴力for循环能解决的事儿吗???

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] ans = new int[2];
        for(int i = 0; i< nums.length-1; i++){
            for(int j = i+1; j < nums.length; j++){
                if(nums[i] + nums[j] == target){
                    ans[0] = i;
                    ans[1] = j;
                    return ans;
                }
            }
        }
        return ans;
    }
}

分析3.0

其实就是找两个数，遍历的当前元素算一个，那剩下的肯定就只能在已经遍历或者未遍历的元素中找，暴力for循环就是在未遍历的元素中找，Map的contains就是在已经遍历过的元素中找，但是有一个很巧妙的思维就是

int temp = target - nums[i]

不用像普通暴力双层for循环那样猛烈

总结

1. 引用类型比较值使用equals()
2. HashMap默认是按照key字典序进行存储的 可打印验证
3. key - 数组下标 - value
4. 字符转数字 '字符' - 'a' 得到的就是对应26个字符的序数
5. 明确题目要求，有时它只需要一个结果，如何操作数据、要不要操作数据是一个问题
6. Integer泛型得到的集合不能直接转成int[] 
7. int[] arr 必须初始化后才能进行操作 不能直接int[] arr = 另外一个数组
8. Set HashMap 遍历过程 这个没法儿用xx.get(index)访问元素
9. 找到循环退出的条件，循环继续下去的条件
10. 查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法
11. 判断特殊情况-定义返回结果-找准循环开始/结束边界条件-打日志定位错误
12. 数组特殊情况

    if(nums == null || nums.length == 0){
            return res;
        }

13. 抽象思维 已经遍历的部分+当前遍历元素+未遍历部分 遍历过的部分存进map用contains()判断 判断的时候要知道你还缺哪个元素

常用变量名增量更新

size、val、ans、cnt、cur、pre、next、left、right、index、gap、target、res