代码随想录第五天 | 哈希表part01

哈希表理论基础

建议：大家要了解哈希表的内部实现原理，哈希函数，哈希碰撞，以及常见哈希表的区别，数组，set 和map。

什么时候想到用哈希法，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。 这句话很重要，大家在做哈希表题目都要思考这句话。

文章讲解：https://programmercarl.com/哈希表理论基础.html

---

242.有效的字母异位词

建议： 这道题目，大家可以感受到 数组 用来做哈希表 给我们带来的遍历之处。

题目链接/文章讲解/视频讲解： https://programmercarl.com/0242.有效的字母异位词.html

题目感想：

1.就是相同数量的字母来组成的不同的单词嘛，我们可以通过暴力循环来得出是否是异位词，也可以通过初始化一个数组，因为全是字母且小写，所以只用26位数组就行，然后先遍历第一个字符串，在数组其对应的位置上面+1，然后再遍历第二个字符串，在数组对应位置上-1，最后再检查整个数组，看是否有不为0的位，有则不是，没有则是异位字；

/**
 * 242. 有效的字母异位词 字典解法
 * 时间复杂度O(m+n) 空间复杂度O(1)
 */
class Solution {
    public boolean isAnagram(String s, String t) {
        int[] record = new int[26];

        for (int i = 0; i < s.length(); i++) {
            record[s.charAt(i) - 'a']++;
// 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
        }

        for (int i = 0; i < t.length(); i++) {
            record[t.charAt(i) - 'a']--;
        }
        for (int count: record) {
            if (count != 0) {
// record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        return true;
// record数组所有元素都为零0，说明字符串s和t是字母异位词
    }
}

---

1. 两个数组的交集
   
   建议：本题就开始考虑 什么时候用set 什么时候用数组，本题其实是使用set的好题，但是后来力扣改了题目描述和 测试用例，添加了 0 <= nums1[i], nums2[i] <= 1000 条件，所以使用数组也可以了，不过建议大家忽略这个条件。 尝试去使用set。
   
   题目链接/文章讲解/视频讲解：https://programmercarl.com/0349.两个数组的交集.html

题目感想：

1.在有限定的范围的情况下，定义数组进行检索会更快，在不限制范围，我们需要考虑用set或者map，一个无序且不重复，一个有序允许重复；

2.最简单的思路就是，首先遍历第一个数组，将它的元素加入set，然后遍历第二个数组，并且去set中进行查找，如果能找到，那就将这个元素加入结果set，不能的话就直接下一个，最后将结果set转为数组输出，也可以直接申请一个结果数组进行存储；

import java.util.HashSet;
import java.util.Set;

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        //遍历数组1
        for (int i : nums1) {
            set1.add(i);
        }
        //遍历数组2的过程中判断哈希表中是否存在该元素
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
        //方法1：将结果集合转为数组

        return resSet.stream().mapToInt(x -> x).toArray();
        //方法2：另外申请一个数组存放setRes中的元素,最后返回数组
        int[] arr = new int[resSet.size()];
        int j = 0;
        for(int i : resSet){
            arr[j++] = i;
        }
        return arr;
    }
}

3.还有一种方法是，因为后面力扣给两个数组补充了长度限制，那我们可以直接定义两个数组，然后分别遍历这两个数组，比如说遍历到2，那么新定义的数组索引为2的数值+1；之后再定义一个数组，根据这两个数组中数值均不为0的索引存入结果数组

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] hash1 = new int[1002];
        int[] hash2 = new int[1002];
        for(int i : nums1)
            hash1[i]++;
        for(int i : nums2)
            hash2[i]++;
        List<Integer> resList = new ArrayList<>();
        for(int i = 0; i < 1002; i++)
            if(hash1[i] > 0 && hash2[i] > 0)
                resList.add(i);
        int index = 0;
        int res[] = new int[resList.size()];
        for(int i : resList)
            res[index++] = i;
        return res;
    }
}

---

1. 快乐数
   
   建议：这道题目也是set的应用，其实和上一题差不多，就是 套在快乐数一个壳子
   
   题目链接/文章讲解：https://programmercarl.com/0202.快乐数.html

题目感想：

