【算法与数据结构】二分查找、插值查找、斐波那契查找—Python实现

# 二分查找
def BinarySearch(arr, left, right, findVal):
    print("二分查找")
    # 找到就返回
    if left > right:
        return -1
    mid = (left + right) // 2  # 中间值索引
    midVal = arr[mid]  # 中间值
    if findVal > midVal:  # 要查找的值大于中间值则向右递归
        return BinarySearch(arr, mid+1, right, findVal)
    elif findVal < midVal:  # 要查找的值小于中间值则向左递归
        return  BinarySearch(arr, left, mid-1, findVal)
    else:  # 找到后返回
        return mid


def insertSearch(arrA, left, right, findVal):
    # 插值查找
    # 找到就返回
    print("差值查找")
    # 必须添加findVal > arrA[len(arrA)-1] or findVal < arrA[0]两个条件，防止index超出边界
    if left > right or findVal > arrA[len(arrA)-1] or findVal < arrA[0]:
        return -1
    mid = left + (right - left) * (findVal - arrA[left]) // (arrA[right] - arrA[left])
    midVal = arrA[mid]  # 中间值
    if findVal > midVal:  # 要查找的值大于中间值则向右递归
        return BinarySearch(arrA, mid+1, right, findVal)
    elif findVal < midVal:  # 要查找的值小于中间值则向左递归
        return  BinarySearch(arrA, left, mid-1, findVal)
    else:  # 找到后返回
        return mid


def binarySearch2(arr, left, right, findVal):
    non = []  # 找不到就返回空列表
    resArr = []  # 找到后将索引添加到此列表
    if left > right:
        return non
    mid = (left + right) // 2
    # 二分查找相当于是用中间值参与运算
    # mid = left + (right - left) * (midValue - arr[left]) / (arr[right] - arr[left])
    # 下面是插值查找
    # mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left])
    midValue = arr[mid]
    if findVal > midValue:
        return binarySearch2(arr, left, mid+1, findVal)
    elif findVal < midValue:
        return binarySearch2(arr, mid-1, right, findVal)
    else:
        temp = mid-1
        while True:
            if temp < 0 or arr[temp] != findVal:
                # 若当前索引已超过左边界或者当前值不等于要查找的值就退出
                break
            resArr.append(temp)  # 找到后添加到了表
            temp -= 1
        resArr.append(mid)  # 将中间值添加到列表
        temp = mid + 1
        while True:
            if temp > len(arr)-1 or arr[temp] != findVal:
                # 向右查找
                break
            resArr.append(temp)
            temp += 1
        return resArr


if __name__ == '__main__':
    # 二分查找，找到所有值
    arr = [1,24,35,67,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,89,1234]
    resArr = binarySearch2(arr, 0, len(arr)-1, 89)  # 向左查找时索引值会倒序排列
    resArr = sorted(resArr)  # 将找到的索引值排序
    print("二分查找结果为", resArr)

    # 插值查找与二分查找次数比较
    # 插值查找
    arrA = [i + 1 for i in range(100)]  # [1,2,3,.....100]
    print(arrA)
    resA = insertSearch(arrA, 0, len(arrA)-1, 99)
    print(resA)
    # 二分查找
    res = BinarySearch(arrA, 0, len(arrA)-1, 99)
    print(res)

----------------------------------------------------------------------------------------

2020.8.4更新 

斐波那契查找代码如下：

def Fib():
    # 生成斐波那契数列[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
    arr = [0 for i in range(10)]
    arr[0] = 1
    arr[1] = 1
    i = 2
    while i < len(arr):
        arr[i] = arr[i - 1] + arr[i - 2]
        i += 1
    return arr


def FibSearch(arr, key):
    low = 0
    high = len(arr) - 1
    k = 0
    f = Fib()
    print(f)
    while high > f[k] - 1:
        # 寻找k值
        k += 1
    temp = arr
    while f[k] > len(temp):
        # 将待查找数列的最大值填充到扩充后的数组
        temp.append(arr[high])
    while low <= high:
        mid = low + f[k-1] - 1  # 找到中间值
        if temp[mid] > key:
            high = mid - 1  # 向前寻找，mid值前面有f[k-1]-1个值，在这个数量中在找到一个黄金分割点
            k -= 1
        elif temp[mid] < key:  # 向后寻找
            low = mid + 1
            k -= 2
        else:
            if mid >= high:
                return high
            else:
                return mid
    return -1


if __name__ == '__main__':
    arr = [3, 56, 78, 90, 123, 345, 5678]
    index = FibSearch(arr, 345)
    print(index)