Ordenao (Parte 1)

Prof. Tlio Toffolo http://www.toffolo.com.br

BCC202 Aula 14 Algoritmos e Estruturas de Dados I

Critrio de Ordenao
Ordena-se de acordo com uma chave:
typedef int TChave; typedef struct { TChave Chave; /* outros componentes */ } TItem;

Caractersticas
Estabilidade: relativo manuteno da ordem original de itens de chaves iguais Ordenao interna: dados a serem ordenados cabem todos na memria principal. Princpio: comparao x distribuio

Critrio de Avaliao
Sendo n o nmero de registros no arquivo, as medidas de complexidade relevantes so: Nmero de comparaes C(n) entre chaves. Nmero de movimentaes M(n) de itens

Outras Consideraes
O uso econmico da memria disponvel um requisito primordial na ordenao interna. Mtodos de ordenao in situ so os preferidos.
Mtodos in situ no utilizam memria adicional.

Mtodos que utilizam listas encadeadas no so muito utilizados. Mtodos que fazem cpias dos itens a serem ordenados possuem menor importncia.

Mtodos
Mtodos a que estudaremos hoje: Bolha (BubbleSort) Seleo (SelectSort) Insero (InsertSort)

BUBBLESORT

ORDENAO DA BOLHA

Mtodo Bolha
Os elementos vo borbulhando a cada iterao do mtodo at a posio correta para ordenao da lista O mtodo poderia parar quando nenhum elemento borbulhace/trocasse de posio Como os elementos so trocados (borbulhados) frequentemente, h um alto custo de troca de elementos

Mtodo Bolha
void Bolha (TItem* v, int n) { int i, j; TItem aux; for (i = 0; i < n-1; i++) { for (j = 1; j < n-i; j++) { if (v[j].Chave < v[j-1].Chave) { aux = v[j]; v[j] = v[j-1]; v[j-1] = aux; } } } }

Anlise de Complexidade
Comparaes C(n)

C ( n) =

(n i 1) = n i 1
i =0 i =0 i =0 i =0

n2

n2

n2

n2

(0 + n 2)(n 1) = n(n 1) (n 1) 2 2 n n = = O(n 2 ) 2

Movimentaes M(n)

M (n) = 3C(n) = O(n 2 )

10

Ordenao por Bolha

Vantagens:
Algoritmo simples Algoritmo estvel

Desvantagens:
O fato de o arquivo j estar ordenado no ajuda reduzir o nmero de comparaes (o custo continua quadrtico), porm o nmero de movimentao cai a zero.

Possvel modificao na atual implementao?

11

Mtodo Bolha
void Bolha (TItem* v, int n) { int i, j; TItem aux; for (i = 0; i < n-1; i++) { for (j = 1; j < n-i; j++) { if (v[j].Chave < v[j-1].Chave) { aux = v[j]; v[j] = v[j-1]; v[j-1] = aux; } } } }

12

Mtodo Bolha Melhoria!!!

void Bolha (TItem* v, int n) { int i, j, troca; TItem aux; for (i = 0; i < n-1; i++) { troca = 0; for (j = 1; j < n-i; j++) { if (v[j].Chave < v[j-1].Chave) { aux = v[j]; v[j] = v[j-1]; v[j-1] = aux; troca++; } } if (troca == 0) break; } }

13

ORDENAO POR SELEO

SELECTSORT

Mtodo Seleo
Seleo do n-simo menor (ou maior) elemento da lista Troca do n-simo menor (ou maior) elemento com a nsima posio da lista Uma nica troca por vez realizada

15

Mtodo Seleo
void Selecao (TItem* v, int n) { int i, j, Min; TItem aux; for (i = 0; i < n - 1; i++) { Min = i; for (j = i + 1 ; j < n; j++) if (v[j].Chave < v[Min].Chave) Min = j; aux = v[Min]; v[Min] = v[i]; v[i] = aux; } }
16

Anlise de Complexidade
Comparaes C(n)
C ( n) =

(n i 1) = n i 1
i =0 i =0 i =0 i =0

n2

n2

n2

n2

(0 + n 2)(n 1) = n(n 1) (n 1) 2 n2 n = = O(n 2 ) 2

Movimentaes M(n)

M (n) = 3(n 1) = O(n)

17

Ordenao por Seleo

Vantagens:
Custo linear no tamanho da entrada para o nmero de movimentos de registros. o algoritmo a ser utilizado para arquivos com registros muito grandes (alto custo de movimentao). muito interessante para arquivos pequenos.

