精品刷題路線參考：
雜湊表基礎
雜湊表也叫雜湊表，雜湊表是一種對映型的資料結構。
雜湊表是根據關鍵碼的值而直接進行訪問的資料結構。
就好像老三和老三的工位：有人來找老三，前臺小姐姐一指，那個像狗窩一樣的就是老三的工位。
總體來說，雜湊表由兩個要素構成：桶陣列與雜湊函式。
桶及桶陣列
雜湊表使用的桶陣列（Bucket array ），其實就是一個容量為 N 的普通陣列，只不過在這裡，我們將其中的每個單元都想象為一個“桶”（Bucket），每個桶單元裡都可以存放一個條目。
比如，所有的關鍵碼都是整數，我們就可以直接將 key 為關鍵碼的那個條目存放在桶單元 A[key]內；為了節省空間，空閒的單元都被置為 null。
例如，吳零、熊大、王二、張三、李四，我們可以把他們放到桶陣列對應的位置。
那麼查詢的時候，我們根據對應的名字編號，直接去找陣列的下標就行了，這樣一來，時間複雜度就是O(1)。
但是老三表示，怎麼會老有人的名字老叫什麼三、什麼四的，起碼得叫個"阿剛"、"小明"吧。
那麼問題來了，阿剛、小明我們應該放在哪裡呢？他們沒法直接放到桶陣列的對應下標位置。
所以，就引入了我們第二個關鍵要素雜湊函式。
雜湊函式
為了讓對映能推廣到所有情況，我們需要藉助雜湊函式 hashFunction對映到桶陣列對應的位置。
例如，我們上面說到的一些平平無奇的名字，阿剛、小明……我們要把它們對映到對應的桶中。
一般情況下，雜湊函式通過對名字的HashCode進行運算，將名字對映到桶陣列對應的索引。
雜湊碰撞
我們最理想的情況，就是通過雜湊計算，各個元素找到空閒的坑位，但是現實往往不那麼盡如人意，有時候，會發現，心上的城，已經長滿了別人家的青藤。
阿剛和小明對映到了同一個位置，但這個位置只能容下一個人，這就叫雜湊碰撞。
所以為了儘可能避免雜湊碰撞呢，就需要精心設計雜湊函式，我們希望雜湊函式滿足以下要求：
- 必須是一致的
- 計算簡單
- 雜湊地址分佈均勻
雜湊函式構造方法
雜湊函式的構造方法有很多，如下圖，有些方法見名知義，篇幅所限，就不多講。
這裡提一下HashMap的雜湊函式：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
整個過程大概如下：
- 利用hashCode()方法獲取int型別的hashCode
- hashCode的高16位和hashCode的低16位做一個異或運算
hashCode右移16位，正好是32bit的一半。與自己本身做異或操作（相同為0，不同為1）。就是為了混合雜湊值的高位和地位，增加低位的隨機性。並且混合後的值也變相保持了高位的特徵。
- 32位int型hashCode範圍過大，需要與桶陣列長度取模運算，得到索引值
int index = hash & (arrays.length-1);
HashMap的雜湊函式是非常優秀的設計，很值得學習。
處理雜湊衝突的辦法
即使再好的設計，也難免發生雜湊碰撞。
那麼，發生雜湊碰撞，應該怎麼處理呢？
拉鍊法
阿剛和小明在桶中發生了衝突，那我們在桶陣列接一個小尾巴——用一個連結串列將他們倆存起來就可以了。
除了這個，還有啥辦法呢？
唉，假如我們的桶陣列還是有坑位，我們可以重新分配，這就是?
線性探測法
使用線性探測法的前提是桶陣列裡面還有坑位。
常見的線性探測法有：
- 開放地址法
開放地址法就是一旦發生衝突，就去尋找下一個空的雜湊地址。
尋找下一個空的雜湊地址叫做探測，常見的探測方法有：線性探測法、二次探測法、隨機探測法。
-
再雜湊法
這個方法也很簡單，利用不同的雜湊函式再求得一個雜湊地址，直到不出現衝突為止。
- 公共溢位區法
公共溢位區法就是再建一個公共溢位區，儲存發生衝突的元素。
Java中的雜湊結構
在Java的刷題中，我們有兩種常用的雜湊結構。
一種是HashMap，<Key，Value>型的Hash結構。
一種是HashSet，沒有重複元素的集合。
| 集合 | 底層實現 | 是否有序 | 數值是否可以重複 | 查詢效率 | 增刪效率 |
|---|---|---|---|---|---|
| HashMap | 陣列/連結串列/紅黑樹 | 否 | key不可重複，value可重複 | O(1) | O(1) |
| HashSet | 陣列/連結串列/紅黑樹 | 否 | 不可重複 | O(1) | O(1) |
通常什麼樣的題目用Hash表呢？
還記得我們前面做過的求數字出現的次數嗎？
判斷一個元素是否出現過的場景，保底的我們應該立即想到雜湊。
刷題現場
LeetCode1.兩數之和 是比較典型的使用雜湊表的例子，前面已經做過了——LeetCode通關：陣列十七連，真是不簡單，就不再來一遍了。
LeetCode242. 有效的字母異位詞
☕ 題目：242. 有效的字母異位詞 (https://leetcode-cn.com/problems/valid-anagram/)
❓ 難度：簡單
? 描述：
給定兩個字串 s 和 t ，編寫一個函式來判斷 t 是否是 s 的字母異位詞。
注意：若 s 和 t 中每個字元出現的次數都相同，則稱 s 和 t 互為字母異位詞。
示例 1:
輸入: s = "anagram", t = "nagaram"
輸出: true
示例 2:
輸入: s = "rat", t = "car"
輸出: false
? 思路：
既然都說了要用雜湊法，就懶得再寫暴力法了。
我們可以用HashMap把字元出現的頻率儲存起來，s 出現一次頻率+1，t 出現一次頻率，判斷最後hash所有位置value是否都為0。
思路很簡單，程式碼實現如下：
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) {
return false;
}
Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < s.length(); i++) {
char sChar = s.charAt(i);
char tChar = t.charAt(i);
map.put(sChar, map.getOrDefault(sChar, 0) + 1);
map.put(tChar, map.getOrDefault(tChar, 0) - 1);
}
for (Integer v : map.values()) {
if (v != 0) {
return false;
}
}
return true;
}
還有另外一種實用陣列作為雜湊表的方法，據說可以加速，但是個人覺得用HashMap的方式比較好理解和記憶。
? 時間複雜度：O(n)
? 空間複雜度：O(n)
LeetCode1002. 查詢常用字元
☕ 題目：1002. 查詢常用字元 (https://leetcode-cn.com/problems/find-common-characters/)
❓ 難度：簡單
? 描述：
給定僅有小寫字母組成的字串陣列 A，返回列表中的每個字串中都顯示的全部字元（包括重複字元）組成的列表。例如，如果一個字元在每個字串中出現 3 次，但不是 4 次，則需要在最終答案中包含該字元 3 次。
你可以按任意順序返回答案。
示例 1：
輸入：["bella","label","roller"]
輸出：["e","l","l"]
示例 2：
輸入：["cool","lock","cook"]
輸出：["c","o"]
LeetCode349. 兩個陣列的交集
☕ 題目：349. 兩個陣列的交集 (https://leetcode-cn.com/problems/intersection-of-two-arrays/)
❓ 難度：簡單
? 描述：
給定兩個陣列，編寫一個函式來計算它們的交集。
示例 1：
輸入：nums1 = [1,2,2,1], nums2 = [2,2]
輸出：[2]
示例 2：
輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出：[9,4]
? 思路：
注意，求交集，是需要去重的。既然說到去重，我們自然想到了HashSet。
我們可以用兩個HashSet，set1儲存nums1元素，遍歷nums2，判斷元素是否存在於set1，用set2儲存。
很好理解。
程式碼如下：
public int[] intersection(int[] nums1, int[] nums2) {
int len1 = nums1.length;
int len2 = nums2.length;
if (len1 == 0 || len2 == 0) {
return new int[0];
}
Set<Integer> set1 = new HashSet<>();
Set<Integer> set2 = new HashSet<>();
for (int i = 0; i < len1; i++) {
set1.add(nums1[i]);
}
for (int j = 0; j < len2; j++) {
if (set1.contains(nums2[j])) {
set2.add(nums2[j]);
}
}
int[] result = new int[set1.size()];
int k = 0;
for (int value : set2) {
result[k++] = value;
}
return result;
}
? 時間複雜度：O(n)
? 空間複雜度：O(n)
LeetCode454. 四數相加 II
☕ 題目：454. 四數相加 II (https://leetcode-cn.com/problems/4sum-ii/)
❓ 難度：中等
? 描述：
給定四個包含整數的陣列列表 A , B , C , D ,計算有多少個元組 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
為了使問題簡單化，所有的 A, B, C, D 具有相同的長度 N，且 0 ≤ N ≤ 500 。所有整數的範圍在 -228 到 228 - 1 之間，最終結果不會超過 231 - 1 。
例如:
輸入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
輸出:
2
解釋:
兩個元組如下:
1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
? 思路：
我們的思路是四個陣列分兩組，一組存HashMap，另一組和HashMap比較。
- 首先定義 一個HashMap，key放A和B兩數之和，value 放A和B兩數之和出現的次數。
- 遍歷大A和大B陣列，統計兩個陣列元素之和，和出現的次數，放到map中。
- 定義int變數count，用來統計a+b+c+d = 0 出現的次數。
- 在遍歷大C和大D陣列，找到如果 0-(C+D) 在map中出現過的話，就用res把map中key出現的次數
- 最後返回統計值 count
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
Map<Integer, Integer> map = new HashMap<>();
int res = 0;
for (int i = 0; i < nums1.length; i++) {
for (int j = 0; j < nums2.length; j++) {
int sumAB = nums1[i] + nums2[j];
map.put(sumAB, map.getOrDefault(sumAB, 0) + 1);
}
}
for (int i = 0; i < nums3.length; i++) {
for (int j = 0; j < nums4.length; j++) {
int sumCD = -(nums3[i] + nums4[j]);
if (map.containsKey(sumCD)) {
res+=map.get(sumCD);
}
}
}
return res;
}
? 時間複雜度：O(n²)
? 空間複雜度：O(n)
LeetCode383. 贖金信
☕ 題目：454. 四數相加 II (https://leetcode-cn.com/problems/4sum-ii/)
❓ 難度：簡單
? 描述：
給定一個贖金信 (ransom) 字串和一個雜誌(magazine)字串，判斷第一個字串 ransom 能不能由第二個字串 magazines 裡面的字元構成。如果可以構成，返回 true ；否則返回 false。
(題目說明：為了不暴露贖金信字跡，要從雜誌上搜尋各個需要的字母，組成單詞來表達意思。雜誌字串中的每個字元只能在贖金信字串中使用一次。)
示例 1：
輸入：ransomNote = "a", magazine = "b"
輸出：false
示例 2：
輸入：ransomNote = "aa", magazine = "ab"
輸出：false
示例 3：
輸入：ransomNote = "aa", magazine = "aab"
輸出：true
? 思路
這個題解法也很好像。
用HashMap儲存報刊陣列字元以及字元出現的次數，遍歷贖金信陣列，取對應的字元。
注意，這裡每個字元只能使用一次，所以取字元的時候需要減1。
程式碼如下：
public boolean canConstruct(String ransomNote, String magazine) {
Map<Character, Integer> hash = new HashMap<>();
for (int i = 0; i < magazine.length(); i++) {
char m = magazine.charAt(i);
hash.put(m, hash.getOrDefault(m, 0) + 1);
}
for (int i = 0; i < ransomNote.length(); i++) {
char r = ransomNote.charAt(i);
if (!hash.containsKey(r)) {
return false;
}
if (hash.get(r) == 0) {
return false;
}
hash.put(r, hash.get(r) - 1);
}
return true;
}
? 時間複雜度：O(n)
? 空間複雜度：O(n)
LeetCode202. 快樂數
☕ 題目：202. 快樂數 (https://leetcode-cn.com/problems/happy-number/)
❓ 難度：簡單
? 描述：
編寫一個演算法來判斷一個數 n 是不是快樂數。
「快樂數」定義為：
- 對於一個正整數，每一次將該數替換為它每個位置上的數字的平方和。
- 然後重複這個過程直到這個數變為 1，也可能是 無限迴圈 但始終變不到 1。
- 如果 可以變為 1，那麼這個數就是快樂數。
如果 n 是快樂數就返回 true ；不是，則返回 false 。
示例 1：
輸入：19
輸出：true
解釋：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
示例 2：
輸入：n = 2
輸出：false
?思路：
這道題解題的關鍵在於也可能是 無限迴圈 但始終變不到 1。。
我們們肯定不能讓它取快樂數這個過程無限迴圈下去，但是它既然迴圈了，那麼各位數的平方和肯定會重複，這就成了判斷元素是否出現的問題。
這道題我們可以用HashSet儲存平方和，如果當前平方和已經出現過，說明已經開始無限迴圈。
public boolean isHappy(int n) {
Set<Integer> set = new HashSet<>();
while (true) {
int sum = getSum(n);
//開心數
if (sum == 1) {
return true;
}
//sum出現過
if (set.contains(sum)) {
return false;
} else {
set.add(sum);
}
n = sum;
}
}
/**
* @return int
* @Description: 獲取平方和
* @date 2021/8/11 22:41
*/
int getSum(int n) {
int sum = 0;
while (n > 0) {
int temp = n % 10;
sum += temp * temp;
n = n / 10;
}
return sum;
}
? 時間複雜度：O(logn)
? 空間複雜度：O(logn)
這道題還可以用雙指標的方式，用兩個數，一個快指標，一個慢指標，如果進入迴圈，最終兩個指標會相遇。
總結
還是一個順口溜：
簡單的事情重複做，重複的事情認真做，認真的事情有創造性地做！
我是三分惡，一個能文能武的全棧開發。
點贊、關注不迷路，我們們下期見！
博主是個演算法練習生，路線和思路參考如下大佬！建議關注！
參考：
[1]. https://github.com/youngyangyang04/leetcode-master
[2]. https://github.com/chefyuan/algorithm-base
[3]. 《資料結構與演算法》
[4]. 淺談HashMap中的hash演算法
[5]. 面試刷演算法，這些api不可不知!