Cuatro algoritmos de búsqueda.

Encontrar algoritmo

Búsqueda lineal

Definición: es para determinar si existe un cierto valor en un conjunto de datos (lista) y devolver el subíndice de su ubicación de almacenamiento. El problema más importante que debe resolver el algoritmo de búsqueda es cómo abordar el valor objetivo en el menor tiempo posible.
Búsqueda lineal : significa que no se utiliza ningún método, y se juzga uno por uno directamente de principio a fin. Pero debido a que la violencia es simple, no hay necesidad de ordenar la lista.

def lineSearch(arr,num):
    flag = 0
    for i in range(len(arr)):
        if arr[i]==num:
            flag=1
            print("找到了，在第{}个位置".format(i+1))
    if flag==0:
        print("没有找到！")
    
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
lineSearch(arr,9000000-1)
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

Búsqueda binaria

Búsqueda binaria : debe asegurarse de que los datos que se buscan estén ordenados. Su estrategia de búsqueda es: primero juzgue el valor intermedio y compárelo con el valor objetivo; si es mayor, descarte la mitad más pequeña de los datos a la izquierda; si es menor, descarte la mitad más grande de los datos a la derecha; La eficiencia temporal de la búsqueda binaria de datos ordenados es O (logn).

def binarySearch(arr,left,right,findVal):
    #定义一个数组储存下标，又可能存在多个相同元素
    resIndex = []
    #arr必须有序
    mid = int((left+right)/2)
    midVal = arr[mid]
    
    if left>right:
        return -1
    
    if findVal > midVal:
        return binarySearch(arr,mid+1,right,findVal)
    elif findVal<midVal:
        return binarySearch(arr,left,mid-1,findVal)
    else:
        temp = mid - 1
        while(True):#左边
            if temp>len(arr)-1 or arr[temp]!=findVal:
                break
            resIndex.append(temp+1)
            temp-=1
            
        resIndex.append(mid+1)#中间
        
        temp=mid+1
        while(True):#右边
            if temp<0 or arr[temp]!=findVal:
                break
            resIndex.append(temp+1)
            temp+=1
        return resIndex

print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
print("Index="+str(binarySearch(arr,0,len(arr),1)))
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

Búsqueda de interpolación

Búsqueda de interpolación : la búsqueda de interpolación se mejora parcialmente en función de la búsqueda binaria, por lo que también es necesario ordenar los datos. Mejora el método de cálculo de middle = (left + right) / 2 directamente para cada búsqueda binaria. Usando el conocimiento del análisis matemático, el punto de división se cambió a ** left + (right-left) * (int ((findVal-arr [left]) / (arr [right] -arr [left]))) **, Sin embargo, antes de su uso, es necesario determinar si el valor objetivo es mayor que el valor máximo de los datos o menor que el valor mínimo de los datos, de lo contrario habrá un riesgo transfronterizo.

def insertSearch(arr,left,right,findVal):
    #定义一个数组储存下标，又可能存在多个相同元素
    resIndex = []
    #arr必须有序
   
    if left>right or findVal<arr[0] or findVal>arr[len(arr)-1]:
        return -1
    
    mid = left + (right-left)*(int((findVal-arr[left])/(arr[right]-arr[left])))
    midVal = arr[mid]
    
    
    if findVal > midVal:
        return insertSearch(arr,mid+1,right,findVal)
    elif findVal<midVal:
        return insertSearch(arr,left,mid-1,findVal)
    else:
        temp = mid - 1
        while(True):#左边
            if temp>len(arr)-1 or arr[temp]!=findVal:
                break
            resIndex.append(temp+1)
            temp-=1
            
        resIndex.append(mid+1)#中间
        
        temp=mid+1
        while(True):#右边
            if temp<0 or arr[temp]!=findVal:
                break
            resIndex.append(temp+1)
            temp+=1
        return resIndex
    
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
print("Index="+str(insertSearch(arr,0,len(arr)-1,1)))
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

Búsqueda de Fibonacci

Búsqueda de Fibonacci : después de leer los dos métodos de búsqueda anteriores, encontrará que el algoritmo de búsqueda es un algoritmo que separa los datos y se acerca al valor objetivo, y matemáticamente existe un método clásico de división: la sección dorada 0.618. Y la sección dorada tiene una relación matemática con la secuencia de Fibonacci. Usando la secuencia de Fibonacci para dividir el número anterior y el siguiente, resulta que se acerca a la proporción áurea. A partir de esto, hemos producido un nuevo algoritmo de búsqueda: la búsqueda de Fibonacci.

import copy
#arr = [1,8,10,89,1000,1234]

import time

arr = [0 for i in range(9000)]
for i in range(9000):
    arr[i]=i

def fib():#非递归
    f = [0 for i in range(9000)]
    f[0]=1
    f[1]=1
    for i in range(2,9000,1):
        f[i]=f[i-1]+f[i-2]
    return f

def fibSearch(arr,key):
    low = 0
    high=len(arr)-1
    k = 0               #分割数字的下标
    mid = 0
    f = fib()
    #获取斐波那契分隔数的下标
    while(high>f[k]-1):
        k+=1
    temp = copy.deepcopy(arr)
    for i in range(high+1,f[k],1):
        temp.append(arr[high])
    
    while(low<=high):
        mid = low+f[k-1]-1
        if key<temp[mid]:#左边查找
            high=mid-1
            k-=1
        elif key>temp[mid]:#右边查找
            low=mid+1
            k-=2
        else:
            if mid<=high:
                return mid
            else:
                return high
    return -1
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))           
print("Index="+str(fibSearch(arr,11) ))     
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))