Uma espécie de bolha
algoritmo bubble sort funciona da seguinte forma:
Comparar elementos adjacentes. Se a primeira é maior do que o segundo, os dois trocaram.
Fazer o mesmo trabalho para cada par de elementos adjacentes, desde o início até o final do primeiro ao último par. Uma vez feito isso, o último elemento é o maior número.
Repita essas etapas para todos os elementos, exceto a última.
Continua a repetir os passos acima descritos para cada vez menos e menos elementos, um par de números até que não haja necessidade de comparar.
Acima trecho da Wikipedia
implementação de código:
def bubble_sort (numberlist):
comprimento = len (numberlist)
para i na gama (comprimento):
para j na gama (1, comprimento - i):
se numberlist [j - 1]> numberlist [j]:
numberlist [j], numberlist [j - 1] = numberlist [j - 1], numberlist [j]
retorno numberlist
二,选择排序
Seleção Sort (Seleção tipo) é um algoritmo simples classificação. Ele funciona da seguinte forma. Em primeiro lugar, encontrar a menor sequência de não triados (grande) elemento, a posição de partida é armazenado na sequência ordenada, e, em seguida, continuar a encontrar o elemento mínimo (grande) a partir dos restantes elementos não triados e classificados no final da sequência. E assim por diante, até que todos os elementos estão ordenados.
Acima trecho da Wikipedia
implementação de código:
def findSmallest (arr): # para descobrir o menor elemento na matriz, retorna o índice do menor elemento.
ARR = Menor [0]
smallest_index = 0
para I em Range (1, len (ARR).):
IF Menor> ARR [I]:
Menor ARR = [I]
smallest_index = I
voltar smallest_index
def SelectSort (arr):
newArr = []
, enquanto arr:
menor = findSmallest (arr)
newArr.append (arr.pop (menor))
newArr retorno
Em terceiro lugar, tipo de inserção
passos
Começando com o primeiro elemento, que pode ser considerado como tendo sido classificadas
fetches o próximo elemento da verificação em frente na sequência de elementos tem sido encomendados em
se o elemento (ordenadas) é maior do que o novo elemento, o elemento para a posição seguinte
repita o passo 3 até encontrar a posição dos elementos ordenados inferiores ou iguais ao novo elemento
após o elemento é inserido na nova posição
repita os passos 2-5
acima trecho da Wikipedia
implementação de código
def insert_sort (dados):
para k na faixa de (1, len (dados)):
cur = dados [k]
j = k
, enquanto j> 0 e de dados [j - 1]> cur:
Dados [j] = dados [j - 1]
j - = 1
de dados [j] = cur
dados de retorno
四,希尔排序
Shell classificar através de todos os elementos a serem comparadas é dividido em várias áreas para melhorar o desempenho de ordenação por inserção. Isso permite que um elemento de uma só vez pode ser um grande passo em frente na direcção da posição final. O algoritmo então mais e, em seguida, dar pequenos passos para classificar, o último passo é um algoritmo de ordenação por inserção comum, mas a esta etapa, você precisa para classificar os dados já haviam sido reservado quase um bom (esta inserção de tipo mais rápido).
Acima trecho da Wikipedia
implementação de código:
def shell_sort (numberlist):
comprimento = len (numberlist)
lacuna = comprimento // 2
enquanto lacuna> 0:
para i no intervalo (gap, comprimento):
temp = numberlist [i]
j = i
enquanto j> = lacuna e numberlist [ j - lacuna]> Temp:
numberlist [j] = numberlist [j - lacuna]
j - = lacuna
numberlist [j] = temperatura
lacuna = lacuna // 2
retorno numberlist
五,归并排序
Princípio é o seguinte (assumindo elementos de sequência de consenso {displaystyle n}):
A sequência de cada um dos dois números adjacentes operação de junção, um {ceil displaystyle (n / 2) } sequências, cada sequência compreendendo dois classificada / um elemento
se o número de sequência não é um caso da sequência acima irá fundir novamente, formando {ceil displaystyle (n / 4) } sequências, cada sequência compreendendo quatro / três elementos
repetir o passo 2 até que todos os elementos ordenados, isto é, o número de sequência é um
ou mais excerto de Wikipedia
Código é a seguinte:
def merge (esquerda, direita):
resultado = []
enquanto a esquerda e direita:
se deixado [0] <direito [0]:
result.append (left.pop (0))
else:
result.append (right.pop (0 ))
se deixado:
resultado + = esquerda
, se a direita:
resultado + = right
resultado de retorno
def merge_sort (numberlist):
if len (numberlist) <= 1:
retorno numberlist
mid = len (numberlist) // 2
esquerda = numberlist [: meados]
direita = numberlist [mid:]
left = merge_sort(left)
right = merge_sort(right)
return merge(left, right)
Em sexto lugar, classificação rápida
Escolher o número de colunas em um elemento, chamado de "referência" (pivô),
colunas de reordenação, todos menores que o valor de referência é colocado na frente do elemento de referência, todo maior do que os elementos de valor de referência colocadas por trás da referência (o mesmo número pode ser para ambos os lados). Após o fim desta divisão, numa posição intermédia na sequência de referência. Esta divisão é chamado (Partition) operação.
Recursivamente (recursivamente) do que o valor de referência o número de colunas e o sub-elemento é maior do que o valor de referência da coluna número elemento filho.
Recursivo para o fundo, o tamanho é o número de colunas ou um zero, que já está classificado melhor. Este algoritmo vai terminar, porque em cada iteração (iteração), o que vai, pelo menos, um elemento colocado na sua posição final ir.
Acima trecho da Wikipedia
Código é a seguinte:
def quick_sort (matriz):
se len (matriz) <2:
matriz de retorno
mais:
pivô = matriz [0]
menos = [i para i na matriz [1:] Se i <= pivô]
maiores = [i para i na matriz [1]: se i> pivô]
retorno quick_sort (menos) + [pivô] + quick_sort (maior)
七,堆排序
Em termos de instruções em ordem ascendente, a matriz para a pilha máximo (Max-Heap Heap), que é uma propriedades de volume satisfazer o máximo (Max-Heap propriedade) de uma árvore binária: Para cada nó, excepto a raiz i, [pai (i)] ≥ A [i].
Repetir o valor máximo tomado a partir do nó máxima da pilha (o nó da raiz e da última permuta, o último nó de comutação, após a remoção da pilha), e assim a manutenção da acumulação máxima das propriedades de volume residual.
def heap_sort (numberlist):
comprimento = len (numberlist)
def sift_down (início, fim):
raiz = começar
enquanto Verdadeiro:
criança = 2 * raiz + 1
se criança> final:
ruptura
se criança + 1 <= final e numberlist [criança ] <numberlist [criança + 1]:
criança + = 1
se numberlist [root] <numberlist [criança]:
numberlist [root], numberlist [criança] = numberlist [criança], numberlist [] raiz
root = criança
mais:
quebra
Criando máximo de heap
for start in range((length - 2) // 2, -1, -1):
sift_down(start, length - 1)
heapsort
for end in range(length - 1, 0, -1):
numberlist[0], numberlist[end] = numberlist[end], numberlist[0]
sift_down(0, end - 1)
return numberlist
Oito, contando tipo
acima trecho de Wikipedia
código é a seguinte:
def counting_sort (numberlist, MAXNUMBER): # MAXNUMBER a matriz máximo
comprimento = len (numberlist) # para ser classificada comprimento da matriz
b = [0 para i na gama (comprimento)] # definir a sequência de saída, é inicializado para 0
C = [ 0 para i na gama (MAXNUMBER + 1)] # conjunto tecnologia sequência é inicializado com 0
para J em numberlist ,:
C [J] = C [J] + 1.
para I em gama (1, len ©.):
C [I] = C [I] + C [I -. 1]
por J em numberlist ,:
B [C [J] -. 1] = J
C [J] = C [J] -. 1
retorno B
deste artigo por referência Wikipedia e oito algoritmo de ordenação pitão alcançar compilações
