Python 语言实现六大查找算法

import random  # 导入随机数模块

num = 0  # 定义变量num
# 使用列表推导式生成包含50个元素的列表
data = [random.randint(1, 100) for i in range(50)]
print("随机产生的数据内容是：")
for i in range(10):  # 遍历行
    for j in range(5):  # 遍历列
        # 按格式输出随机生成内容
        print('%2d[%3d] ' % (i * 5 + j + 1, data[i * 5 + j]), end='')
    print('')
while num != -1:  # 循环输入
    find = 0  # 比较次数
    num = int(input("请输入想要查找的数据，输入-1退出程序:"))  # 数据输入
    for i in range(50):  # 循环遍历50个随机数
        if data[i] == num:  # 判断输入数据和data数据是否相等
            print("在", i + 1, "个位置找到数据", data[i])  # 输出找到的位置和数据内容
            find += 1  # 比较次数加1
    if find == 0 and num != -1:  # 判断比较次数是否为0且输入数据是否为-1
        print("没有找到", num, "此数据")  # 提示没有找到数据

def search(data, num):
    """
    定义查找函数：该函数使用的是折半查找算法
    :param data: 原数列data
    :param num: 键值num
    :return:
    """
    low = 0  # 定义变量用来表示低位
    high = len(data) - 1  # 定义变量用来表示高位
    print("正在查找.......")  # 提示
    while low <= high and num != -1:
        mid = int((low + high) / 2)  # 取中间位置
        if num < data[mid]:  # 判断数据是否小于中间值
            # 输出位置在数列中的左半边
            print(f"{num} 介于中间故障点 {low + 1}[{data[low]}] 和故障点位置 {mid + 1}[{data[mid]}] 之间，找左半边......")
            high = mid - 1  # 最高位变成了中间位置减1
        elif num > data[mid]:  # 判断数据是否大于中间值
            # 输出位置在数列中的右半边
            print(f"{num} 介于中间故障点 {mid + 1}[{data[mid]}] 和故障点位置 {high + 1}[{data[high]}] 之间，找右半边......")
            low = mid + 1  # 最低位变成了中间位置加1
        else:  # 判断数据是否等于中间值
            return mid  # 返回中间位置
    return -1  # 自定义函数到此结束


inp_num = 0  # 定义变量，用来输入键值
num_list = [12, 45, 56, 66, 77, 80, 97, 101, 120]  # 定义数列
print("疑似故障点如下：")
for index, ele in enumerate(num_list):
    print(f" {index + 1}[{ele}]", end="")  # 输出数列
print("")
flag = True  # 开关，用来管控是否多次查找

while flag:  # 循环查找
    inp_num = int(input("请输入故障点：").strip())  # 输入查找键值
    if inp_num == -1:  # 判断键值是否是-1
        break  # 若为-1，跳出循环 即结束程序
    result = search(num_list, inp_num)  # 调用自定义的查找函数——search()函数
    if result == -1:  # 判断查找结果是否是-1
        print(f"没有找到[{inp_num}]故障点")  # 若为-1，提示没有找到值
    else:
        # 若不为-1，提示查找位置
        print(f"在{result + 1}个位置找到[{num_list[result]}]故障点")
    char = input("本次查找结束，是否继续查找，请输入 y(Y) 或 n(N)：").strip()
    if char.upper() == "N":
        flag = False

middle=left+(target-data[left])/(data[right]-data[left])*(right-left)

def insert_search(data, num):
    """
    自定义查找函数：该函数使用的是插补查找算法
    :param data: 原数列data
    :param num: 键值num
    :return:
    """
    # 计算
    left_index = 0  # 最左侧数据的索引
    right_index = len(data) - 1  # 最右侧数据的索引
    print("正在查找.......")  # 提示
    while left_index <= right_index:
        # 使用公式计算出索引值
        middle = left_index + (num - data[left_index]) / (data[right_index] - data[left_index]) * (
                right_index - left_index)
        # 取整
        middle = int(middle)
        # print(middle)
        if num == data[middle]:
            return middle  # 如果键值等于边界值，返回边界位置
        elif num < data[middle]:
            # 输出位置在数列中的左半边
            print(f"{num} 介于位置{left_index + 1}[{data[left_index]}]和边界值{middle + 1}[{data[middle]}]之间，找左半边......")
            right_index = middle - 1  # 如果键值小于边界值，最右边数据索引等于边界位置减1
        else:
            # 输出位置在数列中的左半边
            print(f"{num} 介于位置{middle + 1}[{data[middle]}]和边界值{right_index + 1}[{data[right_index]}]之间，找右半边......")
            left_index = middle + 1  # 如果键值大于边界值，最左边数据索引等于边界位置加1
    return -1  # 自定义函数到此结束

