Python 为什么我的hashset类可以工作但hashtable失败

在这几天里，我一直在研究与hashtable相关的leetcode问题。有两个设计问题。一个是设计hashSet，另一个是设计hashMap。我从别人的代码中获得了一些见解，并实现了hashSet设计。对于hashMap，我认为我应该做的是添加一个额外的数组来存储值，但当我提交代码时，它报告了错误的答案。我想知道我的代码出了什么问题

下面是我的HashSet代码，它通过了所有测试用例

class MyHashSet:
    def __init__(self):
        self.size = 0
        self.capacity = 8
        self.lf = 2/3
        self.arr = [None] * 8
        
    def hash(self, key):
        return key % self.capacity
    
    def rehash(self, key):
        return (5 * key + 1) % self.capacity
    
    def add(self, key: int) -> None:
        if self.contains(key):
            return 
        if self.size / self.capacity >= self.lf:
            self.capacity <<= 1
            new_arr = [None] * self.capacity
            for i in range(self.capacity >> 1):
                if self.arr[i] and self.arr[i] != "removed":
                    index = self.hash(self.arr[i])
                    while new_arr[index] is not None:
                        index = self.rehash(index)
                    new_arr[index] = self.arr[i]
            self.arr = new_arr
        
        index = self.hash(key)
        while self.arr[index] is not None:
            if self.arr[index] == "removed":
                break
            index = self.rehash(index)
        self.arr[index] = key
        self.size += 1

    def remove(self, key: int) -> None:
        if not self.contains(key):
            return
        index = self.hash(key)
        while self.arr[index] != key:
            index = self.rehash(index)
        self.arr[index] = "removed"
        self.size -= 1

    def contains(self, key: int) -> bool:
        """
        Returns true if this set contains the specified element
        """
        index = self.hash(key)
        while self.arr[index] is not None:
            if self.arr[index] == key:
                return True
            index = self.rehash(index)
        return False

类MyHashSet:
定义初始化（自）：
self.size=0
自容量=8
self.lf=2/3
self.arr=[None]*8
def散列（self，key）：
返回密钥%self.capacity
def再灰化（自身，钥匙）：
返回（5*键+1）%self.capacity
def添加（自身，键：int）->无：
如果self.contains（键）：
返回
如果self.size/self.capacity>=self.lf：
自我能力（1）：
如果self.arr[i]和self.arr[i]！=“删除”：
index=self.hash（self.arr[i]）
虽然new_arr[index]不是无：
索引=自我再灰化（索引）
new_arr[index]=self.arr[i]
self.arr=new\u arr
index=self.hash（键）
虽然self.arr[index]不是无：
如果self.arr[index]=“已删除”：
打破
索引=自我再灰化（索引）
self.arr[index]=键
self.size+=1
def移除（自身，键：int）->无：
如果不是self.contains（键）：
返回
index=self.hash（键）
而self.arr[index]！=关键：
索引=自我再灰化（索引）
self.arr[index]=“已删除”
自我尺寸-=1
def包含（self，key:int）->bool:
"""
如果此集合包含指定的元素，则返回true
"""
index=self.hash（键）
虽然self.arr[index]不是无：
如果self.arr[index]==键：
返回真值
索引=自我再灰化（索引）
返回错误

下面是我的HashMap代码，它在一个测试用例中失败

