【力扣100】简要总结之哈希

---

1、两数之和

思路

使用map，【键】：元素值 【值】：下标
遍历原值，找对应的值是否存在于map中
若存在，返回两者下标
若不存在，将当前值与下标存入map

代码（Go）

func twoSum(nums []int, target int) []int {
	m := make(map[int]int) // 创建一个 map，存储已经遍历过的数值及其索引
	for index, val := range nums {
		if preindex, ok := m[target-val]; ok { // 查找 map 中键为 target-val 的值是否存在
			return []int{index, preindex} // 找到匹配的索引对，返回
		} else {
			m[val] = index // 如果没有匹配的，存入 map
		}
	}
	return []int{} // 没找到，返回空切片
}

// map中的存储结构为 {key：数据元素，value：数组元素对应的下标}

2、字母异位词分组

（1）计数法

思路

由于字母异位词的字符串包含相同的字母，且每个字母的出现次数相同，可以用一个数组来记录每个字母的出现次数。
例如，字符串 “eat” 和 “tea”，字母出现次数是相同的：{e: 1, a: 1, t: 1}。
这样我们可以用一个固定大小的数组（长度为 26，表示字母 ‘a’ 到 ‘z’）作为哈希表的键。

实现

1，遍历每个字符串，创建一个大小为 26 的数组，用来记录每个字母的出现次数。
2，用该数组作为哈希表的键，把原字符串添加到对应的键下。
3，最后遍历哈希表，得到所有的字母异位词组。

代码（Go）

// 计数法
func groupAnagrams(strs []string) [][]string {
	mp := map[[26]int][]string{} // {}表示初始化一个空的map  mp：将字母异位词分组的临时数据结构
	for _, str := range strs {
		cnt := [26]int{} // 即mp的键
		for _, b := range str {
			cnt[b-'a']++
		}
		mp[cnt] = append(mp[cnt], str) // 更新map中cnt键对应的值（字符串切片）
	}
	ans := make([][]string, 0, len(mp)) // [][]string相当于c的string[][]  len(mp) 是总的字母异位词组数
	for _, v := range mp {              // 返回键、值
		ans = append(ans, v)
	}
	return ans
}

（2）排序法

思路

字母异位词的字符串可以通过排序变成一样的字符串。比如 “eat” 和 “tea” 排序后都是 “aet”。
因此，可以将每个字符串排序后作为键（key）来存储在哈希表中。所有排序后相同的字符串，属于同一个字母异位词组。

实现

1，遍历字符串数组，将每个字符串转换成排序后的字符串。
2，使用排序后的字符串作为哈希表的键，把原字符串添加到对应的键下。
3，最后遍历哈希表，得到所有的字母异位词组。

代码（Go）

// 排序法
func groupAnagrams(strs []string) [][]string {
	mp := make(map[string][]string) // 创建一个哈希表，键是排序后的字符串，值是字母异位词组
	for _, str := range strs {
		s := []byte(str)                    // 将字符串转为字节【切片】，是复合类型
		sort.Slice(s, func(i, j int) bool { // 对字节切片进行排序
			return s[i] < s[j] //这个规定的其实就是，大的在前还是小的在前
		})
		sortedStr := string(s)                     // 将排序后的字节切片转换回字符串
		mp[sortedStr] = append(mp[sortedStr], str) // 将原字符串加入到对应的字母异位词组
	}

	ans := make([][]string, 0, len(mp))
	for _, v := range mp {
		ans = append(ans, v)
	}
	return ans
}

（3）比较

方法一（排序法）：通过排序字符串作为哈希表的键。每个字符串的排序时间复杂度是 O(k log k)，因此总时间复杂度是 O(n * k log k)。
方法二（计数法）【性能更好】：通过记录字母出现次数的数组作为哈希表的键。每个字符串的处理时间是 O(k)，因此总时间复杂度是 O(n * k)。

3、最长连续序列

思路

题目要求找到数组中的 最长连续子序列
给定数组没有排序，且可能包含重复的元素，需要去重
可以用哈希表来查找数字是否存在
【哈希表自动去重，因为它的键是唯一的，不会存储重复的数字】

实现

1，哈希表存储： 将数组中的每个数字存入一个哈希表 numSet，以便能够快速查找每个数字是否存在。
2，遍历数组： 对于每个数字，检查它是否是一个潜在的连续序列的起点。即它的前一个数字 num-1 不存在于哈希表中。如果是起点，就从该数字开始，继续查找连续的数字。
3，更新最长子序列： 每次找到一个连续子序列时，更新当前找到的最长子序列的长度。

代码（Go）

func longestConsecutive(nums []int) int {
	numSet := map[int]bool{}           // 创建一个哈希表 numSet，用来存储数组中的所有数字,键是数字，值是 bool 类型，用来标记数字是否存在
	for _, num := range nums {         // 遍历 nums 数组，将每个数字存入哈希表 numSet
		numSet[num] = true             // 由于哈希表的键是唯一的，重复的数字会自动去重
	}
	maxLen := 0
	for num := range numSet {          // 通过 range 获取哈希表中的每个键（即数字）
		if !numSet[num-1] {            // 只有 num-1 不存在，才是连续序列的起点
			currentNum := num          // 从当前 num 开始，向上查找连续的数字
			currentMax := 1            // 初始化当前连续序列的长度为 1（包含当前的 num）
			for numSet[currentNum+1] { // 相当于while, 为 true 时，说明当前数字的下一个数字存在
				currentNum++           // 递增，继续查找下一个数字
				currentMax++
			}
			if currentMax > maxLen {   // 如果找到的连续子序列长度大于当前最长的长度，则更新最长长度
				maxLen = currentMax
			}
		}
	}
	return maxLen
}