python實現順序查找和哈希查找

順序查找非常簡單，只是個開胃菜，今天主要練習的是哈希查找

先上順序查找代碼：

def sequence_search(array, num):
    for i in range(len(array)):
        if array[i] == num:
            return i
    return False

array_0 = [23, 43, 12, 54, 65, 48]
print(sequence_search(array_0, 12))
>>> 2

在來看hash查找：

算法思想

    哈希的思路很簡單，如果所有的鍵都是整數，那么就可以使用一個簡單的無序數組來實現：將鍵作為索引，值即為其對應的值，這樣就可以快速訪問任意鍵的值。這是對於簡單的鍵的情況，我們將其擴展到可以處理更加復雜的類型的鍵。

算法流程

　　1）用給定的哈希函數構造哈希表；
　　2）根據選擇的沖突處理方法解決地址沖突；
　　　　 常見的解決沖突的方法：拉鏈法和線性探測法。
　　3）在哈希表的基礎上執行哈希查找。

　單純論查找復雜度：對於無沖突的Hash表而言，查找復雜度為O(1)（注意，在查找之前我們需要構建相應的Hash表）。

class HashSearch:
    def __init__(self, num):
        if isinstance(num, int):
            self.num = abs(num)
            self.empty = self.num
            self._list = [None] * self.num
        else:
            raise TypeError('num must be a int number')
    def __hash(self, key):
        return key % self.num
    def put(self, key):
        assert self.empty > 0, 'this array is full'
        index = self.__hash(key)
        while self._list[index]:
            index = self.__hash(index+1)
        self._list[index] = key
        self.empty -= 1
    def find(self, key):
        index = self.__hash(key)
        temp = indexwhile self._list[index] != key:
            index = self.__hash(index+1)
　　　　　　　if index == temp:
                return False
        return index 

class HashTable:
    def __init__(self):
        # 哈希表的初始大小已經被選擇為 11。盡管這是任意的，但是重要的是，
        # 大小是質數，使得沖突解決算法可以盡可能高效。
        self.size = 11
        self.slots = [None] * self.size
        self.data = [None] * self.size
 
    # hash 函數實現簡單的余數方法
    def hash(self, key, size):
        return key % size
 
    # 沖突解決技術是  加1  rehash 函數的線性探測
    def rehash(self, old_hash, size):
        return (old_hash+1) % size
 
    # 假定最終將有一個空槽，除非 key 已經存在於  self.slots  中。 它計算原始
    # 哈希值，如果該槽不為空，則迭代 rehash 函數，直到出現空槽。如果非空槽已經包含 key，
    # 則舊數據值將替換為新數據值。
    def put(self, key, data):
        hash_value = self.hash(key, len(self.slots))
 
        if self.slots[hash_value] is None:
            self.slots[hash_value] = key
            self.data[hash_value] = data
 
        else:
            if self.slots[hash_value] == key:
                self.data[hash_value] = data
            else:
                next_slot = self.rehash(hash_value, len(self.slots))
                while self.slots[next_slot] is not None and \
                        self.slots[next_slot] != key:
                    next_slot = self.rehash(next_slot, len(self.slots))
 
                if self.slots[next_slot] is None:
                    self.slots[next_slot] = key
                    self.data[next_slot] = data
                else:
                    self.data[next_slot] = data
 
    # 從計算初始哈希值開始。如果值不在初始槽中，則 rehash 用
    # 於定位下一個可能的位置。
    def get(self, key):
        start_slot = self.hash(key, len(self.slots))
 
        data = None
        stop = False
        found = False
        pos = start_slot
 
        while self.slots[pos] is not  None and not found and not stop:
            if self.slots[pos] == key:
                found = True
                data = self.data[pos]
            else:
                pos = self.rehash(pos, len(self.slots))
                if pos == start_slot:
                    stop = True
        return data
 
    # 我們重載  __getitem__  和 __setitem__  方法以允許使
    # 用  []  訪問。 這意味着一旦創建了HashTable，索引操作符將可用。
    def __getitem__(self, item):
        return self.get(item)
 
    def __setitem__(self, key, value):
        self.put(key, value)