9月5号算法心得——哈希表

（参考10分钟学会哈希表_哔哩哔哩_bilibili）

1. 何为哈希表？

        哈希表就是一个数组，通常可以让算法的时间复杂度降一个n，例如O(n^2)->O(n)。哈希表（Hash table）的初衷是为了将关键字值 (key - value) 映射到数组中的某个位置，这样就能够通过数组下标访问该数据，省去了遍历整个数据结构的过程，从而提高了数据的查找速度，插入、查找的平均期望时间复杂度是 O(1) 的。

2. 力扣习题

2.1 2206. 将数组划分成相等数对

        题目描述：给你一个整数数组 nums，它包含 2 * n 个整数。你需要将 nums 划分成 n 个数对，满足：①每个元素只属于一个数对。②同一数对中的元素相等。③如果可以将nums划分成n个数对，请你返回true，否则返回 false 。

        题解：

class Solution(object):
    def divideArray(self, nums):
        hashmap = np.zeros(501)
        for i in range(len(nums)):
            hashmap[nums[i]] += 1
        for i in range(len(nums)):
            if hashmap[nums[i]] % 2 != 0:
                return False
        return True

        显而易见，哈希表在这里的作用就是统计数组nums中的元素出现的次数。时间复杂度为O(n)，空间复杂度为O(n)。

        题外话：这个算法用在这里当然不是最简方法，反而显得很浪费。所以这个题更好的做法是排序：

class Solution(object):
    def divideArray(self, nums):
        nums.sort()
        for i in range(0, len(nums), 2):
            if nums[i] != nums[i+1]:
                return False
        return True

        先把数组进行排序，那么只需要两个两个跳跃，因为题目定义数组nums是2*n个数值，所以不需要考虑下标越界的情况。只要当前的数值和它相邻的数值不相等，就说明这个数字出现的次数为奇数次。时间复杂度为O(n)，空间复杂度为O(1)。

2.2 1512. 好数对的数目

        题目：给你一个整数数组nums。如果一组数字( i, j )满足nums[ i ] == nums[ j ] 且i < j，就可以认为这是一组好数对。返回好数对的数目。

        常规题解：

class Solution(object):
    def numIdenticalPairs(self, nums):
        count = 0
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if(nums[i] == nums[j]):
                    count += 1
        return count

        最直接的思想就是用两次for循环，暴搜算法，不详细解释。时间复杂度为O[(n-1)+(n-2)+...+1] = O[n*(n-1)/2] = O(n²)，空间复杂度为O(1)。

        哈希表题解：

class Solution(object):
    def numIdenticalPairs(self, nums):
        count = 0
        hashmap = np.zeros(101)
        for i in range(len(nums)):
            count += hashmap[nums[i]]
            hashmap[nums[i]] += 1
        return int(count)

        相当于是用空间来换时间（虽然在力扣上跑的时间好像更长了），只要出现了，就把对应元素在哈希表的元素+1，这就代表了这个元素出现过。而直接把哈希表的值加给结果可以这样理解：①元素第一次出现时，哈希表对应的值为0，结果加0，不改变结果。②元素第二次或更多次出现时，哈希表的值为1或更大，意味着之前出现的元素都为一组好数对。时间复杂度为O(n)，空间复杂度为O(n)。

2.3 2006. 差的绝对值为 K 的数对数目

        题目：给你一个整数数组nums和一个整数k，请你返回数对 (i, j) 的数目，满足 i < j 且 |nums[i] - nums[j]| == k 。

        提示：

• 1 <= nums.length <= 200
• 1 <= nums[i] <= 100
• 1 <= k <= 99

        题解：

class Solution(object):
    def countKDifference(self, nums, k):
        hashmap = np.zeros(200)
        count = 0
        for _, x in enumerate(nums):
            count += hashmap[x]
            if x - k >= 0:
                hashmap[x-k] += 1
            hashmap[x+k] += 1
        return int(count)

        此题和上一题类似，只是存入更多元素。根据提示的数值范围，我们可以直接定义哈希表的范围是0~200，然后在存入哈希表的时候舍弃负值即可。时间复杂度为O(n)，空间复杂度为O(n)。

2.4 930. 和相同的二元子数组 （较难，建议先自己思考）

        题目：给你一个二元数组 nums，和一个整数goal，请你统计并返回有多少个和为 goal 的 非空 子数组。

        题解：

class Solution(object):
    def numSubarraysWithSum(self, nums, goal):
        hashmap = [0 for i in range(len(nums)+1)]
        hashmap[0] = 1
        count = 0
        Sum = 0
        
        for i in range(len(nums)):
            Sum += nums[i]
            if Sum - goal >= 0 :
                count += hashmap[Sum-goal]
            hashmap[Sum] += 1

        return count

        此题难度明显大于前面几题，我的思路是先根据数组nums的大小设置一个(n+1)大小的全0列表，并在0下标的位置设置初值为1（意思就是当前的值刚好等于goal时，至少要加1）。并每次赋值hashmap[Sum]++。整体时间复杂度为O(n)，空间复杂度为O(n)。

        还有另一种不是哈希表的做法（我的初解想法），但是和哈希表不相符，且理解难度远高于哈希表（效果还比哈希表差），这里就不介绍了。