【算法系列篇】哈希表

前言

哈希表（Hash Table）是一种依赖哈希函数组织数据，以达到常数级别时间复杂度，插入和搜索都非常高效的数据结构。它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。哈希表在查询数据方面有着突出的优势。那么今天我将为大家分享关于哈希表方面的算法。

1. 两数之和

https://leetcode.cn/problems/two-sum/?envType=list&envId=9Lulrn6r

1.1 题目要求

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
1
2
3

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
1
2

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]
1
2

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案
1
2
3
4

class Solution {
    public int[] twoSum(int[] nums, int target) {

    }
}
1
2
3
4
5

1.2 做题思路

这道题目的要求很简单，就是在数组中查找两个和为 target 的数。使用暴力解法就是列举出数组中任意两个数的组合，看它们的和是否等于target，暴力解法的时间复杂度为 O(N*2) 。

既然是查询的话，我们就可以用到哈希表这个数据结构来降低时间复杂度。使用哈希表只需要遍历一遍数组，当遍历到一个数的时候，就看哈希表中是否存在一个数等于 target - nums[i] 如果有则返回当前这个数的下标和哈希表中存储的 target - num[i] 的下标；如果不存在，则将该位置的数作为 key 值，该位置的下标作为 value 值存放进哈希表中。

1.3 Java代码实现

class Solution {
    public int[] twoSum(int[] nums, int target) {
    	//创建出一个哈希表
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int t = target - nums[i];
            if (map.containsKey(t)) return new int[]{i, map.get(t)};
            map.put(nums[i], i);
        }

        return new int[]{-1,-1};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 判断是否为字符重排

https://leetcode.cn/problems/check-permutation-lcci/?envType=list&envId=9Lulrn6r

2.1 题目要求

给定两个由小写字母组成的字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。

示例 1：

输入: s1 = "abc", s2 = "bca"
输出: true 
1
2

示例 2：

输入: s1 = "abc", s2 = "bad"
输出: false
1
2

说明：

0 <= len(s1) <= 100 
0 <= len(s2) <= 100 
1
2

class Solution {
    public boolean CheckPermutation(String s1, String s2) {

    }
}
1
2
3
4
5

2.2 做题思路

判断是否为字符重排的方法就是看字符串 str2 中的字符是否都包含且只包含字符串 str1 中的字符，要想判断字符串 str2 中的字符是否存在于字符串 str1 中且数量一样，就可以用到哈希表来作为存储的容器。先遍历一遍字符串 str1，将字符串 str1 中遇到的字符以及字符出现的次数存储下来，然后在遍历字符串 str2 中的每个字符的时候就看哈希表中是否存在这个字符。

2.3 Java代码实现

class Solution {
    public boolean CheckPermutation(String s1, String s2) {
        int len1 = s1.length();
        int len2 = s2.length();
        //当两个字符串长度不相同的时候可以直接返回
        if (len1 != len2) return false;
        //这里使用数组模拟出哈希表是因为题目中给出了字符串中的字符都是小写字母
        //字符的范围给了，数组的存储和读取速度相较于哈希表速度更快
        int[] hash = new int[26];
        for (int i = 0; i < len1; i++) {
            hash[s1.charAt(i) - 'a']++;
        }

        for (int i = 0; i < len2; i++) {
            if (--hash[s2.charAt(i) - 'a'] < 0) return false;
        }

        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 存在重复元素

https://leetcode.cn/problems/contains-duplicate/?envType=list&envId=9Lulrn6r

3.1 题目要求

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

示例 1：

输入：nums = [1,2,3,1]
输出：true
1
2

示例 2：

输入：nums = [1,2,3,4]
输出：false
1
2

示例 3：

输入：nums = [1,1,1,3,3,4,3,2,4,2]
输出：true
1
2

提示：

1 <= nums.length <= 105
-109 <= nums[i] <= 109
1
2

class Solution {
    public boolean containsDuplicate(int[] nums) {

    }
}
1
2
3
4
5

3.2 做题思路

判断数组中是否存在重复元素，我们可以也可以使用哈希表这种数据结构来判断重复。HashSet 里面保证了容器中的元素只存在一个，具有去重性。

3.3 Java代码实现

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for(int n : nums) {
            if (set.contains(n)) return true;
            set.add(n);
        }

        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11

4. 存在重复元素II

https://leetcode.cn/problems/contains-duplicate-ii/?envType=list&envId=9Lulrn6r

4.2 题目要求

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [1,2,3,1], k = 3
输出：true
1
2

示例 2：

输入：nums = [1,0,1,1], k = 1
输出：true
1
2

示例 3：

输入：nums = [1,2,3,1,2,3], k = 2
输出：false
1
2

提示：

1 <= nums.length <= 105
-109 <= nums[i] <= 109
0 <= k <= 105
1
2
3

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {

    }
}
1
2
3
4
5

4.2 做题思路

这道题目是上面的重复元素的延展，这道题目不仅需要判断是否存在重复的元素，还需要判断这两个重复元素的下标的差值小于等于k。所以这个题目就需要用到哈希表 HashMap 这种数据结构，将某位置所表示的数字作为 key 值，该位置的下标作为 value 值存放在哈希表中。当该位置的数字在哈希表中存在的时候，就判断这两个数字的下标的差值是否小于等于k，如果小于则直接返回true，如果不小于，则需要更新哈希表中该key值的value值，因为这题目的要求是两个相等元素的下标差值小于等于k。

4.3 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])) {
                if(i - map.get(nums[i]) <= k) return true;
            }

			//这个操作不仅可以解决第一次添加的问题，也可以解决覆盖之前key的value
            map.put(nums[i], i);
        }

        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5. 字母异位词分组

https://leetcode.cn/problems/group-anagrams/

5.1 题目要求

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

示例 1:

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
1
2

示例 2:

输入: strs = [""]
输出: [[""]]
1
2

示例 3:

输入: strs = ["a"]
输出: [["a"]]
1
2

提示：

1 <= strs.length <= 104
0 <= strs[i].length <= 100
strs[i] 仅包含小写字母
1
2
3

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {

    }
}
1
2
3
4
5

5.2 做题思路

这个题目的意思就是将可以构成异位词的字符串分在一组，异位词就是两个字符串都是由相同字符以及字符数量相等的字符组成的字符串。但是这个题目有很多组的异位词，我们遍历字符串的时候又该如何判断该字符串属于哪一个组呢？难道要在遍历一遍哈希表吗，这样时间复杂度也会很高，所以我们不使用这个方法。

这道题的思路是，将字符串经过 ASCII 码排序之后作为key值存放在哈希表中，然后哈希表的value值是一个链表，用来存储同一组异位词，当遍历字符串的时候也是将该字符串进行 ASCII 码排序之后将这个字符串放入指定的key-value中。

5.3 Java代码实现

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for(String s : strs) {
        	//将字符串转换为字符数组之后进行排序，然后再转换为字符串
            char[] tmp = s.toCharArray();
            Arrays.sort(tmp);
            String key = new String(tmp);

			//如果哈希表中不存在key值，则需要先创建出key的List
            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<String>());
            }
            //将该字符串添加进对应分组中
            map.get(key).add(s);
        }

        return new ArrayList(map.values());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20