Estrutura de Dados
Ordenação
Ordenação
● Processo de organizar itens em ordem crescente ou
decrescente segundo algum critério.
● Geralmente o que se deseja ordenar é um registro.
● Esse registro apresenta um ou mais dados
● Geralmente o método de ordenação leva em conta apenas um dos
itens para efetuar a ordenação (chave)
● Duas alternativas
● Mantes os itens de uma estrutura de dados sempre organizados ● Aplicar algum método de ordenação a um conjunto de dados já
3
Classificação - Estabilidade
●
Métodos estáveis
●
A ordem relativa dos itens com chaves iguais é
preservada durante o processo de ordenação
●
Métodos instáveis
●
A ordem relativa dos itens com chaves iguais não
5
Classificação – Conjunto de
Registros
●
Ordenação interna – o conjunto de registros a
ser ordenado cabe na memória principal
●
Ordenação externa – o conjunto de registros
não cabe na memória principal e é necessário
armazenar parte dos mesmos em memória
Métodos de Ordenação
●
O que é necessário saber?
●
Quais são os principais algoritmos de ordenação
interna
●
Quais são as suas características
– Como o método efetua a ordenação – Complexidade temporal do algoritmo – Classificação quanto a estabilidade
7
Ordenação por Bolha (Bublesort)
● Faz uma série de comparações entre elementos do vetor;
● Quando dois elementos estão fora de ordem, esses dois elementos
são trocados de posição;
● Assim, o primeiro elemento é comparado com o segundo e se uma
inversão é encontrada, a troca é feita;
● Independente se houve troca ou não após a primeira comparação, o
segundo elemento é comparado com o terceiro, e, caso uma inversão seja encontrada, a troca é feita;
● O processo continua até que o penúltimo elemento seja comparado
com o último.
● Ou seja, os elementos são colocados em ordem a partir do último
9
11
Esforço computacional Bublesort
● Na primeira iteração são feitas n-1 comparações ● Na segunda iteração n-2
● Na terceira iteração n-3
● (n-1)+(n-2)+(n-3)+... + 2 + 1 = (n-1+1)*n/2
● Soma dos elementos de uma PA ● O (n2)
● Indicado quando o número de elementos é pequeno ● Algoritmo estável
● Melhor caso: vetor já ordenado
● Nenhuma troca é efetuada
● Pior caso: vetor em ordem reversa
13
Bublesort Otimizado
●
O Bubblesort otimizado é uma variação do
algoritmo Bubblesort em que é verificado se, em
uma passada completa pelo vetor, houve troca
de elementos.
●
Se houve troca, continua → o vetor ainda não está
ordenado
●
Se não houve troca, pare → o vetor já está ordenado.
●O melhor caso para esse algoritmo acontece quando
Ordenação por Seleção
●
Pegue o menor item do conjunto e coloque-o
na posição 1
●
Faça isso para os demais elementos do
15
17
Ordenação por Seleção
● O método não é estável
● O fato do vetor já estar ordenado em nada ajuda o método. ● Quanto ao número de comparações: O(n2)
● Quanto ao número de trocas O(n)
● Como o número de trocas é linear, é indicado para vetores
que apresentam registros muitos grandes.
● Mas como é um algoritmo com comparações quadráticas, é
Ordenação por Inserção
● Este método consiste em realizar a ordenação pela inserção de
cada um dos elementos em sua posição correta, levando em consideração os elementos já ordenados.
● O método segmenta o vetor em duas porções:
● Primeira porção: os elementos já ordenados
● Segunda porção: os elementos a serem ordenados
● Inicialmente a primeira porção contém apenas um elemento e
na segunda porção, os demais
● A primeira porção vai crescendo a medida em que os
elementos vão sendo retirados da porção 2 e colocados na porção 1 em sua posição correta.
19
21
23
25
Ordenação por Inserção
●
Algoritmo estável
●Comparações
●
Melhor caso: O(n) → vetor ordenado
●
Pior caso: O(n
2) → vetor em ordem inversa
●
Trocas
●
Melhor caso: O(n) → vetor ordenado
27
Ordenação por Inserção
●
Algoritmo a ser utilizado quando o vetor
encontra-se quase ordenado.
●
Bom algoritmo também para se adicionar
Shellsort
● O método de inserção troca itens adjacentes quando está procurando o
ponto de inserção na sequencia destino.
● Se o menor item estiver na posição mais à direita no vetor, então o número
de comparações e movimentações é igual a n-1 para encontrar o seu ponto de inserção.
● O método shellsort tenta contornar esse problema inicialmente fazendo
troca entre itens distantes em h posições.
● Isso “joga” itens de menor chave para as posições iniciais do vetor
● “adiantando” a inserção de itens de menor chave na posição correta ● diminuindo o número de trocas e movimentações.
● O algoritmo escolhe uma sequencia para h.
● Quando essa sequencia chega em h=1, o algoritmo shellsort torna-se o algoritmo de
29
Shellsort
● void shellsort (int a[]) {
int h = 1;
do h = h * 3 + 1; while (h < n); do {
h = h / 3;
for (int i = h + 1; i <= a.length; i++) { int value = a[i];
j = i – h;
while (j > 0 && value < a[j]) { a[j + h] = a[j]; j = j – h; } a[j + h] = value; } } while (h > 1) }
Shellsort
h = 4 i = 5
value = 'P' (valor a ser ordenado) j = i – h / j = 5 – 4 = 1
Compara a[5] = 'P' com a[1] = 'E'.
Como a[5] não é menor que a[1], não haverá troca.
Value 1 2 3 4 5 6 7 8 9 10 11 12
E X E M P L O F A C I L
31
Shellsort
h = 4 i = 6
value = 'L' (valor a ser ordenado) j = i – h / j = 6 – 4 = 2
Como value é menor que a[2], a[2] ocupará o espaço de a[j+h], a[2+4], a[6]. Ou seja, a[6] = 'X'
j = j – h, j = 2 – 4, j = -2, O loop termina
value ocupará a posição a[j+ h], a[-2+4], a[2] i que era 6 passa a ser igual a 7
Value 1 2 3 4 5 6 7 8 9 10 11 12
E X E M P L O F A C I L
L E X E M P L O F A C I L
L E E M P X O F A C I L
Shellsort
h = 4 i = 7
value = '0' (valor a ser ordenado) j = i – h / j = 7 – 4 = 3
Compara a[7] = 'O' com a[3] = 'E'.
Como a[7] não é menor que a[3], não haverá troca.
Value 1 2 3 4 5 6 7 8 9 10 11 12
33
Shellsort
h = 4 i = 8
value = 'F' (valor a ser ordenado) j = i – h / j = 8 – 4 = 4
Como value é menor que a[4], a[4] ocupará o espaço de a[j+h], a[4+4], a[8]. Ou seja, a[8] = 'M'
j = j – h, j = 4 – 4, j = 0, O loop termina
value ocupará a posição a[j+ h], a[0+4], a[4] i que era 8 passa a ser igual a 9
Value 1 2 3 4 5 6 7 8 9 10 11 12
F E L E M P X O F A C I L
F E L E P X O M A C I L
Shellsort
h = 4 i = 9
value = a[9] = 'A' (valor a ser ordenado) j = i – h / j = 9 – 4 = 5
Compara value = 'A' com a[5] = 'P'.
Como value é menor que a[5], a[5] ocupará o espaço de a[j+h], a[5+4], a[9]. Ou seja, a[9] = 'P'
j = j – h, j = 5 – 4, j = 1
Compara value = 'A' com a[1] = 'E'.
Como value é menor que a[1], a[1] ocupará o espaço de a[j+h], a[1+4], a[5]. Ou seja, a[5] = 'E'
Value 1 2 3 4 5 6 7 8 9 10 11 12
A E L E F P X O M A C I L
A E L E F X O M P C I L
A L E F E X O M P C I L
35
Shellsort
h = 4 i = 10
value = a[10] = 'C' (valor a ser ordenado) j = i – h / j = 10 – 4 = 6
Compara value = 'C' com a[6] = 'X'.
Como value é menor que a[6], a[6] ocupará o espaço de a[j+h], a[6+4], a[10]. Ou seja, a[10] = 'X'
j = j – h, j = 6 – 4, j = 2
Compara value = 'A' com a[2] = 'L'.
Como value é menor que a[2], a[2] ocupará o espaço de a[j+h], a[2+4], a[6]. Ou seja, a[6] = 'L'
j = j – h, j = 2 – 4, j = -2. O loop termina value ocupará a posição a[j+ h], a[-2+4], a[2] i que era 10 passa a ser igual a 11
Value 1 2 3 4 5 6 7 8 9 10 11 12 C A L E F E X O M P C I L C A L E F E O M P X I L C A L E F E O M P X I L C A E F E L O M P X I L C A C E F E L O M P X I L
Shellsort
h = 4 i = 11
value = a[11] = 'I' (valor a ser ordenado) j = i – h / j = 11 – 4 = 7
Compara value = 'I' com a[7] = 'O'.
Como value é menor que a[7], a[7] ocupará o espaço de a[7+h], a[7+4], a[11]. Ou seja,
a[11] = 'O'
j = j – h, j = 7 – 4, j = 3
Compara value = 'I' com a[3] = 'L'.
Value 1 2 3 4 5 6 7 8 9 10 11 12
I A C E F E L O M P X I L
I A C E F E L M P X O L
I A C E F E L M P X O L
37
Shellsort
h = 4 i = 12
value = a[12] = 'L' (valor a ser ordenado) j = i – h / j = 12 – 4 = 8
Compara value = 'L' com a[8] = 'M'.
Como value é menor que a[8], a[8] ocupará o espaço de a[j+h], a[8+4], a[12]. Ou seja, a[12] =
'M'
j = j – h, j = 8 – 4, j = 4
Compara value = 'L' com a[4] = 'F'.
Como value não é menor que a[4], value ocupará a posição a[j+ h], a[4+4], a[8]
i que era 12 passa a ser igual a 13. O loop interno termina. h = h / 3 = 4/3 = 1 (Algoritmo de inserção) Value 1 2 3 4 5 6 7 8 9 10 11 12 L A C E F E L I M P X O L L A C E F E L I P X O M L A C E F E L I P X O M L A C E F E L I L P X O M
Shellsort
● A razão da eficiência do algoritmo ainda não é conhecida ● Ninguém foi capaz de analisar o algoritmo
● Existem algumas conjecturas a respeito da complexidade do
algoritmo
● Conjectura 1 – O (n1,25)
● Conjectura 2 – O (n (log n)2)
● Algumas questões de concurso consideram a ordem de
complexidade do Shellsort como O (n log n)
● Tempo de execução sensível à ordem inicial do arquivo. ● Algoritmo não estável