class MyHashMap:
    def __init__(self):
        self.size = 0
        self.capacity = 8
        self.lf = 2/3
        self.key_arr = [None] * 8
        self.value_arr = [None] * 8

    def hash(self, key):
        return key % self.capacity
    
    def rehash(self, key):
        return (5 * key + 1) % self.capacity    
        
    def put(self, key: int, value: int) -> None:
        """
        value will always be non-negative.
        """
        contain_flag = False
        if self.contains(key):
            contain_flag = True
        
        if not contain_flag and self.size / self.capacity >= self.lf:
            self.capacity <<= 1
            new_key_arr = [None] * self.capacity
            new_value_arr = [None] * self.capacity
            for i in range(self.capacity >> 1):
                if self.key_arr[i] and self.key_arr[i] != "removed":
                    index = self.hash(self.key_arr[i])
                    while new_key_arr[index] is not None:
                        index = self.rehash(index)
                    new_key_arr[index] = self.key_arr[i]
                    new_value_arr[index] = self.value_arr[i]
            self.key_arr = new_key_arr
            self.value_arr = new_value_arr
            
        index = self.hash(key)
        if contain_flag:
            while self.key_arr[index] != key:
                index = self.rehash(index)
        else:
            while self.key_arr[index] is not None:
                if self.key_arr[index] == "removed":
                    break
                index = self.rehash(index)
        self.key_arr[index] = key
        self.value_arr[index] = value
        self.size += 1

    def get(self, key: int) -> int:
        """
        Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key
        """
        if not self.contains(key):
            return -1
        index = self.hash(key)
        while self.key_arr[index] != key:
            index = self.rehash(index)
        return self.value_arr[index]
        
        

    def remove(self, key: int) -> None:
        """
        Removes the mapping of the specified value key if this map contains a mapping for the key
        """
        if not self.contains(key):
            return
        index = self.hash(key)
        while self.key_arr[index] != key:
            index = self.rehash(index)
        self.key_arr[index] = "removed"
        self.value_arr[index] = "removed"
        self.size -= 1
        
    def contains(self, key):
        index = self.hash(key)
        while self.key_arr[index] is not None:
            if self.key_arr[index] == key:
                return True
            index = self.rehash(index)
        return False

类MyHashMap:
定义初始化（自）：
self.size=0
自容量=8
self.lf=2/3
self.key_arr=[None]*8
self.value_arr=[None]*8
def散列（self，key）：
返回密钥%self.capacity
def再灰化（自身，钥匙）：
返回（5*键+1）%self.capacity
def put（自身，键：int，值：int）->无：
"""
值将始终为非负。
"""
contain_标志=False
如果self.contains（键）：
contain_flag=True
如果不包含_标志和self.size/self.capacity>=self.lf：
自我能力（1）：
如果self.key_arr[i]和self.key_arr[i]！=“删除”：
index=self.hash（self.key\u arr[i]）
虽然new_key_arr[index]不是None：
索引=自我再灰化（索引）
new_key_arr[index]=self.key_arr[i]
新值\u arr[index]=self.value\u arr[i]
self.key\u arr=新密钥\u arr
self.value\u arr=新值\u arr
index=self.hash（键）
如果包含_标志：
而self.key_arr[索引]！=关键：
索引=自我再灰化（索引）
其他：
而self.key_arr[index]不是无：
如果self.key_arr[index]=“已删除”：
打破
索引=自我再灰化（索引）
self.key\u arr[index]=键
self.value\u arr[索引]=值
self.size+=1
def get（self，key:int）->int:
"""
返回指定键映射到的值，如果此映射不包含该键的映射，则返回-1
"""
如果不是self.contains（键）：
返回-1
index=self.hash（键）
而self.key_arr[索引]！=关键：
索引=自我再灰化（索引）
返回自身值\u arr[索引]
def移除（自身，键：int）->无：
"""
如果此映射包含键的映射，则删除指定值键的映射
"""
如果不是self.contains（键）：
返回
index=self.hash（键）
而self.key_arr[索引]！=关键：
索引=自我再灰化（索引）
self.key_arr[index]=“已删除”
self.value\u arr[index]=“已删除”
自我尺寸-=1
def包含（自身、密钥）：
index=self.hash（键）
而self.key_arr[index]不是无：
如果self.key\u arr[index]==键：
返回真值
索引=自我再灰化（索引）
返回错误

---

后来，我发现如果我将hashMap的大小从8初始化为1024，它可以通过所有测试用例，但我无法弄清楚它为什么会这样。

哪个测试用例失败？您是否调试过它以试图找出问题？请创建一个演示问题的示例。您可能可以从问题中忽略工作类，我们并不需要看到它。这是一个leetcode问题，我在最后一个包含1001个操作的测试用例中失败了。从测试结果来看，我发现我只在第691次操作中失败了。在这种情况下，我无法创建一个最小的可复制示例。感谢您的帮助，您可以尝试模糊测试来重现失败。使用python的内置字典作为参考/oracle实现，并对地图和内置字典进行随机操作，直到它们在内容上出现分歧。让他们记录操作，以便您了解故障是如何发生的。这是程序员的生活…@Tony Delroy谢谢你的建议，我将尝试测试哪些测试用例失败？您是否调试过它以试图找出问题？请创建一个演示问题的示例。你可以忽略工人阶级