python--数据结构--哈希查找

代码实现：

# search_hash_table.py
from collections import deque
import math


class Record:
    def __init__(self, key):
        self.key = key
        self.other_info = None


class HashTable:
    def __init__(self, table_len):
        self.table = deque([None for i in range(table_len)])
        self.table_len = table_len


flag = False  # flag为True时表明hash_func已调用过一次max_prime，防止多次对max_prime的调用
p = 0  # 存储小于等于一个数的最大素数，也是max_prime的计算结果


def max_prime(number):
    """
    获取小于等于一个数的最大素数
    :param number:
    :return:
    """
    j = 0
    for i in range(number-1, 1, -1):
        a = int(math.sqrt(i))+1
        for j in range(2, a):
            if i % j == 0:
                break
        if i % j != 0:
            global flag
            flag = True
            return i


def hash_func(table_len, key) -> int:
    """
    除留取余法

    :param table_len:
    :param key:
    :return:
    """
    if not flag:
        global p
        p = max_prime(table_len)
    index = key % p
    return index  # 返回关键字在哈希表中的对应位置


def hash_search(hash_table: HashTable, key):
    """
    查找关键字在哈希表中的下标

    哈希表的查找过程与哈希表的创建过程是一致的。

    算法思想：
        (1) 首先计算h0=hash_func(table_len, key)
        (2) 如果单元h0为空，则所查元素不存在
        (3) 如果单元h0中元素的关键字key，则查找到所查元素
        (4) 否则重复下下述解决冲突的过程。
            a. 按解决冲突的方法，找出下一个哈希地址hi
            b. 如果单元hi为空，则所查元素不存在
            c. 如果单元hi中元素的关键字key，则查找到所查元素

    :param hash_table:
    :param key:
    :return:
    """
    index = hash_func(hash_table.table_len, key)
    if hash_table.table[index] is None:
        return -1  # 表示该哈希表中没有key
    elif hash_table.table[index] == key:
        return index  # 返回查找的关键字在哈希表中对应下标
    else:
        # 用线性探测再散列解决冲突
        for i in range(hash_table.table_len):
            index = (index + i) % hash_table.table_len
            if hash_table.table[index] is None:
                return -1  # 表示该哈希表中没有key
            elif hash_table.table[index] == key:
                return index  # 返回查找的关键字在哈希表中对应下标


def create_hash_table(hash_table: HashTable, keys):
    for key in keys:
        index = hash_func(hash_table.table_len, key)
        if hash_table.table[index] is None:
            hash_table.table[index] = key
        elif hash_table.table[index] == key:
            continue  # 表示表中已有该关键字跳过对该关键字的再次插入
        else:
            # 用线性探测再散列解决冲突
            for i in range(hash_table.table_len):
                index = (index + i) % hash_table.table_len
                if hash_table.table[index] is None:
                    hash_table.table[index] = key
                elif hash_table.table[index] == key:
                    break  # 表示表中已有该关键字跳过对该关键字的再次插入
    return hash_table  # 返回建好的哈希表

# test_search_hash_table.py
from search_hash_search import HashTable,create_hash_table, hash_search


m = 10
hash_table = HashTable(m)
hash_table = create_hash_table(hash_table, [62, 58, 48, 95, 32, 10, 26, 42])
print(hash_table.table)
index = hash_search(hash_table, 10)
print(index)


"""
运行结果：
deque([32, 48, 58, 10, 95, 32, 62, 48, 26, 48])
3

Process finished with exit code 0
"""

[引用《数据结构–用C语言描述 耿国华版》]