Complexidade do tempo de classificação da bolha
Neste artigo, a ascensão de classificação é considerada. Este artigo tem como objetivo indicar a velocidade relativa do algoritmo de classificação de bolhas. Essa velocidade relativa é chamada de complexidade do tempo. A codificação é feita na linguagem C do computador.
Conteúdo do artigo
- Introdução - Veja acima
- Ilustração de classificação de bolhas
- Pior desempenho
- Melhor desempenho para o tipo de bolha
- Alguma sequência intercalada de elementos já classificados
- Caso perfeito
- Conclusão
Ilustração de classificação de bolhas
Considere a seguinte lista não classificada:
R x f s u z v jExistem 8 elementos, que precisam de 8 varreduras completas, resultando em:
R f s u x v j zF r s u v j x z
F r s u j v x z
F r s j u v x z
F r j s u v x z
F j r s u v x z
F j r s u v x z
F j r s u v x z
O acordo final da lista é do tipo completo.
Pior desempenho
O código C para classificar os oito caracteres anteriores, explicado anteriormente é:
#incluirVoid Bubblesort (char arr [], int n)
int contador = 0;
para (int i = 0; i < n; i++)
for (int j = 1; j; j < n; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
contador+= 1;
printf ("%i \ n", contador);
O código para trocar está no loop interno aninhado. O contador conta o número de operações básicas. Os loops externos do loop de 0 a 7, eu.e., 8 vezes. Os loops internos do loop de 1 a 7, eu.e., 7 vezes. O número total de operações básicas (loop interno) é 8 x 7 = 56. A saída do contador é 56.
Se o loop interno do loop fosse de 0 a 7, o número total de operações básicas teria sido 8 x 8 = 64. Este é o número máximo de operações básicas para este ninho para os loops. Seja 8. Então, o número máximo desses ninhos para os loops é n2.
A pior complexidade do tempo para a função anterior é dada como,
Sobre2)
O grande O seguido por seus parênteses com n2 é chamado de notação Big-O. Indica a velocidade relativa do código. Embora no código anterior, o número de operações básicas seja 56, o número máximo possível de operações, 82 = 64, é o que seria dado para a complexidade do tempo.
Uma função principal C adequada para o código anterior é:
int main (int argc, char ** argv)int n = 8;
char arr [] = 'r', 'x', 'f', 's', 'u', 'z', 'v', 'j';
Bubblesort (arr, n);
para (int i = 0; i
printf ("\ n");
retornar 0;
Melhor desempenho para o tipo de bolha
Aviso na ilustração anterior para o tipo de bolha; Após a primeira varredura, o elemento mais alto está na extremidade direita. Após a segunda varredura, os dois elementos mais altos estão na extremidade direita, a ordem. Após a terceira varredura, os três elementos mais altos estão na extremidade direita, em ordem e assim por diante. Operações nesses elementos extremo à direita à medida que crescem podem ser omitidos na codificação. Isso aumentaria a velocidade geral (tempo para classificação completa). O código modificado a seguir ilustra o seguinte:
Void Bubblesort (char arr [], int n)int contador = 0;
para (int i = 0; i < n; i++)
for (int j = 1; j; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
contador+= 1;
printf ("%i \ n", contador);
Desta vez, a saída do contador é 28. O número de operações básicas é 28, pouco menos da metade de 64, que é 32. Os loops internos do loop de 1 a n - i. Em sua primeira varredura, eu sou zero e n - i = 8.
Agora,
registro2 8 = log2 23
= 3
8 x 3 = 8xlog2 23
= 24
que é perto de 28. Seja n = 8. A última exceção da expressão do operando direito acima, torna-se n.registro2 23, = n.registro2 8, geralmente escrito como, n log n.
Quando a complexidade do tempo está dentro de algum intervalo intermediário, 20 a 40, neste caso, é expressa como:
O (n log n)
Onde n é o número de elementos na lista. Portanto, a complexidade do tempo para o desempenho aprimorado do tipo de bolha é n log n, significando n x log2(n).
Alguma sequência intercalada de elementos já classificados
Existem oito varreduras para a ilustração anterior de classificação de bolhas. Observe que, na sexta varredura, a lista já estava completamente classificada. As duas últimas linhas são repetições da sexta fila. Para esta lista em particular, as duas varreduras anteriores não foram necessárias. Isso acontece quando a lista não classificada dada tem algumas seqüências intercaladas já classificadas. Se a lista fornecida for completamente não classificada, a última linha seria a lista final classificada (não seria uma repetição do anterior).
As últimas linhas como as duas últimas acima podem ser omitidas na classificação e, assim, melhorar o desempenho (velocidade). O código a seguir ilustra o seguinte:
Void Bubblesort (char arr [], int n)_Bool trocado = 0;
para (int i = 0; i < n; i++)
troca = 0;
for (int j = 1; j; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
troca = 1;
se (trocado == 0)
quebrar;
Caso perfeito
O desempenho perfeito ocorre quando a lista fornecida já está completamente classificada. O código para testar isso é:
Void Bubblesort (char arr [], int n)int contador = 0;
_Bool trocado = 0;
para (int i = 0; i < n; i++)
troca = 0;
for (int j = 1; j; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
troca = 1;
contador+= 1;
se (trocado == 0)
quebrar;
printf ("%i \ n", contador);
A saída é:
7F j r s u v x z
Para uma lista de entrada de,
F j r s u v x zO 7 é do loop interno. No entanto, para a complexidade do tempo, um máximo de 8 é considerado. A complexidade do tempo para o desempenho perfeita é expressa como:
Sobre)
Conclusão
Neste artigo, discutimos a complexidade do tempo de classificação da bolha e enfatizamos o seguinte:
A pior complexidade do tempo para o tipo de bolha é:
Sobre2)
Com a melhoria do código, a complexidade do tempo se torna:
O (n log n)
Quando a lista fornecida já está completamente classificada, a complexidade do tempo é:
Sobre)