Hash table

1.Hash Fucntion

1.1 直接定址法

1.2除留余数法

1.3平方取中法

1.4基数转换法

2.Hash Collision

2.1开放地址法

2.2链地址法

3.

1.0217. 存在重复元素

解法1：

使用dict，因为python中dict内部存储方法为hash table，本质为遍历，故时空复杂度均为O（n）。

解法2：

使用set。故时空复杂度均为O(n)。

解法3：

排序，由于Quick Sort 和 Merge Sort等最快排序算法时间复杂度均为nlog(n)，遍历时间复杂度为O(n)，故最终仍为O(nlog(n))。空间复杂度为O(1)，因为空间复杂度计算的是额外需要的。

2.0219. 存在重复元素 II

1.0349. 两个数组的交集

解法1：

hash map

直接使用内置的intersection方法确实要慢一些。

解法2：

分离双指针。

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        numlist = []
        nums1.sort()
        nums2.sort()
        i,j = 0,0
        while(1):
            if i == len(nums1) or j == len(nums2):
                break
            if nums1[i] == nums2[j]:
                numlist.append(nums1[i])
                i+=1
                j+=1
                continue
            if nums1[i] < nums2[j]:
                i+=1
                continue
            else:
                j+=1
                continue
            
        
        return list(set(numlist))

遍历一遍加原位操作，故时间复杂度O(n)，空间复杂度O(1)。

2.0350. 两个数组的交集 II

3.0706. 设计哈希映射

真的不会，所以贴原答案，供接下来继续学习：

class MyHashMap:

    def __init__(self):
        self.buckets = 1003
        self.table = [[] for _ in range(self.buckets)]


    def hash(self, key):
        return key % self.buckets


    def put(self, key: int, value: int) -> None:
        hash_key = self.hash(key)
        for item in self.table[hash_key]:
            if key == item[0]:
                item[1] = value
                return
        self.table[hash_key].append([key, value])


    def get(self, key: int) -> int:
        hash_key = self.hash(key)
        for item in self.table[hash_key]:
            if key == item[0]:
                return item[1]
        return -1


    def remove(self, key: int) -> None:
        hash_key = self.hash(key)
        for i, item in enumerate(self.table[hash_key]):
            if key == item[0]:
                self.table[hash_key].pop(i)
                return

为计算一个列表中元素（也为列表）个数，使用dict比使用list要快得多：