Quatro algoritmos de busca

Encontrar algoritmo

Pesquisa linear

Definição: é para descobrir se existe um determinado valor em um conjunto de dados (lista) e retornar o subscrito de seu local de armazenamento. O problema mais importante que o algoritmo de pesquisa precisa resolver é como abordar o valor-alvo no menor tempo possível.
Pesquisa linear : significa que nenhum método é usado e é julgado um por um diretamente do começo ao fim. Mas, como a violência é simples, não há necessidade de a lista ser ordenada.

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()))

Pesquisa binária

Pesquisa binária : você deve garantir que os dados que estão sendo pesquisados ​​estejam ordenados. Sua estratégia de busca é: primeiro julgar o valor intermediário e compará-lo com o valor-alvo; se for maior, descarte a metade menor dos dados à esquerda; se menor que, descarte a metade maior dos dados à direita; se forem iguais, foi encontrado. A eficiência de tempo da pesquisa binária para dados ordenados é 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()))

Pesquisa de interpolação

Pesquisa de interpolação : a pesquisa de interpolação é parcialmente aprimorada com base na pesquisa binária, portanto, também é necessário solicitar os dados. Ele melhora o método de cálculo do meio = (esquerda + direita) / 2 diretamente para cada pesquisa binária. Usando o conhecimento da análise matemática, o ponto de divisão foi alterado para ** esquerda + (direita-esquerda) * (int ((findVal-arr [esquerda]) / (arr [direita] -arr [esquerda]))), No entanto, antes do uso, é necessário determinar se o valor-alvo é maior que o valor máximo dos dados ou menor que o valor mínimo dos dados; caso contrário, haverá risco de transfronteiriço.

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()))

Pesquisa de Fibonacci

Pesquisa de Fibonacci : Após ler os dois métodos de pesquisa acima, você descobre que o algoritmo de pesquisa é um algoritmo que separa os dados e se aproxima do valor-alvo, e matematicamente existe um método de divisão clássico - a seção de ouro 0,618. E a seção dourada passa a ter uma relação matemática com a sequência de Fibonacci. Usando a sequência de Fibonacci para dividir o número anterior e o próximo número, acontece que ele se aproxima da proporção áurea. A partir disso, produzimos um novo algoritmo de busca: busca 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()))