数据结构｜LeetCode（力扣）经典题：哈希表_力扣哈希经典例题

哈希表

更多请查看我的专栏：LeetCode（力扣）刷题指南

可直接在LeetCode中搜索题目名称

1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

1.1 解决方案

1. 暴力法(时间O(n^2):5012 ms)

1. 两次遍历，第一次遍历每个元素，设x；
2. 第二次遍历，查找是否有与target-x相等的目标元素。

class Solution:
    def twoSum(self,nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            b = target - nums[i]
            for j in range(len(nums)):
                if nums[j]==b and i!=j:
                    return [i,j]
1
2
3
4
5
6
7

2.暴力法进阶：时间复杂度O(n)：940 ms

1. 一次遍历，遍历每个元素，设x；
2. 通过切片复制nums数组x后面的数组nums1；
3. 通过list.index查找y=target-x在 nums1 中的位置。

class Solution:
    def twoSum(self,nums: list[int], target: int) -> list[int]:
        for i in range(len(nums)):
            a=target-nums[i]
            nums1=nums[i+1:]
            if a in nums1:
                return [i,nums1.index(a)+i+1]
        return 0
1
2
3
4
5
6
7
8

​ 第二个元素的查找并不需要再从头来一遍遍历，只需要从第一个元素之间或之后查找即可。但为了方便index 这里选择从第一个元素之前查找。

---

3.哈希法(时间复杂度O(n):52 ms)

1. 通过enumerate()建立一个字典，模仿哈希表；
2. 然后根据target-num在字典中查找键，并返回相应的数组位置。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hash={
   }
        for index1,num1 in enumerate(nums):
            hash[num1] = index1 #字典的键是数组nums的元素，值是元素序号
        for index,num in enumerate(nums):
            i= hash.get(target-num)
            if i is not None and i!=index:
                return [i,index]
1
2
3
4
5
6
7
8
9
10

​ 为了对运行时间复杂度进行优化，我们需要一种更有效的方法来检查数组中是否存在目标元素。如果存在，我们需要找出它的索引。保持数组中的每个元素与其索引相互对应的最好方法是什么？哈希表。

4.哈希法进阶版(时间复杂度O(n)：52 ms)

1. 通过enumerate()建立一个字典，模仿哈希表；
2. 在建立字典的同时，查找字典中是否有与target-num相对应的键

class Solution:
    def twoSum(self,nums: List[int], target: int) -> List[int]:
        map = {
   }
        for index, num in enumerate(nums):
            if (map.get(target - num) is not None )&(index!=map.get(target - num)) :
                return [index, map.get(target - num)]
            map[num] = index
1
2
3
4
5
6
7
8

​ 类似于暴力法版本，不需要在整个字典中查找，可以在第一个元素之间的字典中查找，因此就只需要一次循环可解决。但效果并不明显。

2. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”
输出: true

---

示例 2:

输入: s = “rat”, t = “car”
输出: false

---

说明:
你可以假设字符串只包含小写字母。

进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

2.1 解决办法

1.排序（O(nlogn):60 ms）

通过将 s 的字母重新排列成 t 来生成变位词。因此，如果 T 是 S 的变位词，对两个字符串进行排序将产生两个相同的字符串。此外，如果 s 和 t 的长度不同，t 不能是 s 的变位词，我们可以提前返回。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        return sorted(s)==sorted(t)
1
2
3

复杂度分析：

时间复杂度：O(nlogn)，假设 n 是 ss 的长度，排序成本O(nlogn) 和比较两个字符串的成本 O(n)。排序时间占主导地位，总体时间复杂度为 O(nlogn)。
空间复杂度：空间取决于排序实现，这依赖于语言的细节,和函数的设计方式。例如，可以将函数参数类型更改为 char[]。

2.哈希表（时间O(n)）

一个重要的前提“假设两个字符串只包含小写字母”，小写字母一共也就 26 个，因此：

1. 可以利用两个长度都为 26 的字符数组来统计每个字符串中小写字母出现的次数，然后再对比是否相等；

2. 以只利用一个长度为 26 的字符数组，将出现在字符串 s 里的字符个数加 1，而出现在字符串 t 里的字符个数减 1，最后判断每个小写字母的个数是否都为 0。

3. 或者我们可以先用计数器表计算 s，然后用 t 减少计数器表中的每个字母的计数器。如果在任何时候计数器低于零，我们知道 t 包含一个不在 s 中的额外字母，并立即返回 FALSE。

按上述操作，可得出结论：s 和 t 互为字母异位词。

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if len(s) != len(t
1
2
3
4
5
6
7