代码随想录算法训练营第六天|242.有效的字母异位词、349.两个数组的交集、202.快乐数、1.两数之和

哈希表

定义：哈希表是根据关键码的值而直接进行访问的数据结构

💡 利用哈希函数，通常用来快速判断一个元素是否出现在集合中

哈希函数

通过特定编码方式来将其他数据格式转化为不同的数值的函数

同时我们会通过取模来保证得到的数值始终落在哈希表的size范围内，若是有同时映射到哈希表同一个索引下标的值，则会产生哈希碰撞

哈希碰撞：

当多个数值同时映射到一个位置时，就产生了哈希碰撞，此时有两种解决方法

拉链法：

即在碰撞的地方生成一个链表，逐个保存后来的值

线性探测法：

若产生冲突，则冲突位置向下找一个位置保存信息，故使用时一定要保证tableSize大于dataSize

常见的三种哈希结构：

使用哈希法解决问题时，通常选择下列三种数据结构：

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

---

总结：

当需要快速判断一个元素是否出现在集合中时，就应当考虑哈希法。

但哈希法的使用也是存在弊端的：他牺牲了空间来换取时间，使用时同样也需要注意

---

题目链接：242. 有效的字母异位词 - 力扣（LeetCode）

初见思路：

使用两个数组，分别保存每个字母出现的个数，随即一起遍历，若有不同返回false，否则返回true

但在看完代码随想录中的代码后，发现没必要创建两个数组，只需要在一个数组上进行比对即可，第一个数组存在则++，在第二个数组中存在则–,最终遍历数组进行判断即可，ac代码如下：

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] jud = new int[26];
        for(int i = 0; i < s.length();i++){
            jud[s.charAt(i)-'a']++;
        }
        for(int i = 0; i < t.length();i++){
            jud[t.charAt(i)-'a']--;
        }
        for(int i = 0; i < 26;i++){
            if(jud[i] != 0){
                return false;
            }
        }
        return true;
    }
}

---

题目链接：349. 两个数组的交集 - 力扣（LeetCode）

初见思路：

本题与上一道题目类似，同样是判断字符是否出现过的问题，但不同的是，本题中的元素会反复出现，但我们需要做的是去除重复的元素后再次返回，因此本题中我使用了两个boolean数组对元素是否出现过进行判断，当其出现过一次后，就不再在result数组中添加他。ac代码如下：

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int ans[] = new int[1000];
        boolean judged[] = new boolean[1000];
        for(int i = 0; i <nums1.length;i++){
                ans[nums1[i]]++;
        }

        int num = 0;
        for(int i = 0; i <nums2.length;i++){
            if(ans[nums2[i]] > 0 && !judged[nums2[i]]){
                num++;
                judged[nums2[i]] = true;
            }
        }
        boolean judged2[] = new boolean[1000];
        int[] result = new int[num];
        num = 0;
        for(int i = 0; i <nums2.length;i++){
            if(ans[nums2[i]] > 0 && !judged2[nums2[i]]){
                result[num++] = nums2[i];
                judged2[nums2[i]] = true;
            }
        }
        return result;
    }

---

上述思路固然可行，但却会造成极大的空间浪费，使用数组进行书写由于题目中会有一些空缺的未使用的元素，故会产生空间浪费，更好的思路应当是使用hashmap对题目进行处理，具体代码如下：

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
       if(nums1 == null || nums2 == null || nums1.length == 0|| nums2.length == 0){
           return new int[0];
       }
       Set<Integer> set1 = new HashSet<>();
       Set<Integer> resSet = new HashSet<>();

       for(int i:nums1){
           set1.add(i);
       }

       for(int i:nums2){
           if(set1.contains(i)){
               resSet.add(i);
           }
       }
        return resSet.stream().mapToInt(x->x).toArray();
    }

}

总结

做题后发现使用hashset的通过用时相对于代码一来讲大了很多，且空间使用也并没有好到哪里去，这是因为:

直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。

不要小瞧 这个耗时，在数据量大的情况，差距是很明显的。

还是应当多看看hashset的相关函数，本题尽管明白了思路，但完全不知道stl中hashSet的写法以及具体函数，还是不能很好的完成问题

---

题目链接：202. 快乐数 - 力扣（LeetCode）

初见是没有思路的，只得看了代码随想录中的题解：

→本题看起来像是一道数学问题，实则不然，由于出现一次的结果就一定会在下次循环中出现，因此只需要判断数字是否出现过即可，出现过立即停止循环，否则不停的进行数字的变换判断即可，重点还是hashset的使用，具体ac代码如下：

class Solution {
    int getNextNum(int n){
        int result = 0;
        while (n > 0){
            int last = n % 10;
            n /= 10;
            result += last * last;
        }
        return result;
    }
    public boolean isHappy(int n) {
        int last;
        Set<Integer> record = new HashSet<>();
        while(n != 1 && !record.contains(n)){
            record.add(n);
            n = getNextNum(n);
        }
        return n == 1;
    }
}

---

题目链接：1. 两数之和 - 力扣（LeetCode）

思路：

要想到此题应该使用什么数据结构，由于我们要同时使用到给出的数组中的下标值以及其具体的值，故选择Hashmap对题目进行处理，具体操作为生成一个result[2]数组用来保存结果，对于给出数组的每个元素，判断减去其值的值是否在map中，若在则可直接赋值result数组并返回，若不在则将该元素加入到hashMap中去，这样做通过一次循环就能够完成判断。

ac代码如下：

class Solution {
    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 tmp = target - nums[i];
            if (map.containsKey(tmp)) {
                res[1] = i;
                res[0] = map.get(tmp);
            }
            map.put(nums[i], i);
        }
        return res;
    }

}