leetcode面试题之哈希表

242. 有效的字母异位词

题目：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词

链接：https://leetcode.cn/problems/valid-anagram/

思路：哈希表 （用数组表示哈希表，前提是有限值）

1. 将每个字符映射到数组[0-25]的位置上
2. 遍历s数组对应值+1，遍历t数组对应值-1
3. 最后数组中的值都为0，表明成功

public boolean isAnagram(String s, String t) {
        // 思想：哈希表 
        // 将每个字符映射到数组[0-25]的位置上,遍历s数组对应值+1，遍历t数组对应值-1
        // 最后数组中的值都为0，表明成功
        int[] record = new int[26]; 
        // 遍历s
        for (char c : s.toCharArray()) {
            record[c - 'a'] += 1;
        }
        // 遍历t
        for (char c : t.toCharArray()) {
            record[c - 'a'] -= 1;
        }
        // 判断最终结果
        for (int i : record) {
            if (i != 0) return false;
        }
        return true;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

349. 两个数组的交集

题目：给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

链接：https://leetcode.cn/problems/intersection-of-two-arrays/

思路：HashSet，两个set

public int[] intersection(int[] nums1, int[] nums2) {
        // 初始条件判断
        if (nums1.length == 0 || nums2.length == 0) return new int[0];
        Set<Integer> set1 = new HashSet<>(), res = new HashSet<>();
        // 遍历nums1，存放值
        for (int i : nums1) {
            set1.add(i);
        }
        // 遍历nums2，如果set1中有相同的值，则放入返回set中
        for (int i : nums2) {
            if (set1.contains(i)) {
                res.add(i);
            }
        }
        // 返回值由set转为数组
        return res.stream().mapToInt(i->i).toArray();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

202. 快乐数

题目：编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

链接：https://leetcode.cn/problems/happy-number/

思路：双指针
题目指出：可能无限循环
破循环：双指针，快指针一次走两步，慢指针一次走一步，相遇即产生循环
1.getSum求得每位的平方和
2.双指针破循环，看是否由1引起循环，如果是即为快乐数

class Solution {
    // 求得每位的平方和
    public int getSum(int n) {
        int sum = 0;
        while (n > 0) {
            int bit = n % 10;
            sum += bit * bit;
            n = n / 10;
        }
        return sum;
    }
    public boolean isHappy(int n) {
        int slow = n, fast = n; // 定义快慢指针
        // 快指针一次走两步，慢指针一次走一步，当两个指针相遇时，即开始循环
        // 如果循环是由1引起的，则是快乐数
        do {
            slow = getSum(slow);
            fast = getSum(fast);
            fast = getSum(fast);
        } while (slow != fast);
        return slow == 1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1. 两数之和

题目：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

链接：https://leetcode.cn/problems/two-sum/

思路：哈希表
===> <元素值, 下标>
判断target - nums[i]值是否在哈希表中
containsKey方法：获取哈希表的key

public int[] twoSum(int[] nums, int target) {
        // 哈希表
        Map<Integer, Integer> map = new HashMap<>();
        int n = nums.length;
        for (int i = 0; i < n; i ++) {
            if (map.containsKey(target - nums[i])) {
                return new int[]{map.get(target - nums[i]), i};
            }
            map.put(nums[i], i);
        }
        return null;
    }
1
2
3
4
5
6
7
8
9
10
11
12

454. 四数相加 II

题目：给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n；nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

链接：https://leetcode.cn/problems/4sum-ii/

思路：哈希表

1. 第一次遍历，将a b的和放入 map
2. 第二次遍历，判断 a+b ?= -(c+d),相等说明满足条件，放入res

public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        // <元素值，次数>
        Map<Integer, Integer> map = new HashMap<>();
        // 第一次遍历，将a b的和放入 map
        for (int a : A) {
            for (int b : B) {
                int sum = a + b;
                if (map.containsKey(sum)) {
                    map.put(sum, map.get(sum)+1);
                } else {
                    map.put(sum, 1);
                }
            }
        }
        int res = 0;
        // 第二次遍历，判断 a+b ?= -(c+d),相等说明满足条件，放入res
        for (int c : C) {
            for (int d : D) {
                int sum = - (c + d);
                if (map.containsKey(sum)) {
                    res += map.get(sum);
                }
            }
        }
        return res;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

383. 赎金信

题目：给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

链接：https://leetcode.cn/problems/ransom-note/

思路：与242题类似，有限值，用数组表示哈希表映射

1. 数组用于记录字符的出现次数
2. 分别遍历magazine ransomNote，用record记录，magazine中的字符++，ransomNote中的字符–，如果最后record中的值>0，说明满足条件

public boolean canConstruct(String ransomNote, String magazine) {
        int[] record = new int[26]; 
        for (char c : magazine.toCharArray()) {
            record[c - 'a'] += 1;
        }
        for (char c : ransomNote.toCharArray()) {
            record[c - 'a'] -= 1;
        }
        for (int i : record) {
            if (i < 0) return false;
        }
        return true;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13