Encontrar e algoritmo de classificação

A. Find

1. pesquisa sequencial (pesquisa linear) O (n)

##li=[4,5,6,9,3,7],查找9
def search(li, val):
    for i in range(len(li)):
        if li[i]==val:
            return i
    return -1
>>> 3

2. busca binária O (log n)

##li = [1,3,6,9,44,67,88](列表要有序),查找9
def bin_search(li, val):
    low = 0
    high = len(li) - 1
    while low <= high:
        mid = (low + high) // 2
        if li[mid] == val:
            print(mid)
            return mid
        elif li[mid] < val:
            low = mid + 1
        else:
            high = mid - 1
    else:
        print("没有这个值")
>>>3

II. Sort

lowB trio

1. Bubble Sort

O número de um grupo a ser classificados no número total dentro do intervalo em curso não tiver sido classificados ordem dos dois números adjacentes para comparar, de cima para baixo, de modo que um maior número de afundamento, menor para assumir. Ou seja: sempre que duas adjacentes relativamente poucos encontrar o seu requisitos de sequenciamento e sequenciamento oposto, eles vão trocar.

##最好情况O(n) # 列表有序
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:稳定
import random
def bubble_sort(li):
    for i in range(len(li)-1):
        exchange = False
        for j in range(len(li)-i-1):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1], li[j]
                exchange = True
        if not exchange:
            break
    return li
li = list(range(15))
random.shuffle(li)
print(li)
res = bubble_sort(li)
print(res)

2. Selecione Sort

Para bubble sort, há um lugar pode ser otimizado, ou seja, durante a viagem, a troca não é necessário vinte e dois, pode escrever para baixo o valor mínimo, o valor mínimo directamente depois de terminar uma viagem para a frente do transdutor.

##最好情况O(n^2)
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:不稳定
import random
def select_sort(li):
    for i in range(len(li)-1):
        min_pos = i
        for j in range(i+1, len(li)):
            if li[j] < li[min_pos]:
                min_pos = j
        li[i], li[min_pos] = li[min_pos], li[i]
    return li

li = list(range(15))
random.shuffle(li)
print(li)
res = select_sort(li)
print(res)

3. Inclusão Sort

Um registro para a lista ordenada é classificada, resultando em um novo recorde ordenados por número na Tabela 1. Isto é, a primeira ficha como a primeira sequência é uma sequência ordenada, e, em seguida, inserido um a um, da segunda gravação, até que toda a sequência de ordenada até agora.

##最好情况O(n)
##平均情况O(n^2)
##最坏情况O(n^2)
##稳定性:稳定
import random
def insert_sort(li):
    for i in range(1, len(li)):
        tmp = li[i]
        j = i - 1
        while j >= 0 and li[j] > tmp:
            li[j+1] = li[j]
            j -= 1
        li[j+1] = tmp
    return li

li = list(range(15))
random.shuffle(li)
print(li)
res = insert_sort(li)
print(res)

NB trio

1. Breve Sort

Selecção de um elemento de referência, um elemento que é menor do que o elemento de referência na parte frontal, maior que o elemento de referência é colocado por trás do elemento, em seguida, o valor de referência é menor do que o número de colunas de um número de sub-elementos e o elemento de referência é maior do que o método original de coluna ordenada até que toda a sequência de ordenada;

##最好情况O(nlogn)
##平均情况O(nlogn)
##最坏情况O(n^2) # 列表有序并倒序(从小到大排序)
##稳定性:不稳定

##方法一
import random
def quicksort(li, left, right):
    if left < right:
        mid = random_partition(li, left, right)
        quicksort(li, left, mid-1)
        quicksort(li, mid+1, right)
    return li
    
#优化快排最坏情况   
def random_partition(li, left, right):
    i = random.randint(left, right)
    li[i], li[left] = li[left], li[i]
    return partition(li, left, right)

def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp:
            right -= 1
        li[left] = li[right]
        while left < right and li[left] <= tmp:
            left += 1
        li[right] = li[left]
    li[left] = tmp
    return left
li = list(range(15))
random.shuffle(li)
print(li)
res = quicksort(li)
print(res)

##方法二
import random
def quick_sort(li):
    if len(li) < 2:
        return li
    temp = li[0]
    left = [v for v in li[1:] if v <= temp]
    right = [v for v in li[1:] if v > temp]
    left = quick_sort(left)
    right = quick_sort(right)
    return left + [temp] + right
li = list(range(15))
random.shuffle(li)
print(li)
res = quick_sort(li)
print(res)

2. heapsort

montão binária é uma árvore binária completa ou árvore binária quase completa. satisfaz montão binários duas propriedades:
a chave (1) o nó pai é sempre maior do que ou igual a (menos do que ou igual a) uma chave para nenhum nó filho;
(2) de cada sub-árvore esquerda nó e sub direita é um amontoado binário;
raiz grande chave nó pai quando a pilha é sempre maior ou igual a qualquer tecla quando um nó filho. Quando o nó pai é sempre menor ou igual a qualquer tecla chave é uma pequena pilha nó raiz infantil;

##最好情况O(nlogn)
##平均情况O(nlogn)
##最坏情况O(nlogn)
##稳定性:不稳定

#大根堆
## O(nlogn)
def sift(li, low, high):
    tmp = li[low]
    i = low
    j = 2 * i + 1
    while j <= high:
        if j + 1 <= high and li[j] < li[j+1]:
            j += 1
        if li[j] > tmp:
            li[i] = li[j]
            i = j
            j = 2 * i + 1
        else:
            break
    li[i] = tmp

def heap_sort(li):
    n = len(li)
    for low in range((n-1)//2, -1, -1):
        sift(li, low, n-1)
    print(li)
    for high in range(n-1, -1, -1):
        li[0], li[high] = li[high], li[0]
        sift(li, 0, high-1)

import random
li = list(range(15))
random.shuffle(li)
print(li)
heap_sort(li)
print(li)