python排序算法
- Domine os principais algoritmos de classificação em python
Diretório de artigos
1. Visão geral dos algoritmos de classificação
Algoritmos de classificação são um dos problemas mais básicos e comumente usados na ciência da computação. Em aplicações práticas, uma grande quantidade de dados precisa ser classificada para melhores operações, como resumo e consulta. O algoritmo de classificação pode organizar os dados de acordo com certas regras, tornando consultas, cálculos e outras operações mais convenientes e rápidas.
Um algoritmo de classificação é um algoritmo que reorganiza um conjunto de elementos não ordenados em uma ordem específica. Durante o processo de classificação, os tamanhos dos elementos precisam ser comparados de acordo com certas regras e, em seguida, trocados ou movidos para atingir o objetivo do arranjo. Algoritmos de classificação comuns incluem classificação por inserção, classificação por bolha, classificação por seleção, classificação por colina, classificação por mesclagem, classificação rápida, etc. Diferentes algoritmos de classificação têm diferentes vantagens e desvantagens, e precisamos escolher algoritmos diferentes de acordo com necessidades específicas.
2. Classificação por inserção
A classificação por inserção é um algoritmo de classificação simples e intuitivo. Sua ideia básica é inserir um registro em uma lista ordenada existente para obter uma nova lista ordenada. Na implementação específica, podemos inserir elementos não classificados nas partes classificadas, um por um, para que os elementos sejam ordenados gradualmente. A complexidade de tempo do algoritmo de classificação por inserção é O(n^2) e a complexidade de espaço é O(1).
Código:
def insertion_sort(arr):
for i in range(len(arr)):
j = i
while j > 0 and arr[j] < arr[j-1]:
arr[j], arr[j-1] = arr[j-1], arr[j]
j -= 1
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
insertion_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
3. Classificação de bolhas
Bubble sort também é um algoritmo de classificação simples, cuja ideia básica é conseguir a classificação comparando e trocando dois elementos adjacentes. Na implementação específica, percorremos repetidamente a sequência a ser classificada, comparando os tamanhos de dois elementos adjacentes a cada vez e trocando-os se não estiverem na ordem correta até que todos os elementos da sequência sejam classificados. A complexidade de tempo do algoritmo de classificação por bolha é O(n^2) e a complexidade de espaço é O(1).
Código:
def bubble_sort(arr):
n = len(arr)
for i in range(n - 1):
for j in range(n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
bubble_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
4. Selecione a classificação
A classificação por seleção é um algoritmo de classificação simples e intuitivo. Sua ideia básica é selecionar o menor (ou maior) elemento da sequência a ser classificada a cada vez e colocá-lo no final da sequência classificada. Quando implementado, selecionamos repetidamente o menor elemento da parte não classificada e o trocamos pelo elemento final classificado até que toda a sequência seja classificada. A complexidade de tempo do algoritmo de classificação por seleção é O(n^2) e a complexidade de espaço é O(1).
Código:
def selection_sort(arr):
n = len(arr)
for i in range(n - 1):
min_index = i
for j in range(i + 1, n):
if arr[j] < arr[min_index]:
min_index = j
arr[i], arr[min_index] = arr[min_index], arr[i]
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
selection_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
5. Classificação de colinas
A classificação Hill também é um algoritmo de classificação simples e eficaz, cuja ideia básica é conseguir a classificação dividindo a sequência em várias subsequências. Durante a implementação específica, primeiro dividimos a sequência em várias subsequências, realizamos a classificação por inserção em cada subsequência, de modo que o interior da subsequência seja basicamente ordenado e, em seguida, reduzimos gradualmente o escopo da subsequência até que toda a sequência esteja ordenada. A complexidade de tempo do algoritmo de classificação de Hill é O(nlogn) e a complexidade de espaço é O(1).
Código:
def shell_sort(arr):
n = len(arr)
gap = n // 2
while gap > 0:
for i in range(gap, n):
j = i
while j >= gap and arr[j] < arr[j - gap]:
arr[j], arr[j - gap] = arr[j - gap], arr[j]
j -= gap
gap //= 2
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
shell_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
6. Mesclar classificação
Merge sort é um algoritmo de classificação eficiente.Sua ideia básica é mesclar duas subsequências ordenadas em uma sequência ordenada maior. Na implementação específica, primeiro dividimos recursivamente a sequência a ser classificada em várias subsequências e, em seguida, mesclamos essas subsequências até que toda a sequência seja classificada. A complexidade de tempo do algoritmo de classificação por mesclagem é O(nlogn) e a complexidade de espaço é O(n).
Código:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
result = []
i, j = 0, 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
merge_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
7. Classificação rápida
A classificação rápida é um algoritmo de classificação eficiente. Sua ideia básica é conseguir a classificação por meio do método de divisão e conquista. Na implementação específica, primeiro selecionamos um elemento como o "centro do eixo" e, em seguida, dividimos a sequência a ser classificada em duas partes, de modo que os elementos na parte esquerda sejam menores que o centro do eixo e os elementos na parte direita são maiores que o centro do eixo e, em seguida, compare recursivamente as partes esquerda e direita. Basta classificar as partes. A complexidade de tempo do algoritmo de classificação rápida é O(nlogn) e a complexidade de espaço é O(n).
Código:
python
def quick_sort(arr, left, right):
if left >= right:
return arr
pivot = arr[left]
i, j = left, right
while i < j:
while i < j and arr[j] >= pivot:
j -= 1
arr[i] = arr[j]
while i < j and arr[i] < pivot:
i += 1
arr[j] = arr[i]
arr[i] = pivot
quick_sort(arr, left, i - 1)
quick_sort(arr, i + 1, right)
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
quick_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
9. Comparação de algoritmos
Em aplicações práticas, diferentes algoritmos de classificação têm diferentes vantagens e desvantagens, e precisamos escolher o algoritmo apropriado de acordo com necessidades específicas. Abaixo, comparamos a complexidade de tempo e a complexidade de espaço dos algoritmos de classificação acima.
Algoritmo de classificação complexidade de tempo média pior complexidade de tempo complexidade de espaço
classificação de inserção O (n ^ 2) O (n ^ 2) O (1)
classificação de bolha O (n ^ 2) O (n ^ 2) O (1)
Classificação de seleção O (n ^ 2) O (n ^ 2) O (1)
Classificação de colina O (nlogn) O (n ^ 2) O (1)
Classificação de mesclagem O (nlogn) O (nlogn) O (n)
Classificação rápida O (nlogn) O (n) ^2) O(n)
Como pode ser visto na tabela acima, diferentes algoritmos de classificação têm diferentes complexidades de tempo e complexidade de espaço. Em aplicações práticas, precisamos escolher um algoritmo apropriado para operações de classificação para obter melhores resultados.