Algoritmo de classificação (classificação Hill, classificação rápida, classificação por mesclagem (análise de imagem em movimento))

Tipo de colina

Hill Sort (Shell Sort) é um tipo de inserção. Também conhecido como classificação incremental reduzida, é uma versão mais eficiente e aprimorada do algoritmo de classificação por inserção direta. A classificação de colina é um algoritmo de classificação instável.
A ideia básica da classificação de Hill é : listar a matriz em uma tabela e inserir e classificar as colunas separadamente, repetir esse processo, mas usar uma coluna mais longa a cada vez (o comprimento do passo é maior, o número de colunas é menor). No final, toda a tabela possui apenas uma coluna. Converter a matriz em tabela é para entender melhor o algoritmo, e o próprio algoritmo ainda usa matrizes para classificação .

Análise de Algoritmos

// An highlighted block
'''希尔排序'''
def shell_sort(alist):
    n = len(alist)
    # gap为步长，选择gap值的元素进行判断
    gap = n // 2
    #gap值减少为1时，外部循环停止
    while gap > 0:
        # 按步长进行插入排序
        for j in range(gap, n):
            #第一层的数据进行排序后，然后下一层的值为gap+1位置的值
            i = j
            # 将gap位置的值与前gap的值相比较，进行排序
            while i>0:
                if alist[i]<alist[i-gap]:
                    alist[i],alist[i - gap] =alist[i - gap],alist[i]
                    i -= gap
                else:
                    break
        # 得到新的步长
        gap = gap // 2

li = [11,13,5,7,20]
a=[11,13,5,33,4,17,7,20,9,15,10,50]
shell_sort(li)
print(li)
shell_sort(a)
print(a)

complexidade de tempo

Complexidade de tempo ideal: diferente de acordo com a sequência de etapas.
Pior complexidade de tempo: O (n ^ 2)
pensamento estável: instável

Ordenação rápida

Classificação rápida (inglês: Quicksort), também conhecido como classificação de troca de partição (classificação de troca de partição), divide os dados a serem classificados em duas partes independentes por meio de uma classificação, todos os dados em uma parte são menores do que todos os dados na outra parte E, em seguida, classifique rapidamente as duas partes dos dados de acordo com este método. Todo o processo de classificação pode ser executado recursivamente para que todos os dados se tornem uma sequência ordenada.

Análise de Algoritmos

// An highlighted block
"""快速排序"""
def quick_sort(alist, start, end):
    # 递归的退出条件
    if start >= end:
        return
    # 设定起始元素为要寻找位置的基准元素
    mid = alist[start]
    # low为序列左边的由左向右移动的游标
    low = start
    # high为序列右边的由右向左移动的游标
    high = end
    len(alist)
    while low < high:
        # 如果low与high未重合，high指向的元素不比基准元素小，则high向左移动
        while low < high and alist[high] >= mid:
            high -= 1
        # 将high指向的元素放到low的位置上
        alist[low] = alist[high]
        # 如果low与high未重合，low指向的元素比基准元素小，则low向右移动
        while low < high and alist[low] < mid:
            low += 1
        # 将low指向的元素放到high的位置上
        alist[high] = alist[low]
    # 退出循环后，low与high重合，此时所指位置为基准元素的正确位置
    # 将基准元素放到该位置
    alist[low] = mid
    # 对基准元素左边的子序列进行快速排序
    quick_sort(alist, start, low-1)
    # 对基准元素右边的子序列进行快速排序
    quick_sort(alist, low+1, end)

alist = [20,13,5,7,11,30,3,65,45]
quick_sort(alist,0,len(alist)-1)
print(alist)

complexidade de tempo

Complexidade de tempo ideal: O (nlogn)
Pior complexidade de tempo: O (n ^ 2)
Estabilidade: Instável

Mesclar classificação

A classificação de mesclagem é uma aplicação muito típica de dividir e conquistar. A ideia da classificação por mesclagem é decompor a matriz recursivamente e, em seguida, mesclar a matriz.
Depois de decompor a matriz para o menor tamanho e, em seguida, mesclar as duas matrizes ordenadas, a ideia básica é comparar o primeiro número das duas matrizes, pegar aquele que é menor primeiro e, em seguida, mover o ponteiro correspondente um bit para trás pegando o número. Em seguida, compare até que um array esteja vazio e, finalmente, copie a parte restante do outro array.

Análise de Algoritmos

A análise final do princípio do algoritmo é a mesma, então escrevi uma parte

// An highlighted block
def merge_sort(alist):
    if len(alist) <= 1:
        return alist
    # 二分分解
    num = len(alist)//2
    left = merge_sort(alist[:num])
    right = merge_sort(alist[num:])
    # 合并
    return merge(left,right)

def merge(left, right):
    '''合并操作，将两个有序数组left[]和right[]合并成一个大的有序数组'''
    #left与right的下标指针
    l, r = 0, 0
    result = []
    while l<len(left) and r<len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result

alist = [54,26,93,17,77,31,44,55,20]
sorted_alist = merge_sort(alist)
print(sorted_alist)

complexidade de tempo

Complexidade de tempo ideal: O (nlogn)
Pior complexidade de tempo: O (nlogn)
Estabilidade: estável

Comparação da eficiência de algoritmos de classificação comuns