数据结构之哈希表

哈希表：

定义

直接寻址表+哈希函数==哈希表
哈希表通过关键字码直接访问地址，元素值为val，通过哈希函数h（val）==index得到索引值（值域为哈希表的长度），val元素直接放在得到的索引值的位置上

哈希冲突：

当存入元素过多时，经过哈希函数的映射得到的索引值会重复

哈希冲突解决办法

解决办法：1.开放寻址法：当前位置已有元素时，向后寻找空位
2.拉链法：在每个索引上放上一个链表

字典和集合都是通过哈希表来实现的

代码

#创建一个链表类

class LinkList:
    class Node:
        def __init__(self,item=None):
            self.item=item
            self.next=None

    class LinkListIterator:         #构造迭代器，让链表可以迭代
        def __init__(self,node):
            self.node=node
        def __next__(self):
            if self.node:
                cur_node=self.node
                self.node=cur_node.next
                return cur_node.item
            else:
                raise StopIteration
        def __iter__(self):
            return self


    def __init__(self,ite=None):
        self.head=None
        self.tail=None
        if ite:
            self.extend(ite)

    def append(self,obj):
        s=LinkList.Node(obj)
        if not self.head:
            self.head=s
            self.tail=s
        else:
            self.tail.next=s
            self.tail=s

    def extend(self,ite):
        for obj in ite:
            self.append(obj)

    def find(self,obj):
        for n in self:
            if n==obj:
                return True
        else:
            return False

    def __iter__(self):
        return self.LinkListIterator(self.head)

    def __repr__(self):                              #打印
        return "<<"+",".join(map(str,self))+'>>'

lk=LinkList([1,2,3,4,5])
# for element in lk:
#     print(element)

# print(lk)


class hashTable:
    def __init__(self,size=101): #定义哈希表的长度
        self.size=size
        self.T=[LinkList() for i in range(self.size)]

    def h(self,k):               #哈希函数
        return k%self.size

    def find(self,k):            #查找函数
        i=self.h(k)
        return self.T[i].find(k)

    def invert(self,k):
        i=self.h(k)            #哈希映射
        if self.find(k):       #如果k已经存在
            print("Duplicated Insert")
        else:
            self.T[i].append(k)

    def __repr__(self):
        return "<<"+",".join(map(str,self.T))+'>>'

ht=hashTable()

ht.invert(0)
ht.invert(1)
# ht.invert(0)
ht.invert(101)
print(ht)
print(ht.find(101))