请实现一个 Cuckoo Hash，包括陷入死循环之后的 Rehash 的内容，这部分需要你自 己实现，一个解决方法是路径检测+重新哈希： 检测循环路径的方法也比较简单，可以预先设定一个较大的阈值，当循环次数或者递归调用次数 超过设定阈值时，就可以认为产生了循环路径。 一旦判断发生循环路径之后，进行 Rehash 操作，选择新的 Hash 函数，然后重新构造整个哈希 表。

Cuckoo Hashing 是一种高效的哈希表实现方式，可以避免哈希冲突的问题。在 Cuckoo Hashing 中，每个元素被哈希到两个不同的位置，如果其中一个位置已经被占用了，那么就将占用该位置的元素重新哈希到它的另一个位置，直到找到一个空位置为止。如果发生循环冲突，则进行重新哈希操作。

以下是一个简单的 Cuckoo Hashing 的实现：

class CuckooHash:
    def __init__(self, size=32):
        self.size = size
        self.table1 = [None] * size
        self.table2 = [None] * size
        self.hash_functions = [hash1, hash2]
        self.max_rehash = 10

    def hash(self, key):
        return [f(key) % self.size for f in self.hash_functions]

    def insert(self, key, value):
        index1, index2 = self.hash(key)
        for i in range(self.max_rehash):
            if self.table1[index1] is None:
                self.table1[index1] = (key, value)
                return True
            elif self.table1[index1][0] == key:
                self.table1[index1] = (key, value)
                return True
            elif self.table2[index2] is None:
                self.table2[index2] = (key, value)
                return True
            elif self.table2[index2][0] == key:
                self.table2[index2] = (key, value)
                return True
            else:
                if i == self.max_rehash - 1:
                    self.rehash()
                else:
                    index = index1 if random.randint(0, 1) == 0 else index2
                    old_key, old_value = self.table1[index] if index == index1 else self.table2[index2]
                    self.table1[index1] = (key, value)
                    index1, index2 = index2, self.hash(old_key)[0] if index == index1 else self.hash(old_key)[1]
                    key, value = old_key, old_value
        return False

    def rehash(self):
        self.size *= 2
        self.table1 = [None] * self.size
        self.table2 = [None] * self.size
        for key, value in self.items():
            self.insert(key, value)

    def get(self, key):
        index1, index2 = self.hash(key)
        if self.table1[index1] and self.table1[index1][0] == key:
            return self.table1[index1][1]
        elif self.table2[index2] and self.table2[index2][0] == key:
            return self.table2[index2][1]
        else:
            return None

    def items(self):
        return [item for item in self.table1 + self.table2 if item is not None]

在这个实现中，我们使用了两个哈希表，每个元素会被哈希到 table1 和 table2 中的两个不同位置。如果某个位置已经被占用了，我们就将要插入的元素重新哈希到另一个位置进行插入操作，重复此过程直到找到空闲位置或者达到最大重新哈希次数。如果达到最大重新哈希次数，则进行 Rehash 操作。

在 Rehash 操作中，我们将哈希表的大小翻倍，并重新构造整个哈希表。为了避免死循环，我们可以设置一个最大重新哈希次数，在达到这个次数之后，就进行 Rehash 操作。