本文共 4116 字，大约阅读时间需要 13 分钟。

���������Hashing���������������������������������������������������������������������������������-map>���������������������������������������������������������������������������������������������������������������

������������������������

1.1 ���������������Linear Probing���

������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

1.2 ���������������Chaining���

���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������O(1)���������O(n)������������������������������������������������������������������

2. ������������������������

2.1 ���������

���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

2.2 ���������������

���������������������������������������������������������������������������������������������������������������������������������������������������alettee Density������������������������������������������������������������������

2.3 ���������������������������

������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
3. ������������������

3.1 ���������������������������

class HashMap:
    def __init__(self, max_size=128):
        self.max_size = max_size
        self.real_size = 0
        self.data = [None] * self.max_size
        self.next = [None] * self.max_size
    def hash(self, key):
        h = 0
        for b in bin(key)[2:]:
            h = (h << 1) | (1 & b)
        return h % self.max_size
    def get(self, key):
        return self.data[self.hash(key)]
    def put(self, key):
        if self.real_size % self.max_size == 0 and self.real_size < self.max_size:
            self.real_size += 1
        hashed = self.hash(key)
        if self.data[hashed] is None:
            self.real_size += 1
            self.data[hashed] = key
            self.next[hashed] = hashed
        else:
            next_hash = self.get(self.data[hashed])
            if self.data[next_hash] is None:
                self.data[next_hash] = key
                self.next[hashed] = next_hash
            else:
                next_next_hash = self.get(self.data[next_hash])
                self.data[next_next_hash] = key
                self.next[next_hash] = next_next_hash
                self.next[hashed] = next_next_hash
        return True
    def remove(self, key):
        current = self.hash(key)
        while self.data[current] is not None:
            current = self.next[current]
            if current < 0 or current >= self.max_size:
                return False
        self.clear_linked(current)
        return True
    def clear_linked(self, current):
        while current != -1 or self.data[current] is not None:
            temp = self.next[current]
            self.data[current] = None
            if temp != -1:
                self.next[temp] = -1
            current = temp
        return True

3.2 ���������������������

���������������������������������������������������������������������������������������������O(1)���������������������������������������������������������������������������������������������������������������������������

4. ������

������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������