python中的字典

在Python中，字典是通过散列表或说哈希表实现的。字典也被称为关联数组，还称为哈希数组等。也就是说，字典也是一个数组，但数组的索引是键经过哈希函数处理后得到的散列值。哈希函数的目的是使键均匀地分布在数组中，并且可以在内存中以O(1)的时间复杂度进行寻址，从而实现快速查找和改。

建立哈希表的详细过程如下：
数据添加：把key通过哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。

数据查询：再次使用哈希函数将key转换为对应的数组下标，并定位到数组的位置获取value。

哈希表存储

1. hash表利用hash函数计算出Key的哈希值，与数组长度求余，取余结果index作为数组下标
2. list[hash(key)%len(list)]=value

哈希冲突与扩容
只要样本足够大，任何哈希函数一定会出现两个不同的key得出同一个哈希值，此时会出现两个不同key存入同一个数组位置，这种就称为哈希冲突。
可以利用开链法和开放寻址法解决冲突。
开放寻址法中常用的方法有：线性探测、二次探测、再哈希探测和随机探测。

开链法：哈希表中的顺序表的每个位置存储的是链表，如果发生冲突时，冲突的元素会被加在链表的后面
开放寻址法：如果发现index位置上有数据，则探查新的位置来存储，index有值，则探查index+n 以此类推

#开链法解决hash冲突
class Node:
    """一个简单的链表子节点"""
    def __init__(self,key,value):
        self.key=key
        self.value=value
        self.next=None
class myDict:
    def __init__(self,max):
        self.max=max
        self.hashTable=[None for _ in range(max)]
        self.capacity=0
    def addItem(self,key,value):
        """增加"""
        if self.capacity==self.max:
            raise Exception("超出容量")
        index=hash(key)%self.max
        if self.hashTable[index]:
            print(f"hash冲突 {key} {value}")
            node=self.hashTable[index]
            while node.next:
                node=node.next
            node.next=Node(key,value)
        else:
            self.hashTable[index]=Node(key,value)
            self.capacity+=1
    def getValue(self,key):
        flag=False
        index=hash(key)%self.max
        node=self.hashTable[index]
        if not node:
            raise Exception("key error 1 ")
        elif node.key==key:
            return node.value
        else:
            while node.next:
                node = node.next
                if node.key==key:
                    flag=True
                    break
        if not flag:
            raise Exception("key error 2 ")
        return node.value

mydict=myDict(20)
temp=['q','w','e','r','t','y','u','i','o','a','s','d','f','g','h','j','k','z','x','c','v','b','n']
result=[]
for x in temp:
    for y in temp:
        for z in temp:
            result.append(f"{x}{y}{z}")

for item in result:
    mydict.addItem(item,f"{item}-value")
print(mydict)

# 开放寻址法解决hash冲突
class HashTable:
    def __init__(self, size=10):
        self.size = size
        self.table = [None] * self.size

    def _hash_function(self, key):
        # 简单的哈希函数，使用乘法再模基于键的长度
        hash = (ord(key[0]) + ord(key[1])) % self.size
        return hash

    def _resolve_collision(self, key, index):
        # 处理哈希冲突的开放寻址
        i = index + 1
        while self.table[i] is not None:
            i += 1
        return i

    def insert(self, key, data):
        # 插入键值对
        index = self._hash_function(key)
        if self.table[index] is None:
            self.table[index] = [[key, data]]
        else:
            # 处理哈希冲突
            index = self._resolve_collision(key, index)
            self.table[index].append([key, data])

    def search(self, key):
        # 搜索键对应的数据
        index = self._hash_function(key)
        if self.table[index] is not None:
            for pair in self.table[index]:
                if pair[0] == key:
                    return pair[1]
        return None


# 示例使用哈希表
my_hash_table = HashTable(size=10)
my_hash_table.insert('key1', 'data1')
my_hash_table.insert('key2', 'data2')
my_hash_table.insert('key3', 'data3')

# 假设key1和key2位于同一个桶中，key3通过哈希函数直接找到位置
print(my_hash_table.search('key1'))  # 应该输出 'data1'
print(my_hash_table.search('key2'))  # 应该输出 'data2'
print(my_hash_table.search('key3'))  # 应该输出 'data3'

原文链接：https://blog.csdn.net/qq_48441158/article/details/136313539
原文链接：https://blog.csdn.net/weixin_33331978/article/details/112876291