inp_num = 0  # 定义变量，用来输入键值
num_list = [34, 53, 57, 68, 72, 81, 89, 93, 99]  # 定义数列
print("数据内容是：")
for index, ele in enumerate(num_list):
    print(f" {index + 1}[{ele}]", end="")  # 输出数列
print("")
flag = True  # 开关，用来管控是否多次查找

while flag:  # 循环查找
    inp_num = int(input("请输入要查找的键值：").strip())  # 输入查找键值
    result = insert_search(num_list, inp_num)  # 调用自定义的查找函数——insert_search()函数
    if result == -1:  # 判断查找结果是否是-1
        print(f"没有找到[{inp_num}]")  # 若为-1，提示没有找到值
    else:
        # 若不为-1，提示查找位置
        print(f"在{result + 1}个位置找到[{inp_num}]")
    char = input("本次查找结束，是否继续查找，请输入 y(Y) 或 n(N)：").strip()
    if char.upper() == "N":
        flag = False

h(item)=item % num

class HashTable(object):  # 创建哈希表
    def __init__(self):
        self.size = 11  # 哈希表长度
        self.throw = [None] * self.size  # 哈希表数据键初始化
        self.data = [None] * self.size  # 哈希表数据值初始化

    # 假定最终将有一个空槽，除非 key 已经存在于  self. throw中。它计算原始
    # 哈希值，如果该槽不为空，则迭代 rehash 函数，直到出现空槽。如果非空槽已经包含key，
    # 则旧数据值将替换为新数据值
    def put(self, key, value):  # 输出键值
        hashvalue = self.hashfunction(key, len(self.throw))  # 创建哈希值
        if self.throw[hashvalue] is None:
            self.throw[hashvalue] = key  # 将key值给哈希表的throw
            self.data[hashvalue] = value  # 将value值给哈希表的data
        else:
            if self.throw[hashvalue] == key:
                self.data[hashvalue] = value
            else:
                nextslot = self.rehash(hashvalue, len(self.throw))
                while self.throw[nextslot] is not None and self.throw[nextslot] != key:
                    nextslot = self.rehash(nextslot, len(self.throw))
                if self.throw[nextslot] is None:
                    self.throw[nextslot] = key
                    self.data[nextslot] = value
                else:
                    self.data[nextslot] = value

    def rehash(self, oldhash, size):
        return (oldhash + 1) % size

    def hashfunction(self, key, size):
        return key % size

    # 从计算初始哈希值开始。如果值不在初始槽中，则 rehash 用
    # 于定位下一个可能的位置。
    def get(self, key):
        startslot = self.hashfunction(key, len(self.throw))
        data = None
        found = False
        stop = False
        pos = startslot
        while pos is not None and not found and not stop:
            if self.throw[pos] == key:
                found = True
                data = self.data[pos]
            else:
                pos = self.rehash(pos, len(self.throw))
                # 回到了原点，表示找遍了没有找到
                if pos == startslot:
                    stop = True
        return data

    # 重载载 __getitem__ 和 __setitem__ 方法以允许使用 [] 访问
    def __getitem__(self, key):
        return self.get(key)

    def __setitem__(self, key, value):
        return self.put(key, value)


H = HashTable()  # 创建哈希表
H[16] = "红"  # 给哈希表赋值
H[28] = "橙"
H[32] = "黄"
H[14] = "绿"
H[56] = "青"
H[36] = "蓝"
H[71] = "紫"
print("key的数据是：", H.throw)  # 输出键key
print("value的数据是：", H.data)  # 输出值value
print("结果是:", H[28])  # 根据key=28查value
print("结果是:", H[71])  # 根据key=71查value
print("结果是:", H[93])  # 根据key=93查value

