preâmbulo:
Um algoritmo bubble sort
Dois bolha realização programa espécie
Três algoritmo de ordenação rápida
Quatro classificação rápida realização do programa algoritmo
O algoritmo de ordenação primeira bolha
breve introdução
Bubble Sort (Bubble Sort), é uma ciência da computação simples campo algoritmo de classificação .
Ele elementos da coluna para ordenar visitou várias vezes, a fim de comparar dois elementos adjacentes, se sua ordem (como descendente, a primeira letra de A a Z) erros que troca assumiu. Trabalhando elemento de visita é repetido até que não há necessidade de trocar elementos adjacentes, ou seja, a coluna elemento tem sido ordenados concluída.
O nome vem do algoritmo de facto elementos maiores irão trocar gradualmente através de um "flutuador" para o início do número da coluna (ascendente ou descendente), como se o dióxido de carbono das bolhas numa bebida gaseificada, eventualmente, flutuar para o topo do mesmo bolha, daí o nome" classificar ".
princípio
algoritmo princípio bubble sort é a seguinte:
-
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 do primeiro par ao final do último par. Neste ponto, deve ser 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.
Análise Algorithm
complexidade de tempo
Se o estado inicial é o arquivo de sequência positiva, uma passagem para completar o pedido. O número de comparações necessárias palavras-chave 
e registrar o número de celular 
Ter atingido um mínimo:
,
.
Portanto, a melhor bubble sort complexidade de tempo é 
.
Se o arquivo original está em ordem inversa, a necessidade de
Classificando viagem. Para ordenar por viagem
Comparação dos tempos de uma palavra-chave (1≤i≤n-1), e um registo de cada comparação deve ser movido três vezes para conseguir posição de troca de ficha. Neste caso, a comparação e atingiu o número máximo de celular:
O pior complexidade de tempo de bubble sort é
.
[1] Em resumo, por conseguinte, a média bolha tipo complexidade global tempo é
.
estabilidade Algorithm
Bubble sort é os elementos pequenos movê-lo para frente ou para trás nas grandes elementos. Comparação entre dois elementos adjacentes é mais, também a troca ocorre entre estes dois elementos. Portanto, se os dois elementos são iguais, então a troca não irá, se não há dois elementos adjacentes iguais, mesmo que a frente por permuta de pares a duas adjacentes-se, desta vez não serão trocados, os mesmos elementos antes e após a ordem não mudou, de modo que o bubble sort é um algoritmo estável espécie.
O segundo algoritmo bubble sort
linguagem C
#include <stdio.h>
#define ARR_LEN 255 / * comprimento máximo do array * /
#define elemType int / * Tipo de elemento * /
/ * bubble sort * /
/ * 1. A partir do elemento atual, para trás sequencialmente comparando cada elemento adjacente, se a comutação reversa * /
/ * 2. repetição dos passos anteriores para todos os elementos, até o último elemento de * /
/ * elemType ARR []: triagem da matriz de destino; int len: o número de elementos * /
BubbleSort vácuo (elemType ARR [], int len) {
elemType TEMP;
eu int, J;
for (i = 0; I <len-1; i ++) / * o circuito externo é para classificar o número de voltas, o número len para len-1 vezes * /
para (j = 0; J <; vezes. len- 1-j i ++) {/ * o loop interno é o número de vezes por comparação viagem, o i-ésimo comparador viagem len-i * /
IF (ARR [J]> ARR [J + 1]) {/ * comparando elementos adjacentes, então o interruptor quando a ordem inversa (maior do que o direito do ascendente esquerda, descendente e vice-versa) * /
TEMP = ARR [J];
ARR [J] = ARR [J + 1];
ARR [J + . 1] = TEMP;
}
}
}
int principal (void) {
elemType arr [ARR_LEN] = {3,5,1, -7,4,9, -6,8,10,4};
int len = 10;
int i;
BubbleSort (arr, len);
for (i = 0; i <len; i ++)
printf ( "% d \ t", arr [i]);
putchar ( '\ n');
return 0;
}
3 Breve algoritmo de classificação
classificação rápida (Quicksort) é uma melhoria sobre o tipo de bolha.
Breve tipo proposto por CAR Hoare em 1960. A idéia básica é: uma viagem ao ordenar os dados a serem classificados em duas partes independentes, a parte onde todos os dados do que a outra parte de todos os dados para ser pequeno, então este método de dados para as duas partes rápido separadamente triagem, a triagem de todo o processo pode ser de forma recursiva, a fim de alcançar os dados inteiros numa sequência ordenada.
É fornecido para classificar a matriz A [0] ...... Um [N-1], seleccionar qualquer de um primeiro dados (o primeiro número é geralmente escolhida de matriz) de dados como uma chave, e, em seguida, todos é menor do que o número dos que são colocados em esquerda, todos maiores do que seus números são colocados à sua direita, um processo conhecido como uma viagem para a classificação rápida. É digno de nota que, rápida tipo não é um algoritmo de ordenação estável, isto é, as mesmas posições relativas da pluralidade de valores podem oscilar no final do algoritmo.
Uma viagem ao algoritmo de ordenação rápida é:
1) definir duas variáveis de i, j, no início do tipo: i = 0, j = N-1;
2) para o primeiro elemento de matriz como os dados de chave, atribuído a chave , isto é, chave = A [0];
3) Pesquisa para a frente a partir de j, isto é, começando a partir da pesquisa para a frente (J,), para encontrar um inferior a primeira chave valor Um [j], o A [j] e A [i] troca valor;
4) começam na parte de trás pesquisa i, isto é, antes do início da busca para trás (i ++), encontra o primeiro é maior do que a chave de A [i], o A [i] e troca Um [j] valor;
5) Repita os passos 3 e 4 até que i = j; (3,4 etapa, não encontrou valor qualificado, isto é, 3 A [j] é não inferior à chave , em 4 a [i] não é maior do que a. Tecla vez mudando j, o valor de I de tal modo que j = j-1, i = i + 1, até encontrar encontrado valor qualificado, quando a troca de i, j posição do ponteiro inalterada. Além disso, i == j que processo deve ser exatamente o tempo i + J ou concluída, de modo que neste momento o fim do ciclo).
Pode funcionar qsort () pode ser encomendado gama diretamente em linguagem C.
uso:
qsort vazio (base void *, int nelem, largura, int (* FCMP) (* const vazio, const void *));
Parâmetros:
um primeiro endereço a ser classificados de matriz
2 para ser matriz classificada elemento número
3 na pegada o tamanho de cada elemento
ponteiro 4 pontos de uma função para determinar sequencialmente uma ordenação
complexidade de tempo
Melhor caso complexidade de tempo de O (nlogn), o processo é mais complexo, não é repetida aqui.
Cada tomar o pior caso para o número (número de referência) é o valor máximo / mínimo da corrente a ser comparado é, neste caso, de cada vez apenas para obter um número de sequência inferior a 1 (isto é, quer tudo maior do que o número de referência, ou menor do que a referência completa), em seguida, uma espécie de bolha é equivalente, o número de comparações = (n - 1) + (n - 2) + ... + 2 + 1 = ( n - 1) * n / 2, neste caso complexidade de tempo é: O (n ^ 2). Normalmente, ele aparece no pior caso: ser dados ordenados em si já é uma sequência positiva ou linha ordem inversa bom.
complexidade espaço
Na verdade, esta não é uma boa cálculo complexidade espacial, porque algumas pessoas usam a classificação não-lugar, calculado como ruim (porque algumas pessoas usaram a matriz auxiliar, por isso, é necessário calcular o número de seu elemento) , vou analisar no espaço situ sob complexidade quicksort dela;
Primeiro lugar espaço quick utilizado é O (1), que é um nível constante, e o espaço real é consumido por chamadas recursivas, porque cada necessário recursiva para manter alguns dos dados;
A complexidade óptima espaço caso: O (log n); bissecta a matriz de cada vez que um caso
O pior caso complexidade espaço é: O (n); caso degenerado do tipo bolha
Quarta rápida realização programa de algoritmo de ordenação
A rápida espécie de mais rápido, porque em comparação com bubble sort, cada bolsa é trancos e barrancos. Toda vez que ao ordenar um ponto de referência definido, o ponto de referência será menor do que igual ao número de todos colocados à esquerda do ponto de referência, o ponto de referência será maior do que o número igual ao de referência total para o ponto certo. Então, cada vez que o câmbio não vai ser o mesmo que o tipo de bolha só podem ser trocadas entre números adjacentes a partir da troca da grande mais. Portanto, o número total de comparação e troca de ter velocidade menos natural seria aumentado. Claro que, no pior caso, pode ainda ser o número dois adjacente foram trocadas. Então, o pior complexidade de tempo de classificação rápida e bubble sort é o mesmo é O (N2), a sua complexidade média de tempo de O (n log n).
Breve tipo:
#include <stdio.h>
int A [101], n-; // definir variáveis globais, estas variáveis requer o uso de duas sub-funções em
quicksort void (int esquerda, direita int) {
int I, J, T, TEMP;
IF (esquerda> direita)
retorno;
TEMP = a [esquerda]; // TEMP é armazenada no número de referência
i = left;
J = direito;
o while (! I = J) {// ordem é importante, primeiro da direita para encontrar
o tempo (a [J]> = TEMP && I <J)
J ,;
o tempo (a [I] <= TEMP && I <J) // encontrar o direito
I ++;
IF (I < j) // lugares de troca nos dois números de matriz
{
T = uma [I];
a [i] = uma [J];
um [j] = T;
}
}
// homing números de referência será, eventualmente,
um [ esquerda] = uma [i];
A [I] = TEMP;
sort (esquerda ,. 1-I); // continuar o processamento da esquerda, existe um processo recursivo
quick (i + 1, direita) ; // continuar a processar o mesmo, existe uma recursiva processo
}
int main () {
int i;
// dados de leitura
Scanf ( "% D", e n-);
for (i = 1;. I <= N-; i ++)
Scanf ( "% D", & a [i]) ;
sort (1, n.); // quick chamada
após // classifica a saída
for (i = 1;. eu <n-; i ++)
a printf ( "% D", a [i]);
printf ( "% D \ n-", A [n-]);
retorno 0;
}
