【演算法】雜湊表法四部曲
阿新 • • 發佈：2021-03-27
# 雜湊表
散列表（Hash table，也叫雜湊表），是**根據關鍵碼值(Key value)而直接進行訪問**的資料結構。也就是說，它**通過把關鍵碼值對映到表中一個位置來訪問記錄**，以加快查詢的速度。這個對映函式叫做雜湊函式，存放記錄的陣列叫做散列表。
給定表M，存在函式f(key)，對任意給定的關鍵字值key，代入函式後若能得到包含該關鍵字的記錄在表中的地址，則稱表M為雜湊(Hash）表，函式f(key)為雜湊(Hash) 函式。
關鍵碼值與地址一一對映
# 適用場景
適用於**關鍵字與某一值一一對應**，即 可使用鍵值對map，而hashmap是鍵值對中較好的實現類
關鍵詞：一一對應
# 遍歷雜湊表的四種方式
```
public static void main(String[] args) {
Map map=new HashMap();
map.put("1", "value1");
map.put("2", "value2");
map.put("3", "value3");
map.put("4", "value4");
//第一種：普通使用，二次取值
// 遍歷鍵，取出值
System.out.println("\n通過Map.keySet遍歷key和value：");
for(String key:map.keySet()) {
System.out.println("Key: "+key+" Value: "+map.get(key));
}
//第二種
// 使用Map.entrySet()的迭代器
System.out.println("\n通過Map.entrySet使用iterator遍歷key和value: ");
Iterator map1it=map.entrySet().iterator();
while(map1it.hasNext()) {
Map.Entry entry=(Entry) map1it.next();
System.out.println("Key: "+entry.getKey()+" Value: "+entry.getValue());
}
//第三種：推薦，尤其是容量大時
// foreach
System.out.println("\n通過Map.entrySet遍歷key和value");
for(Map.Entry entry: map.entrySet()) {
System.out.println("Key: "+ entry.getKey()+ " Value: "+entry.getValue());
}
//第四種
// 遍歷value
System.out.println("\n通過Map.values()遍歷所有的value，但不能遍歷key");
for(String v:map.values()) {
System.out.println("The value is "+v);
}
}
```
輸出結果：
```
通過Map.keySet遍歷key和value：
Key: 1 Value: value1
Key: 2 Value: value2
Key: 3 Value: value3
Key: 4 Value: value4
通過Map.entrySet使用iterator遍歷key和value:
Key: 1 Value: value1
Key: 2 Value: value2
Key: 3 Value: value3
Key: 4 Value: value4
通過Map.entrySet遍歷key和value
Key: 1 Value: value1
Key: 2 Value: value2
Key: 3 Value: value3
Key: 4 Value: value4
通過Map.values()遍歷所有的value，但不能遍歷key
The value is value1
The value is value2
The value is value3
The value is value4
```
【推薦】使用entrySet遍歷Map類集合KV，而不是keySet方式進行遍歷。
說明：keySet 其實是遍歷了2次，一次是轉為Iterator物件，另一次是從hashMap中取出key所對應的value。而entrySet只是遍歷了一次就把key和value都放到了entry中，效
率更高。如果是JDK8，使用Map.foreach方法。
正例：values()返回的是V值集合，是一個list集合物件; keySet()返回的是K值集合，是一個Set集合物件; entrySet()返回的是K-V值組合集合。
# 記錄陣列中元素出現頻數
遍歷nums1，使用雜湊表儲存關鍵字，以及他們出現的次數
方法一：遇到空的就賦初值，非空就+1
```
// 1. 遍歷nums1，使用雜湊表儲存關鍵字，以及他們出現的次數
Map map = new HashMap<>();
for (int i = 0; i < nums1.length; i++) {
if (map.get(nums1[i]) != null) {
map.put(nums1[i], map.get(nums1[i])+1);
} else {
map.put(nums1[i], 1);
}
}
```
---
方法二：使用`getOrDefault()`
```
Map map = new HashMap();
for (int num : nums1) {
int count = map.getOrDefault(num, 0) + 1;
map.put(num, count);
}
```
---
方法三：如果元素固定，那麼我們可以就使用一個一維陣列來儲存他們出現的頻數。這也是雜湊表法。
遍歷字串 p，記錄字元頻數
```
int[] sArr = new int[26];
for (int i = 0; i < p.length(); i++) {
sArr[s.charAt(i) - 'a']++;
}
```
方法四：如果要求元素只出現一次 或者判斷是否有重複元素，那就可以用雜湊集合
```
Set set = new HashSet();
for (int num : nums1) {
// 新增此元素至 Set，加入失敗那就代表有重複
if(!set.add(num)) {
return false;
}
}
```
# 例項
## [1. 兩數之和](https://leetcode-cn.com/problems/two-sum/)
給定一個整數陣列 nums 和一個整數目標值 target，請你在該陣列中找出 和為目標值 的那 兩個 整數，並返回它們的陣列下標。
你可以假設每種輸入只會對應一個答案。但是，陣列中同一個元素不能使用兩遍。
你可以按任意順序返回答案。
示例 1：
輸入：nums = [2,7,11,15], target = 9
輸出：[0,1]
解釋：因為 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
輸入：nums = [3,2,4], target = 6
輸出：[1,2]
示例 3：
輸入：nums = [3,3], target = 6
輸出：[0,1]
答案
```
class Solution {
public int[] twoSum(int[] nums, int target) {
// 雜湊表用來存放（關鍵字，下標）
Map map = new HashMap<>();
// 遍歷陣列，每次遇到一個元素判斷雜湊表裡面有沒有與其對應的target - nums[i]元素
// 如果有就返回下標，如果沒有就把它的關鍵字和下標放進去，
for (int i = 0; i < nums.length; i++) {
Integer index = map.get(target - nums[i]);
if (index != null) {
return new int[]{index, i};
} else {
map.put(nums[i], i);
}
}
return null;
}
}
```
## [有效的字母異位詞](https://leetcode-cn.com/problems/valid-anagram)
給定兩個字串 s 和 t ，編寫一個函式來判斷 t 是否是 s 的字母異位詞。
示例 1:
輸入: s = "anagram", t = "nagaram"
輸出: true
示例 2:
輸入: s = "rat", t = "car"
輸出: false
說明:
你可以假設字串只包含小寫字母。
進階:
如果輸入字串包含 unicode 字元怎麼辦？你能否調整你的解法來應對這種情況？
## 答案
### 方法一：排序
t 是 s 的異位詞等價於「兩個字串排序後相等」。因此我們可以對字串 s 和 t 分別排序，看排序後的字串是否相等即可判斷。此外，如果 s 和 t 的長度不同，t 必然不是 s 的異位詞。
Java
```
class Solution {
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) {
return false;
}
char[] str1 = s.toCharArray();
char[] str2 = t.toCharArray();
Arrays.sort(str1);
Arrays.sort(str2);
return Arrays.equals(str1, str2);
}
}
```
複雜度分析
- 時間複雜度：$O(n \log n)$，其中 n 為 s 的長度。排序的時間複雜度為 $O(n\log n)$，比較兩個字串是否相等時間複雜度為 $O(n)$，因此總體時間複雜度為 $O(n \log n+n)=O(n\log n)$。
- 空間複雜度：$O(\log n)$。排序需要 $O(\log n)$ 的空間複雜度。注意，在某些語言（比如 Java & JavaScript）中字串是不可變的，因此我們需要額外的 $O(n)$ 的空間來拷貝字串。但是我們忽略這一複雜度分析，因為：
這依賴於語言的細節；
這取決於函式的設計方式，例如，可以將函式引數型別更改為 char[]。
### 方法二：雜湊表
> table = new HashMap();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
table.put(ch, table.getOrDefault(ch, 0) + 1);
}
for (int i = 0; i < t.length(); i++) {
char ch = t.charAt(i);
table.put(ch, table.getOrDefault(ch, 0) - 1);
if (table.get(ch) < 0) {
return false;
}
}
return true;
}
}
```
複雜度分析
- 時間複雜度：$O(n)$，其中 n 為 s 的長度。
- 空間複雜度：$O(S)$，其中 S 為字符集大小，此處 $S=26$。
## [劍指 Offer 61. 撲克牌中的順子](https://leetcode-cn.com/problems/bu-ke-pai-zhong-de-shun-zi-lcof/)
從撲克牌中隨機抽5張牌，判斷是不是一個順子，即這5張牌是不是連續的。2～10為數字本身，A為1，J為11，Q為12，K為13，而大、小王為 0 ，可以看成任意數字。A 不能視為 14。
示例 1:
```
輸入: [1,2,3,4,5]
輸出: True
```
示例 2:
```
輸入: [0,0,1,2,5]
輸出: True
```
### 答案
```
class Solution {
public boolean isStraight(int[] nums) {
Set repeat = new HashSet<>();
int max = 0, min = 14;
for(int num : nums) {
if(num == 0) continue; // 跳過大小王
max = Math.max(max, num); // 最大牌
min = Math.min(min, num); // 最小牌
// 新增此牌至 Set，加入失敗那就代表有重複
if(!repeat.add(num)) return false; // 若有重複，提前返回 false
}
return max - min + 1 <= 5; // 最大牌 - 最小牌 + 1 <= 5 則可構成順子，因為包含有0、0、0、9、11的情況