def search(data, key):  # 用二分查找 想要查找的数据在哪块内
    length = len(data)  # 数据列表长度
    first = 0  # 第一位数位置
    last = length - 1  # 最后一个数据位置
    print(f"长度:{length} 分块的数据是:{data}")  # 输出分块情况
    while first <= last:
        mid = (last + first) // 2  # 取中间位置
        if data[mid] > key:  # 中间数据大于想要查的数据
            last = mid - 1  # 将last的位置移到中间位置的前一位
        elif data[mid] < key:  # 中间数据小于想要查的数据
            first = mid + 1  # 将first的位置移到中间位置的后一位
        else:
            return mid  # 返回中间位置
    return False

# 分块查找
def block(data, count, key):  # 分块查找数据，data是列表，count是每块的长度，key是想要查找的数据
    length = len(data)  # 表示数据列表的长度
    block_length = length // count  # 一共分的几块
    if count * block_length != length:  # 每块长度乘以分块总数不等于数据总长度
        block_length += 1  # 块数加1
    print("一共分", block_length, "块")  # 块的多少
    print("分块情况如下：")
    for block_i in range(block_length):  # 遍历每块数据
        block_data = []  # 每块数据初始化
        for i in range(count):  # 遍历每块数据的位置
            if block_i * count + i >= length:  # 每块长度要与数据长度比较，一旦大于数据长度
                break  # 就退出循环
            block_data.append(data[block_i * count + i])  # 每块长度要累加上一块的长度
        result = search(block_data, key)  # 调用二分查找的值
        if result != False:  # 查找的结果不为False
            return block_i * count + result  # 就返回块中的索引位置
    return False

data = [23, 43, 56, 78, 97, 100, 120, 135, 147, 150, 155]  # 数据列表
result = block(data, 4, 150)  # 第二个参数是块的长度，最后一个参数是要查找的元素
print("查找的值得索引位置是:", result)  # 输出结果

def fibonacci_search(data, key):
    # 需要一个现成的斐波那契列表。其最大元素的值必须超过查找表中元素个数的数值
    F = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
         233, 377, 610, 987, 1597, 2584, 4181, 6765]
    low = 0  # 低位
    high = len(data) - 1  # 高位
    # 为了使得查找表满足斐波那契特性，在表的最后添加几个同样的值
    # 这个值是原查找表的最后那个元素的值
    # 添加的个数由F[k]-1-high决定
    k = 0
    while high > F[k] - 1:
        k += 1
    i = high  # 将i定位到high的位置
    while F[k] - 1 > i:  # 添加数据
        data.append(data[high])  # 追加到high之后的位置上
        i += 1
    print("添加后的数据", data)  # 输出追加后的数据
    # 算法主逻辑，count用于展示循环的次数
    while low <= high:  # 满足低位小于等于高位
        # 为了防止F列表下标溢出，设置if和else
        if k < 2:
            mid = low
        else:
            mid = low + F[k - 1] - 1
        print("低位位置：%s, 中间位置：%s,高位位置：%s" % (low, mid, high))  # 输出每次分割情况
        if key < data[mid]:  # 目标数据小于中间值数据，在左侧寻找
            high = mid - 1  # 高位位置移到mid-1的位置
            k -= 1  # 下标k此时减1
        elif key > data[mid]:  # 目标数据大于中间值数据，在右侧寻找
            low = mid + 1  # 低位位置移到mid+1的位置
            k -= 2  # 下标k此时减2
        else:  # 否则
            if mid <= high:  # 中间值小于等于mid
                return mid  # 此时的结果是mid就是目标值得位置，返回mid即可
            else:  # 如果mid大于了高位位置值
                return high  # 此时的结果直接返回high的值
    return False


# 验证数据
data = [9, 10, 13, 15, 22, 29, 37, 48, 53]  # 数据列表
key = int(input("请输入想要查找的数据："))
result = fibonacci_search(data, key)  # 调用斐波那契查找函数
print("目标数据", key, "的位置是", result)  # 输出结果