Algoritmo de clasificación (clasificación Hill, clasificación rápida, clasificación combinada (análisis de imágenes en movimiento))

Tipo de colina

Hill sort (Shell Sort) es un tipo de inserción. También conocida como ordenación incremental reducida, es una versión más eficiente y mejorada del algoritmo de ordenación por inserción directa. La clasificación de colinas es un algoritmo de clasificación inestable.
La idea básica de la clasificación Hill es : enumerar la matriz en una tabla e insertar y ordenar las columnas por separado, repita este proceso, pero use una columna más larga cada vez (la longitud del paso es más larga, la cantidad de columnas es menor). Al final, toda la tabla tiene una sola columna. La conversión de la matriz a la tabla es para comprender mejor el algoritmo, y el algoritmo en sí todavía usa matrices para ordenar .

Análisis 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)

complejidad del tiempo

Complejidad temporal óptima: diferente según la secuencia de pasos.
Peor complejidad temporal: O (n ^ 2)
pensamiento estable: inestable

Ordenación rápida

Clasificación rápida (en inglés: Quicksort), también conocida como clasificación de intercambio de partición (clasificación de intercambio de partición), divide los datos que se van a clasificar en dos partes independientes a través de una clasificación, todos los datos de una parte son más pequeños que todos los datos de la otra parte , Y luego clasifique rápidamente las dos partes de los datos de acuerdo con este método. Todo el proceso de clasificación se puede realizar de forma recursiva para que todos los datos se conviertan en una secuencia ordenada.

Análisis 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)

complejidad del tiempo

Complejidad de tiempo óptima: O (nlogn)
Peor complejidad de tiempo: O (n ^ 2)
Estabilidad: Inestable

Combinar ordenación

La clasificación por combinación es una aplicación muy típica de divide y vencerás. La idea de la ordenación por fusión es descomponer la matriz de forma recursiva y luego fusionar la matriz.
Después de descomponer la matriz al tamaño más pequeño y luego fusionar las dos matrices ordenadas, la idea básica es comparar el primer número de las dos matrices, y tomar la que es más pequeña primero, y luego mover el puntero correspondiente un bit después tomando el número. Luego compare hasta que una matriz esté vacía y finalmente copie la parte restante de la otra matriz.

Análisis de algoritmos

El análisis final del principio del algoritmo es el mismo, así que escribí una 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)

complejidad del tiempo

Complejidad de tiempo óptima: O (nlogn)
Peor complejidad de tiempo: O (nlogn)
Estabilidad: estable

Comparación de la eficiencia de los algoritmos de clasificación comunes