算法导论程序25--散列表（Python）

在直接寻址方式下，具有关键字k的元素被存放在槽k中。在散列方式下，该元素存放在槽h(k)中：即利用散列函数（hash function）h，由关键字k计算出槽的位置。

这里，函数h将关键字的全域U映射到散列表（hash table）T[0...m-1]的槽位上：

h:U->{0,1,...,m-1}

这里，散列表的大小m一般要比|U|小得多。我们可以说一个具有关键字k的元素被散列到槽h(k)上，也可以说h(k)是关键字k的散列值。

冲突：两个关键字可能映射到同一个槽中。解决冲突的方法：

链接法。开放寻址法。

通过链接法解决冲突：

把散列在同一个槽中的所有元素都放在一个链表中，槽j中有一个指针，它指向存储所有散列到j的元素的链表的表头；如果不存在这样的元素，则槽j中为NIL。

class chained_hash:
    def __init__(self,T=[],size=0):
        if len(T)==0:
            self.T=[None for i in range(size)]
        else:
            self.T=T
        self.size=size
    def search(self,k):
        if self.T[self.hash_h(k)]!=None:
            x=self.T[self.hash_h(k)].list_search(k)
            return x
        return None
    def insert(self,x):
        if self.T[self.hash_h(x.key)]==None:
            self.T[self.hash_h(x.key)]=DoublyLinkedList(x)
        else:
            self.T[self.hash_h(x.key)].list_insert(x)
    def delete(self,x):
        self.T[self.hash_h(x.key)].list_delete(x)
    def hash_h(self,key):
        return key%12


class Node:
    def __init__(self,key):
        self.key=key


#####双向链表####     
class DoublyNode:
    def __init__(self,n_prev,n_next,key):
        self.prev=n_prev
        self.next=n_next
        self.key=key

class DoublyLinkedList:
    def __init__(self,head):
        self.head=head
    def list_search(self,k):
        x=self.head
        while x !=None and x.key!=k:
            x=x.next
        return x
    def list_insert(self,x):
        x.next=self.head
        if self.head != None:
            self.head.prev=x
        self.head=x
        x.prev=None
    def list_delete(self,x):
        if x.prev!=None:
            x.prev.next=x.next
        else:
            self.head=x.next
        if x.next !=None:
            x.next.prev=x.prev

运行结果：

>>> T=[]
>>> x=DoublyNode(None,None,13)
>>> ch=chained_hash(T,12)
>>> ch.insert(x)
>>> x=DoublyNode(None,None,25)
>>> ch.insert(x)
>>> y=ch.search(25)
>>> y.key
25
>>> ch.delete(y)
>>> ch.T[1].head
<__main__.DoublyNode object at 0x038E8890>
>>> ch.T[1].head.key
13
>>> ch.T[1].head.next
>>> 

hash_h是自定义的除法散列法。h(k)=k mod m

其中m=12。相应地，散列表的槽T的个数为12。T中的每个元素都是一个双向链表。