1.最简单的方法就是计算然后去set里面找是否出现过，没出现就存起来，直到结果为1或者出现重复的就结束；

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> record = new HashSet<>();
        while (n != 1 && !record.contains(n)) {
            record.add(n);
            n = getNextNumber(n);
        }
        return n == 1;
    }

    private int getNextNumber(int n) {
        int res = 0;
        while (n > 0) {
            int temp = n % 10;
            res += temp * temp;
            n = n / 10;
        }
        return res;
    }
}

2.还有一个方法就是用到了快慢指针，慢指针一次走一步，快指针一次走两步，之后比较他们的出的值是否有为1的或者他们的值是否相等，这样就不用存储了！！！是不是很熟悉，没错，我们在找链表中的环的时候也用到了这个，太有意思了。

class Solution {

     public int getNext(int n) {
        int totalSum = 0;
        while (n > 0) {
            int d = n % 10;
            n = n / 10;
            totalSum += d * d;
        }
        return totalSum;
    }

    public boolean isHappy(int n) {
        int slowRunner = n;
        int fastRunner = getNext(n);
        while (fastRunner != 1 && slowRunner != fastRunner) {
            slowRunner = getNext(slowRunner);
            fastRunner = getNext(getNext(fastRunner));
        }
        return fastRunner == 1;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/happy-number/solutions/224894/kuai-le-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3.还有一种是数学解法，这个就是找到一个三位数字可能会进入的循环链然后存起来，只要后面的计算的数字在这个循环链中那么就是不能为1的

class Solution {

    private static Set<Integer> cycleMembers =
        new HashSet<>(Arrays.asList(4, 16, 37, 58, 89, 145, 42, 20));

    public int getNext(int n) {
        int totalSum = 0;
        while (n > 0) {
            int d = n % 10;
            n = n / 10;
            totalSum += d * d;
        }
        return totalSum;
    }

    public boolean isHappy(int n) {
        while (n != 1 && !cycleMembers.contains(n)) {
            n = getNext(n);
        }
        return n == 1;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/happy-number/solutions/224894/kuai-le-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

感兴趣的可以去力扣看看详细的题解；

---

1. 两数之和
   
   建议：本题虽然是 力扣第一题，但是还是挺难的，也是 代码随想录中 数组，set之后，使用map解决哈希问题的第一题。
   
   建议大家先看视频讲解，然后尝试自己写代码，在看文章讲解，加深印象。
   
   题目链接/文章讲解/视频讲解：https://programmercarl.com/0001.两数之和.html

题目感想：

1.简单的方法有两种，一种是在set中匹配自己需要的，匹配不到把自己加进去，然后循环；另外一种是，给这个数组排序，然后两个指针分布数组两端，根据和目标的大小进行缩进；

//使用哈希表
public int[] twoSum(int[] nums, int target) {
    int[] res = new int[2];
    if(nums == null || nums.length == 0){
        return res;
    }
    Map<Integer, Integer> map = new HashMap<>();
    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中
    }
    return res;
}

//使用哈希表方法2
public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> indexMap = new HashMap<>();
    for(int i = 0; i < nums.length; i++){
        int balance = target - nums[i];  // 记录当前的目标值的余数
        if(indexMap.containsKey(balance)){  // 查找当前的map中是否有满足要求的值
            return new int []{i, indexMap.get(balance)}; //  如果有，返回目标值
        } else{
            indexMap.put(nums[i], i); //  如果没有，把访问过的元素和下标加入map中
        }
    }
    return null;
}

//使用双指针
public int[] twoSum(int[] nums, int target) {
    int m=0,n=0,k,board=0;
    int[] res=new int[2];
    int[] tmp1=new int[nums.length];
    //备份原本下标的nums数组
    System.arraycopy(nums,0,tmp1,0,nums.length);
    //将nums排序
    Arrays.sort(nums);
    //双指针
    for(int i=0,j=nums.length-1;i<j;){
        if(nums[i]+nums[j]<target)
            i++;
        else if(nums[i]+nums[j]>target)
            j--;
        else if(nums[i]+nums[j]==target){
            m=i;
            n=j;
            break;
        }
    }
    //找到nums[m]在tmp1数组中的下标
    for(k=0;k<nums.length;k++){
        if(tmp1[k]==nums[m]){
            res[0]=k;
            break;
        }
    }
    //找到nums[n]在tmp1数组中的下标
    for(int i=0;i<nums.length;i++){
        if(tmp1[i]==nums[n]&&i!=k)
            res[1]=i;
    }
    return res;
}