Desvantagens:
O fato de o arquivo j estar ordenado no ajuda em nada, pois o custo continua quadrtico. O algoritmo no estvel.
18

Mtodo Seleo
void Selecao (TItem* v, int n) { int i, j, Min; TItem aux; for (i = 0; i < n - 1; i++) { Min = i; for (j = i + 1 ; j < n; j++) if (v[j].Chave < v[Min].Chave) Min = j; aux = v[Min]; v[Min] = v[i]; v[i] = aux; } }

19

Mtodo Seleo Melhoria!

void Selecao (TItem* v, int n) { int i, j, Min; TItem aux; for (i = 0; i < n - 1; i++) { Min = i; for (j = i + 1 ; j < n; j++) if (v[j].Chave < v[Min].Chave) Min = j; if (i != Min) { aux = v[Min]; v[Min] = v[i]; v[i] = aux; } } }
20

ORDENAO POR INSERO

INSERTSORT

Mtodo Insero
Algoritmo utilizado pelo jogador de cartas
As cartas so ordenadas da esquerda para direita uma por uma. O jogador escolhe a segunda carta e verifica se ela deve ficar antes ou na posio que est. Depois a terceira carta classificada, deslocando-a at sua correta posio O jogador realiza esse procedimento at ordenar todas as cartas

Alto custo em remover uma carta de uma posio e coloc-la em outra quando a representao por arranjos
22

Mtodo Insero
void Insercao (TItem* v, int n) { int i,j; TItem aux; for (i = 1; i < n; i++) { aux = v[i]; j = i - 1; while (j >= 0 && aux.Chave < v[j].Chave) { v[j + 1] = v[j]; j--; } v[j + 1] = aux; } }

23

Mtodo Insero (com sentinela)

void Insercao (TItem* v, int n) { int i,j; for (i = n-2; i >= 0; i--) { v[n] = v[i]; j = i + 1; while (v[n].Chave > v[j].Chave) { v[j - 1] = v[j]; j++; } v[j - 1] = v[n] } }

24

Anlise de Complexidade
Comparaes C(n)
No anel mais interno, na i-sima iterao, o valor de Ci :
melhor caso : Ci (n) = 1 pior caso caso medio : Ci (n) = i : Ci(n) = 1/i (1 + 2 + ... + i) = (i+1)/2

Assumindo que todas as permutaes de n so igualmente provveis no caso mdio, temos:

melhor caso : C(n) = (1 + 1 + ... + 1) = n - 1 pior caso caso medio : C(n) = (1 + 2 + ... + n-1) = n2/2 - n/2 : C(n) = (2 + ... + n ) = n2/4 + n/4 1/2
25

Anlise de Complexidade
Movimentaes M(n)
No anel mais interno, na i-sima iterao, o valor de Mi :
melhor caso : Mi (n) = 0 pior caso caso medio : Mi (n) = i : Mi(n) = 1/i (0 + 1 + 2 + ... + i-1) = (i-1)/2

Assumindo que todas as permutaes de n so igualmente provveis no caso mdio, temos:

melhor caso : M(n) = (2 + 2 + ... + 2) = 2n - 2 pior caso caso medio : M(n) = (2+1 + ... + 2+n-1) = (n2+3n-4)/2 : M(n) = (2 + 3 + ... + n ) = (n2 + n 2)/2
26

Ordenao por Insero

O nmero mnimo de comparaes e movimentos ocorre quando os itens esto originalmente em ordem. O nmero mximo ocorre quando os itens esto originalmente na ordem reversa. o mtodo a ser utilizado quando o arquivo est quase ordenado. um bom mtodo quando se deseja adicionar uns poucos itens a um arquivo ordenado, pois o custo linear. O algoritmo de ordenao por insero estvel.
27

Ordenao por Comparao

Mtodos simples:
Adequados para pequenas entradas. Requerem O(n2) comparaes. Produzem programas pequenos (pouco cdigo).

28

Ordenao por Comparao

Mtodos eficientes:
Adequados para entradas maiores. Requerem O(n log n) comparaes. Usam menos comparaes. As comparaes so mais complexas nos detalhes.

Uma observao importante:

Mtodos simples so mais eficientes para pequenos arquivos.

29

Perguntas?

BUBBLESORT, SELECTSORT E INSERTSORT

EXERCCIO

Exerccio
Dada a sequncia de nmeros:

3492518
Ordene em ordem crescente utilizando os trs algoritmos aprendidos em sala (BubbleSort, SelectSort e InsertSort), apresentado a sequncia dos nmeros a cada passo.

32