Ordenacao e Pesquisa PDF

Algoritmos de
Ordenao e Pesquisa
Marco Antonio Moreira de Carvalho

Algoritmos e Estrutura de Dados
Bibliografia Bsica
l Cormen, Leiserson, Rivest. Introduction

to Algorithms. 2nd edition. MIT Press,
2001. Captulos 2, 6, 7, 8.
l Aho, Alfred V., Hopcroft, John F.,

Ullman, Jeffrey D., Data Structure and
Algorithms, Massachusetts: Addison-
Wesley, 1987. Captulo 8.
2
Ordenao e Pesquisa
l Considerando um conjunto de dados:

l Organiz-los de acordo com algum critrio (>, <, , ,
etc.); ou
l Encontrar algum que atenda um critrio especfico
(maior, menor, =, etc.).
l Estas tarefas devem ser realizadas eficientemente
l O tempo para execut-las depende da quantidade de
dados envolvidos.
l Aplicao direta: Organizao e manipulao de
dados.
3
Ordenao e Pesquisa
l Os elementos so chamados de chaves;

l Pode haver chaves de valores idnticos;
l Os valores no necessariamente so sequenciais.
l Chaves podem ser nmeros, strings, registros, etc.
4
Estrutura de Dados
l Vetores
l Mantm uma srie de elementos sequenciais
mantidos em uma ordem linear como um nico,
porm, com possibilidade de acesso individual;
l Cada elemento possui um ndice que indica sua
posio no vetor e permite acess-lo diretamente;
l Vetores tem tamanhos fixos.
ndice 0 1 2 3 4 5
Valor 4 8 15 16 23 42
5
Pesquisa
l Dado um conjunto de n chaves {k1, k2, , kn}:

l Determinar a existncia e/ou determinar a posio de
determinada chave ki;
l Determinar a maior, a menor, etc.
l Dada a sequncia de chaves abaixo, como
determinar a existncia da chave 8? No sabemos
se as chaves esto ordenadas
? ? ? ? ? ?
6
Mtodos de Pesquisa
l Pesquisa Sequencial
l Pesquisa Binria
7
Pesquisa Sequencial
l Mtodo intuitivo:
l Dada uma chave k, compar-la a cada chave no
vetor, caso haja uma igual, a chave est no vetor
l Caso todas as chaves tenham sido comparadas e no
houve nenhuma igual, a chave no existe no vetor.
k=8
42 16 4 15 8 23
Chave encontrada! 8
Pesquisa Sequencial
Cdigo
!
! n, int k, int *posicao)!
int Sequencial(int A[], int
{! !
int i;! !
int achou = 0;! //sinaliza se a chave foi encontrada!
! !
for(i=0; i<n; i++)! //para cada chave!
if(A[i] == k)! //compara com a chave de busca!
{! !
*posicao = i;! //se encontrou!
achou = 1;! //armazena a posio!
}! !
! return achou;! //indica se encontrou ou no!
}!
9
Pesquisa Sequencial
Complexidade
int Sequencial(int A[], int n, int k, int *posicao)!
{!
int i;! Custo Repeties
int achou = 0;! !
! !
for(i=0; i<n; i++)! c1 ! !n!
if(A[i] == k)! c2 !n-1!
{!
*posicao = i;!
achou = 1;!
}!
return achou;!
}!
Tempo = (n) 10
Pesquisa Sequencial
l Exerccio
l Como torn-la mais rpida?
l 2 verses.
l Qual a complexidade desta pesquisa sequencial
aprimorada?
l Se o elemento procurado for o primeiro?
l Se o elemento procurado for o ltimo?
l E na mdia?
11
Pesquisa Binria
l Assume que as chaves esto ordenadas

l A partir disto, possvel diminuir o espao de busca,
restringindo-o por faixas de valores.
l Divide-se o problema ao meio seguidas vezes, at
que a chave desejada seja encontrada ou determine-
se sua inexistncia.
12
Pesquisa Binria
l Determina a chave central do vetor;

l Caso a chave pesquisada no seja a central, compare
seus valores
l Se a chave pesquisada for menor, volte ao primeiro passo,
porm, considere o vetor do incio at o ponto da chave central;
l Se a chave pesquisada for maior, volte ao primeiro passo,
porm, considere o vetor do ponto da chave central at o final.
k=8
4 8 15 16 23 42 49 51 62 70
13
Pesquisa Binria

seus valores
k=8
4 8 15 16 23 42 49 51 62 70
14
Pesquisa Binria

seus valores
k=8
4 8 15 16 23 42 49 51 62 70
15
Pesquisa Binria

seus valores
k=8
4 8 15 16 23 42 49 51 62 70
16
Chave encontrada!
Pesquisa Binria - Cdigo
!
! n)!
int PesquisaBinaria( int A[], int k, int
{! !
int esquerda = 0; ! //determina onde comea a busca!
int direita = n-1; ! //determina onde termina a busca!
int meio;! //determina a chave central!
! !
while (esquerda <= direita) ! //enquanto houver mais que !
{! //uma chave no intervalo!
meio = (esquerda+direita)/2;!//calcula a chave central!
! !
! ! if (k == A[meio])! //testa se a central a procurada!
return meio;! !
else if (k < A[meio])! //compara se menor!
direita = meio-1;! !
else! //caso contrrio maior!
esquerda = meio+1;! !
}! !
return -1; ! //retorna -1 se no encontrou!
}!
17
Pesquisa Binria -
Complexidade
l Melhor Caso (1) s
l A chave pesquisada a primeiraTchave
(n) = central: (1);
T (n / 2) + (1) nos ou
l Pior Caso
l A chave procurada no existe no vetor, todas as
divises tero de ser feitas.
18
Teorema Mestre Resumido
l Alguns algoritmos tm sua complexidades

determinadas atravs de recorrncias da forma
1. Se a > b k ento T (n) (n log a )

b
k k
l 2. Se a = b ento
O Teorema Mestre estabelece trs casos que T ( n ) ( n log
podem ser simplificados: 3. Se a < b k ento T (n) (n k )
19
Pesquisa Binria -
Complexidade
l Pelo segundo caso do Teorema Mestre, temos que

no pior caso a complexidade da Pesquisa Binria
20
Ordenao
l Dado um conjunto de n chaves {k1, k2, , kn},

organiz-las tal que k 1 k 2 k n.
l Por exemplo, dado (5, 3, 1, 2, 4), n = 5, temos 1 2
3 4 5.
l Como ordenar a sequncia de chaves abaixo?
15 23 4 42 8 16
4 8 15 16 23 42
21
Ordenao - Tipos
l Ordenao Interna
l Todas as chaves na memria principal facilidade de
acesso.
l Ordenao externa
l Chaves na memria principal e em memria externa
movimentao de chaves entre as duas.
l Diferentes mtodos para cada tipo.
22
Ordenao - Propriedades
l Estabilidade
l Manuteno da ordem relativa entre chaves de
mesmo valor;
l Especialmente importante para casos em que cada
elemento possui mais de uma chave.
l Adaptabilidade
l Mtodos adaptveis tm o tempo de execuo
reduzido caso a entrada j esteja ordenada.
23
O que importante saber
sobre cada mtodo
l Funcionamento;
l Tipo de ordenao efetuada;
l Complexidade
l Comportamento de acordo com o caso, em termos da
quantidade de chaves.
l Estabilidade;
l Adaptabilidade;
l Especificidades;
24
Mtodos de Ordenao
l Bubble Sort (Mtodo Bolha)

l Insertion Sort (Mtodo de Insero)
l Selection Sort (Mtodo de Seleo)
l Quicksort
l Heapsort
l Bucket Sort (Bin Sort)
l Radix Sort
l Merge Sort (Ordenao por Intercalao)
25
Bubble Sort
(Mtodo Bolha)
l O mtodo mais simples:
l Suponha chaves em um vetor vertical A. Valores
baixos so leves e valores altos so pesados .
Como bolhas, os valores leves sobem no vetor um
por vez, ao passo que os pesados descem.
l Operao Troca(A[i], A[j]): os elementos das
posies i e j trocam de posio.
26
Bubble Sort - Funcionamento
l O vetor analisado Posio Chave

comparando-se pares de
1 ?
chaves;
l A mais leve sobe, a 2 ?
mais pesada desce;
l Caso j estejam na 3 3
posio correta, o
prximo par analisado. 4 1
Comparao: 1 e 3
Troca(A[4], A[3])
27
Bubble Sort Procedimento
de Troca
Troca(int *i, int *j) Posio Chave
{ 1 ?
int temp;
temp = *i; 2 2
*i = *j;
3 1
*j = temp;
} 4 3
Comparao: 1 e 2
Troca(A[3], A[2])
28

1 4
chaves;
l A mais leve sobe, a 2 1
mais pesada desce;
posio correta, o
Comparao: 1 e 4
Troca(A[2], A[1])
29

1 1
chaves;
mais pesada desce;
posio correta, o
A chave mais leve chegou ao topo.

No ser utilizada em futuras comparaes.
30

1 1
chaves;
mais pesada desce;
posio correta, o
Comparao: 3 e 2
No h troca.
31

1 1
chaves;
mais pesada desce;
posio correta, o
Comparao: 2 e 4
Troca(A[3], A[2])
32

1 1
chaves;
mais pesada desce;
posio correta, o
A segunda mais leve chegou

sua posio.
33

1 1
chaves;
mais pesada desce;
posio correta, o
Comparao: 3 e 4
Troca(A[4], A[3])
34

1 1
chaves;
mais pesada desce;
posio correta, o
Chaves ordenadas.
35
Bubble Sort - Cdigo
// Para cada bolha , exceto a ltima!

for(i=0; i<n-1; i++)!
{!
// Percorre o vetor, exceto as chaves j !
for(j=n-1; j>i; j--)! // ordenadas!
if(A[j] < A[j-1])! // Compara os pares!
Troca(&A[j], &A[j-1]);!// Se for mais leve , troca as posies!
}!
36
Bubble Sort Complexidade
Custo Repeties
!
1 for(i=0; i<n-1; i++)! c1 ! !n!
{! !
2 for(j=n-1; j>i; j--)! c2 !n-i!
3 if(A[j] < A[j-1])! c3 !n-i!
4 Troca(&A[j], &A[j-1]);! !
}! c4 ! !n-i!
37
n n n n
= c1 n + c2 + c3 +
2 2
Bubble Sort Complexidade
c 2 + c3 + c4 2 c1
= n +
2
Tempo = O(n2) 38
Bubble Sort Resumo
l Tipo de Ordenao: Interna.

l Complexidade: O(n2).
l Quantidade de dados: Poucos.
l Especificidades: Complexidade fixa e cdigo
compacto.
l Estabilidade: Sim.
l Adaptabilidade: No. A implementao clssica
realiza a mesma quantidade de operaes mesmo
se as chaves j estiverem ordenadas.
39
Insertion Sort
(Mtodo de Insero)
l Analogia com a
organizao de cartas de
baralho na mo;
l Cartas so recebidas e
colocadas na mo
aleatoriamente;
l Durante a organizao,
cada carta colocada no
seu lugar certo, uma por Extrado de Cormen, Leiserson, Rivest, (2001).
vez, deslocando as
demais.
40
Insertion Sort - Funcionamento
l Compara-se os pares de chaves;
l Cada chave colocada na posio correta
l Para isso, outras so movidas.
l Caso j esteja na posio certa, passa-se ao
prximo par.
6 4 ? ? ? ?
Chave 4 na posio errada.
41
prximo par.
6 ? ? ? ?
Valor da chave armazenado. 4

Move-se as outras chaves para abrir o espao.
42
prximo par.
4 6 ? ? ? ?
Valor da chave armazenada inserido na

posio certa.
43
prximo par.
4 6 7 ? ? ?
Chaves nas posies corretas.
44
prximo par.
4 6 7 5 ? ?
Chaves 5 na posio errada
45
prximo par.
4 6 7 ? ?

46
prximo par.
4 5 6 7 ? ?

posio certa.
47
prximo par.
4 5 6 7 1 ?
Chave na posio errada.
48
prximo par.
4 5 6 7 ?

49
prximo par.
1 4 5 6 7 ?

posio certa.
50
prximo par.
1 4 5 6 7 2
Chave na posio errada.
51
prximo par.
1 4 5 6 7

52
prximo par.
1 2 4 5 6 7

posio certa.
Chaves ordenadas.
53
Insertion Sort - Cdigo
int ChaveAtual;! //Varivel auxiliar para as comparaes!
!
for(j=1; j<n; j++)! //Para cada uma das chaves, exceto a ltima!
{!
ChaveAtual = A[j];! //Chave comparada atualmente!
i = j-1;!
! !
while(i>=0 && A[i] > ChaveAtual)!
//Compara com as demais chaves!
{!
A[i+1] = A[i];!
//Abre o espao entre as chaves maiores !
i--;!
}!
!
A[i+1] = ChaveAtual;!
}! //Insere a chave na posio correta!
54
Insertion Sort - Complexidade
Custo Repeties
1 for(j=1; j<n; j++)! c1 ! !n!

{! !
2 ChaveAtual = A[j];! c2 !n-1!
3 i = j-1;! c3 !n-1!
! ! !
4 while(i>=0 && A[i] > ChaveAtual)! !
! {!
c4 ! !j!
5 A[i+1] = A[i];! !
6 i--;! c5 ! !j-1 !!
! }! c6 ! !j-1 !!
! !
7 A[i+1] = ChaveAtual;! !
}! c7 ! !n-1!
55
Insertion
c c cSort
- Complexidade
2 c c c
= + + n + c + c + c + + + + c n (c
4 5 6 4 5 6
+ c3 + c 4 +
1 2 3 7 2
2 2 2 2 2 2
Pior caso = O(n2)

56
Insertion Sort Resumo

l Especificidades: A complexidade, apesar de alta,
no fixa.
l Adaptabilidade: Sim.
57
Selection Sort
(Mtodo de Seleo)
l Princpio simples;
l A cada iterao procura a chave de menor valor ainda
no ordenada;
l Depois de encontrada, ela inserida na posio correta
do vetor.
58
Selection Sort - Funcionamento
l A cada iterao procura a chave de menor valor

ainda no ordenada;
l Depois de encontrada, ela inserida na posio
correta.
? ? ? ? ?
Menor chave ?
Posio ? 59

ainda no ordenada;
correta.
6 ? ? ? ?
Menor chave 6
Posio 1 60

ainda no ordenada;
correta.
6 4 ? ? ?
Menor chave 4
Posio 2 61

ainda no ordenada;
correta.
6 4 3 ? ?
Menor chave 3
Posio 3 62

ainda no ordenada;
correta.
6 4 3 5 ?
Menor chave 3
Posio 3 63

ainda no ordenada;
correta.
6 4 3 5 1
Menor chave 1
Posio 5 64

ainda no ordenada;
correta.
6 4 3 5
Menor chave 1
Posio 5 65

ainda no ordenada;
correta.
1 6 4 3 5
Menor chave 3
Posio 4
Acelerando 66

ainda no ordenada;
correta.
1 6 4 5
Menor chave 3
Posio 4 67

ainda no ordenada;
correta.
1 3 6 4 5
Menor chave ?
Posio ? 68

ainda no ordenada;
correta.
1 3 6 4 5
Menor chave 4
Posio 4
Acelerando 69

ainda no ordenada;
correta.
1 3 6 5
Menor chave 4
Posio 4 70

ainda no ordenada;
correta.
1 3 4 6 5
Menor chave ?
Posio ? 71

ainda no ordenada;
correta.
1 3 4 6 5
Menor chave 5
Posio 5
Acelerando 72

ainda no ordenada;
correta.
1 3 4 6
Menor chave 5
Posio 5 73

ainda no ordenada;
correta.
1 3 4 5 6
Chaves ordenadas.
74
Selection Sort - Cdigo
for(i=0; i<n-1; i++)! //para cada uma das chaves,!

{! //exceto a ltima!
MenorChave = A[i];! //inicializa o menor valor!
! indice = i;! //e menor ndice!
! !
! for(j=i+1; j<n; j++)! //Entre as chaves no ordenadas!
! {! !
! if(A[j] < MenorChave)! //Procura a menor!

! ! {! !
! ! MenorChave = A[j];! //atualiza as variveis!
! ! indice = j;! !
! ! }!
! }! !
! !
! Troca(&A[i], &A[indice]);! //Troca de lugar com a primeira!
}! //chave no ordenada!
75
Selection Sort - Complexidade
Custo Repeties
for(i=0; i<n-1; i++)! c1 ! ! !n!
{! !
MenorChave = A[i];! c2 ! ! !n-1!
! indice = i;! c3 ! ! !n-1!
! !
! for(j=i+1; j<n; j++)! c4 ! ! !n-i!
! {! !
! if(A[j] < MenorChave)! c5 ! ! !n-i !!
! ! {! !
! ! MenorChave = A[j];! c6 ! ! !n-i !!
! ! indice = j;! c7 ! ! !n-i!
! ! }! !
! }! !
! !
! Troca(&A[i], &A[indice]);! c8 ! ! !n-1!
}! !
76
c4 c5 c6 c7 2 c c c c
+ + + n + c1 + c2 + c3 + 4 + 5 + 6 + 7 + c8 n (c2 + c3 +
Selection Sort - Complexidade
2 2 2 2 2 2 2 2
Tempo = O(n2)
77
Selection Sort Resumo

l Especificidades: A complexidade fixa.
l Estabilidade: Depende da implementao. A
apresentada estvel.
l Adaptabilidade: No.
78
Quicksort
l Provavelmente o mais eficiente para ordenao

interna;
l Baseado no paradigma Dividir-e-Conquistar ;
l Divide o problema original em problemas menores,
semelhantes.
l Procedimento recursivo;
l Complexidade varia com o caso;
l Funcionamento no trivial como os anteriores.
79
Quicksort
l Trs passos bsicos:

l Dividir:Escolha uma chave piv e divida o vetor em
dois subvetores (possivelmente vazios) tal que as
chaves do subvetor esquerda sejam menores que a
chave piv, que por sua vez menor que as chaves
do subvetor direita;
l Conquistar: Ordene os subvetores recursivamente,
dividindo-os tambm;
l Combinar: Uma vez que todos os subvetores estejam
ordenados, o vetor original tambm estar.
80
Quicksort - Funcionamento
l Escolhe-se o piv: primeira chave do vetor (existem outras

estratgias);
l Percorre-se o vetor de esquerda a direita, comparando-se as
chaves;
l Menores para a esquerda, maiores para a direita.
3 1 ? ? ? ? ? ? ? ?
Piv
Chave 1 permanecer esquerda.
81

chaves;
3 1 4 ? ? ? ? ? ? ?
Piv Diviso
Chave 4 permanecer direita.
82

chaves;
3 1 4 1 ? ? ? ? ? ?
Piv Diviso
83

chaves;
3 1 1 4 5 ? ? ? ? ?
Piv Diviso
84

chaves;
3 1 1 4 5 9 ? ? ? ?
Piv Diviso
85

chaves;
3 1 1 4 5 9 2 ? ? ?
Piv Diviso
86

chaves;
3 1 1 2 5 9 4 6 ? ?
Piv Diviso
87

chaves;
3 1 1 2 5 9 4 6 5 ?
Piv Diviso
88

chaves;
3 1 1 2 5 9 4 6 5 3
Piv Diviso
89
l Inserir o piv na posio correta.
3 1 1 2 5 9 4 6 5 3
Piv Diviso
90
l Inserir o piv na posio correta;

l Agora o vetor deve ser dividido em duas partes:
l Do incio a antes do piv;
l De depois do piv ao final.
2 1 1 3 5 9 4 6 5 3
91
l Cada metade do vetor submetida ao mesmo processo

individualmente, podendo ser dividida novamente;
l No fim, junta-se as partes ordenadas.
2 1 1 1 1 2
Piv
92
3 1 4 1 5 9 2 6 5 3
2 1 1 3 5 9 4 6 5 3
2 1 1 5 9 4 6 5 3
1 1 2 3 4 5 6 5 9
1 1 3 4 6 5 9
93
1 1 3 4 5 6 9
Quicksort - Cdigo
int Particao(int A[], int esquerda, int direita) !
{! !
int i;! !
int j;! !
! !
i = esquerda;! //varivel de controle!
for(j=esquerda+1; j<=direita; j++) ! //percorre o subvetor!
{! !
if (A[j] < A[esquerda]) ! //se a chave analisada!
! {! //for menor que o piv!
i++;! !
Troca(&A[i], &A[j]);! //troca as chaves de !
}! //posio!
}! !
! !
Troca(&A[esquerda], &A[i]);! //insere o piv na !
! //posio correta!
return i;!
}!
!
94
Quicksort - Cdigo
Quicksort(int A[], int esquerda, int direita) !

{!
!
int p;!
! //piv!
if (direita > esquerda) ! !
{! //se o subvetor no !
p = Dividir(A, esquerda, direita);! //for vazio !
Quicksort(A, esquerda, p-1);!
//ele ordenado!
Quicksort(A, p+1, direita);!
}! //divide em parte esquerda!
}! //e parte direita!
95
Quicksort - Complexidade
int Particao(int A[], int esquerda, int direita) !
{!
int i;!
int j;! !
! !
i = esquerda;! Custo
!
Repeties
1 for(j=esquerda+1; j<=direita; j++) ! c1 ! ! !n!
{! !
2 if (A[j] < A[esquerda]) ! c2 ! ! !n-1!
! {! !
3 i++;! c3 ! ! !n-1!
4 Troca(&A[i], &A[j]);! c4 ! ! !n-1!
}!
}!
!
Troca(&A[esquerda], &A[i]);!
!
return i;!
}!
!
Tempo = (n)
96
l Suponha que para ordenar n chaves, a

complexidade dada pela recorrncia
T(n) = T(i)+T(n-i-1) + (n)
l Em que i representa o tamanho da partio obtida e
T(0) = (1).
l O pior caso do Quicksort ocorre quando as
parties nunca so eficientes: o vetor dividido em
um parte com n-1 chaves e outra com 0 chaves, ou
seja, no h partio efetiva em nenhuma das
chamadas recursivas;
l Isto ocorre quando o vetor j est ordenado;
97
l No pior caso, para i=0, temos ento:
l No melhor caso, para i= ou -1 (partio

perfeita), temos: n n
T (n) T + T n 1 + (n)
2 2
n
T (n) 2T + (n)
2
T (n) = O(n log n)
(Pelo Teorema Mestre, caso 2)
98
l Para o caso mdio, suponhamos que todas as

possveis parties (0 e n-1, 1 e n-2, , n-1 e 0)
possuem a mesma probabilidade de acontecer, ou
seja, 1/n para cada;
l Isto quer dizer que, na rvore de recurso, parties
boa e ruins se alternaro aleatoriamente em cada
nvel;
l razovel pensar que elas se alternam em cada
nvel deterministicamente no caso mdio.
99
l A pior partio l A melhor partio
100
0
Quicksort - Complexidade [(n-1)/2]-1
l Uma m partio seguida por uma boa partio
l Temos 3 subvetores, obtidos aos custos

(n)+(n-1) = (n)
l O custo das boas parties absorvem o das ms.
101
l Logo, se a complexidade para boas parties

(nlogn), para o caso mdio temos uma constante
maior, resultando ainda em O(nlogn).
l Esta no uma prova da complexidade, uma
intuio sobre a mesma, que pode ser confirmada
matematicamente.
102
Quicksort Resumo

l Complexidade: O(n2) no pior caso e O(nlogn) no melhor caso
e tambm no caso mdio.
l Quantidade de dados: Muitos.
l Especificidades: Estratgias de seleo de piv e partio
podem influenciar o tempo de execuo. Apesar de ser
quadrtico no pior caso, o caso mdio justifica sua utilizao.
l Estabilidade: Depende da partio. A verso apresentada
instvel. Uma verso in place estvel. Infelizmente,
mtodos eficientes so instveis.
103
Heapsort
l Utiliza uma estrutura de dados especfica: o Heap

l rvore binria completa em todos os nveis, exceto
o ltimo (possivelmente);
l Tambm pode ser visto como um vetor e possui as
seguintes propriedades:
l A raiz da rvore armazenada em A[1];
l Para um dado n i:
l O seu n pai ;
l Seu filho esquerda 2i;
l Seu filho direita 2i+1;
104
Heapsort - Heaps 1
16
2 3
14 10
4 5 6 7
8 7 9 3
8 9 10
2 4 1
1 2 3 4 5 6 7 8 9 10
16 14 10 8 7 9 3 2 4 1
105
Heaps
l Os heaps podem ser mximos ou mnimos;

l Raiz com o maior valor e pais com valor que os
filhos MaxHeap.
l Raiz com o menor valor e pais com valor que os
filhos MinHeap.
l No Heapsort, chaves so inseridas em um heap
mximo;
l Ao serem retiradas do heap, as chaves estaro
ordenadas;
l necessrio manter as propriedades do heap
durante as inseres e excluses.
106
Heapsort Funcionamento
l Utiliza 3 operaes sobre heaps:

l MAX-HEAPIFY: mantm a propriedade do heap
mximo;
l BUILD-MAX-HEAP: produz um heap a partir de um
vetor de entrada;
l HEAPSORT: ordena o vetor que representa o heap.
107
Heapsort MAX-HEAPIFY
l Cada subrvore deve ser um heap mximo,

portanto, um n pai no pode ser maior que os ns
filhos;
l Caso o n pai seja menor que um dos filhos, ele
trocar de posio com o maior deles;
l aplicado recursivamente para garantir que uma
mudana realizada no viola a propriedade em
outras subrvores.
108
2
4 1
4 5 6
14 7 9
8 9 10
2 8 1
109
2 3
10
14
4 5 6
4 7 9
8 9 10
2 8 1
110
2 3
10
14
4 5 6
8 7 9
8 9 10
2 4 1
111
MAX-HEAPIFY - Cdigo
void MAX_HEAPIFY(int A[], int i, int n){! !!
int esquerdo;! //determina o filho esquerdo!
int direito;! //determina o filho direito!
int maior;! !
!
!
esquerdo = 2*i;! !
direito = 2*i+1;! !
!
if(esquerdo <= n && A[esquerdo] > A[i])!//se o filho esquerdo for!

! maior = esquerdo;! //maior que o pai, registra!
!
else!
//seno!
! maior = i;! //o maior o pai mesmo!
!
if (direito <= n && A[direito] > A //se o direito maior que o maior!
[maior])! !
! maior = direito;! //registra!
!
!
if(maior != i) {! //se o maior no o pai!
Troca(&A[i], &A[maior]);! !
! MAX_HEAPIFY(A, maior, n);! //troca as posies!
}! //verifica se a subrvore viola a !
//propriedade!
}! !
!
! 112
MAX-HEAPIFY - Complexidade
l (1) para fazer as trocas em um mesmo nvel; T(

l Uma subrvore pode ter no mximo tamanho 2n/3;
l No pior caso ento, a complexidade dada pela =T
recorrncia
(Pelo teorema mestre, caso 2)
113
Heapsort BUILD-MAX-HEAP
l Utiliza o procedimento anterior para transformar um

vetor em um heap mximo;
l aplicado de baixo para cima na rvore;
l Da metade do vetor em diante esto as folhas da
rvore, ento o procedimento aplicado deste
ponto para trs no vetor;
l A propriedade do heap mantida pelo
procedimento anterior.
114
1 3
4 5 6
2 16 9
8 9 10
14 8 7
4 1 3 2 16 9 10 14 8 7
115
1
4
2 3
1 3
4 5 6
2 16 9
8 9 10
14 8 7
116
1
4
2 3
1 3
4 5 6
14 16 9
8 9 10
2 8 7
117
1
4
2 3
1 10
4 5 6
14 16 9
8 9 10
2 8 7
118
1
4
2 3
16 10
4 5 6
14 7 9
8 9 10
2 8 1
119
1
16
2 3
14 10
4 5 6
8 7 9
8 9 10
2 4 1
120
BUILD-MAX-HEAP - Cdigo
void BUILD_MAX_HEAP(int A[],int n)!

{!
int i;!
!
!
//Para cada uma das subrvores,!
for(i=n/2; i>0; i--)!
//verifica corrige a propriedade !
MAX_HEAPIFY(A, i, n);!
//do heap!
}!
//folhas no so verificadas!
121
BUILD-MAX-HEAP
Complexidade
l Aparentemente, a complexidade O(nlogn);
l Porm, analisando-se a quantidade mxima de ns
por nvel do heap, e a quantidade de nveis,
possvel provar que a complexidade do
procedimento pode ser limitada por O(n);
l Em outras palavras, construir um heap a partir de
um vetor aleatrio possvel em tempo linear.
122
Heapsort - Funcionamento
l Inicialmente constri um heap (BUILD-MAX-HEAP);

l A maior chave estar na raiz do heap, ento ela
ser a ltima chave na ordenao ela removida
do heap;
l A nova raiz pode violar a propriedade do heap,
portanto, aplica-se o procedimento MAX-HEAPIFY;
l Agora, a segunda maior chave est na raiz, ela ser
a penltima na ordenao final;
l E assim por diante
l A rvore diminui a cada remoo.
123
16
14 10
8 7 9
2 4 1
124
14
8 10
4 7 9
i
2 1 16
Como esta chave veio 125

parar aqui?
10
8 9
4 7 1
i
2 14 16
126
9
8 3
4 7 1
i
10 14 16
127
8
7 3
4 2 1 9
10 14 16
128
7
4 3
1 2 8
10 14 16
129
4
2 3
1 7 8
10 14 16
130
3
2 1
i
4 7 8
10 14 16
131
2
Heapsort - Funcionamento i
1 3
4 7 8
10 14 16
132
Heapsort - Funcionamento 4 7 8
10 14 16
1 2 3 4 7 8 9 10 14 16
133
Heapsort - Cdigo
!
void HEAPSORT(int A[], int n)!
!
{!
int i;! !
! !
BUILD_MAX_HEAP(A, n-1);! //constri o heap inicial!
! !
for(i=n-1; i>0; i--)! //para cada chave!
{! //coloca a raiz do heap na !
Troca(&A[1], &A[i]);! //posio correta da ordenao!
! MAX_HEAPIFY(A, 1, i-1);! //verifica e corrige a!
}! //propriedade do heap!
}!
134
Heapsort - Complexidade
void HEAPSORT(int A[], int n)!

{!
int i;!
! Custo Repeties
BUILD_MAX_HEAP(A, n-1);!
O(n) ! !1!
! !
for(i=n-1; i>0; i--)! c1! ! !n!
{! !
!
Troca(&A[1], &A[i]);! c3! ! !n-1!

! MAX_HEAPIFY(A, 1, i-1);! O(logn) ! !n-1!
}! !
}! !
!
!
!
135
Heapsort - Complexidade
136
Tempo = O(nlogn)
Heapsort Resumo

l Complexidade: O(nlogn) no pior caso.
l Especificidades: Melhor complexidade, porm, uma
boa implementao do Quicksort melhor na
prtica, devido a questes de hardware (cache).
l Estabilidade: No.
137
Bucket Sort (Bin Sort)
l Pressupe que a entrada consiste em nmeros

inteiros distribudos uniformemente sobre um
intervalo
l Ou seja, que h um limite nos valores das chaves.
l O intervalo ento dividido em n subintervalos de
tamanhos iguais, os chamados buckets (baldes);
l Cada chave vai para o balde correspondente sua
faixa de valor
l Considerando a uniformidade da distribuio, no
esperamos muitas chaves em um mesmo balde.
138
n A[i]
Bucket Sort Funcionamento
l Cada balde posteriormente ordenado,

isoladamente dos demais;
l Considerando o limite [0,1), e chaves com dois
dgitos decimais, determinamos o nmero de baldes
como 10 (0, 9).
l A funo para determinao do ndice balde correto
;
139
B
0 /
1 /
2 /
3 /
4 /
5 /
6 /
7 /
8 /
9 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
140
B
0 /
1 /
2 /
3 /
4 /
5 /
6 /
7 0,78 /
8 /
9 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
141
B
0 /
1 0,17 /
2 /
3 /
4 /
5 /
6 /
7 0,78 /
8 /
9 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
142
B
0 /
1 0,17 /
2 /
3 0,39 /
4 /
5 /
6 /
7 0,78 /
8 /
9 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
143
B
0 /
1 0,17 /
2 0,26 /
3 0,39 /
4 /
5 /
6 /
7 0,78 /
8 /
9 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
144
B
0 /
1 0,17 /
2 0,26 /
3 0,39 /
4 /
5 /
6 /
7 0,72 0,78 /
8 /
9 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
145
B
0 /
1 0,17 /
2 0,26 /
3 0,39 /
4 /
5 /
6 /
7 0,72 0,78 /
8 /
9 0,94 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
146
B
0 /
1 0,17 /
2 0,21 0,26 /
3 0,39 /
4 /
5 /
6 /
7 0,72 0,78 /
8 /
9 0,94 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
147
B
0 /
1 0,12 0,17 /
2 0,21 0,26 /
3 0,39 /
4 /
5 /
6 /
7 0,72 0,78 /
8 /
9 0,94 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
148
B
0 /
1 0,12 0,17 /
2 0,23 0,21 0,26 /
3 0,39 /
4 /
5 /
6 /
7 0,72 0,78 /
8 /
9 0,94 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
149
B
0 /
1 0,12 0,17 /
2 0,23 0,21 0,26 /
3 0,39 /
4 /
5 /
6 0,68 /
7 0,72 0,78 /
8 /
9 0,94 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
150
B
0 /
1 0,12 0,17 /
2 0,23 0,21 0,26 / Balde desordenado.
3 0,39 /
4 /
5 /
6 0,68 /
7 0,72 0,78 /
8 /
9 0,94 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
151
B
0 /
1 0,12 0,17 /
2 0,21 0,23 0,26 /
3 0,39 /
4 /
5 /
6 0,68 /
7 0,72 0,78 /
8 /
9 0,94 /
A 0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
152
Bucket Sort Pseudo Cdigo
void BucketSort(int A[], int n)!

{!
int i;!
!
for(i=0; i<n; i++)!
InserirLista (B[int floor(n*A[i])], A[i]);!
!
for(i=0; i<n-1; i++)!
! InsertionSortLista(&B[i])!
!
ConcatenarListasEncadeadas(n-1);!
}!
153
Bucket Sort Complexidade
void BucketSort(int A[], int n)!

{!
int i;! !
! Custo
! Repeties
for(i=0; i<n; i++)! c1! ! !n!
InserirLista! O(1) ! !n-1!
! !
for(i=0; i<n-1; i++)! c3! ! !n-1!
! InsertionSortLista(&B[i]);! O(ni2) ! !n-1!
!
ConcatenarListasEncadeadas(n-1);!
}!
154
Bucket Sort - Complexidade
l O custo das sucessivas chamadas a ordenao por

insero pode ser calculado pela recorrncia
l Em que ni denota a quantidade de chaves no balde i;

l Tomando as expectativas de ambos os lados e usando a
linearidade de expectativa, temos:

E[T (n)] = E (

n 1
= (n) + E[O
0
n 1
= ( n ) + O ( E
1550
Bucket Sort - Complexidade
l O valor esperado para 2-1/n;

l Substituindo na ltima equao, temos
l Desta maneira, o Bucket Sort linear;

l Pode ser provado que, mesmo a entrada no sendo
uma distribuio uniforme o Bucket Sort ainda
executar em tempo linear.
156
Bucket Sort Resumo

l Complexidade: O(n).
l Quantidade de dados: Muitos, porm, com valores
limitados.
l Especificidades: Pressupe caractersticas da
entrada, e a implementao depende de tais
caractersticas. Um Bucket Sort com apenas dois
buckets na verdade o Quicksort (com pivoteamento
ruim).
l Estabilidade: Depende do algoritmo de ordenao
interna dos buckets.
l Adaptabilidade: Depende do algoritmo de ordenao
interna dos buckets.
157
Radix Sort
l Utiliza o conceito do Bucket Sort;

l Pressupe que as chaves de entrada possuem
limite no valor e no tamanho (quantidade de
dgitos);
l essencial utilizar um segundo algoritmo estvel
para realizar a ordenao;
l Ordena nmeros um digito de cada vez;
l A partir do menos significativo;
l Ou a partir do menos significativo.
158
Radix Sort
l Como os valores possuem limite, e a quantidade de

dgitos fixa, possvel aplicar o Bucket Sort para
cada nvel;
l Cria-se um balde para cada possvel valor dos dgitos
(0-9, ao invs de para cada faixa de valores), de
modo a no ser necessrio ordenar os baldes
internamente.
l O Bucket Sort linear neste caso, uma vez que no
necessrio ordenar os baldes isoladamente.
159
Radix Sort - Funcionamento
l A partir dos dgitos menos significativos, ordene as

chaves.
3 2 9
4 5 7
6 5 7
8 3 9
4 3 6
7 2 0
3 5 5
160

chaves.
3 2 9 7 2 0
4 5 7 3 5 5
6 5 7 4 3 6
8 3 9 4 5 7
4 3 6 6 5 7
7 2 0 3 2 9
3 5 5 8 3 9
161

chaves.
3 2 9 7 2 0
4 5 7 3 5 5
6 5 7 4 3 6
8 3 9 4 5 7
4 3 6 6 5 7
7 2 0 3 2 9
3 5 5 8 3 9
162

chaves.
3 2 9 7 2 0 7 2 0
4 5 7 3 5 5 3 2 9
6 5 7 4 3 6 4 3 6
8 3 9 4 5 7 8 3 9
4 3 6 6 5 7 3 5 5
7 2 0 3 2 9 4 5 7
3 5 5 8 3 9 6 5 7
163

chaves.
3 2 9 7 2 0 7 2 0
4 5 7 3 5 5 3 2 9
6 5 7 4 3 6 4 3 6
8 3 9 4 5 7 8 3 9
4 3 6 6 5 7 3 5 5
7 2 0 3 2 9 4 5 7
3 5 5 8 3 9 6 5 7
164

chaves.
3 2 9 7 2 0 7 2 0 3 2 9
4 5 7 3 5 5 3 2 9 3 5 5
6 5 7 4 3 6 4 3 6 4 3 6
8 3 9 4 5 7 8 3 9 4 5 7
4 3 6 6 5 7 3 5 5 6 5 7
7 2 0 3 2 9 4 5 7 7 2 0
3 5 5 8 3 9 6 5 7 8 3 9
165
Radix Sort Pseudo Cdigo
l Como dito anteriormente, o Radix Sort consiste em

usar um outro mtodo de ordenao (estvel) para
ordenar as chaves em relao a cada dgito;
l O cdigo, portanto, muito simples:
RadixSort(A[], d)!
{!
for(i=0; i<d; i++)!
BucketSort(A, d);!
}!
l Em que d o dgito em relao ao qual as chaves
sero ordenadas.
166
Radix Sort - Complexidade
l Considerando n chaves de d dgitos e valores at k,

temos:
l Quando d constante e k = O(n), que o caso

quando usamos o Bucket Sort, temos:
167
Radix Sort Resumo

l Complexidade: O(n).
l Quantidade de dados: Muitos, porm, com chaves de
tamanhos limitados.
l Especificidades: Pressupe caractersticas da entrada, e a
implementao depende de tais caractersticas.
l Estabilidade: Usando o dgito menos significativo sim, usando o
mais significativo, no.
l Especificidades: Apesar da complexidade melhor deste
mtodo, na prtica o Quicksort ainda melhor, por fazer
melhor uso de cache do computador, alm de melhores
constantes.
l Adaptabilidade: No. 168
Merge Sort
(Ordenao por Intercalao)
l Baseado no paradigma Dividir-e-Conquistar
l Divide o problema original em problemas menores
semelhantes;
l Resolve os problemas menores mais fceis ;
l Combina os problemas menores para formar a
soluo para o problema original
l mais fcil ordenar chaves parcialmente ordenadas.
l um algoritmo recursivo.
169
Merge Sort
l Baseado em dois procedimentos:

l MERGE: Cria dois subvetores, cada um
correspondente a uma metade do vetor original,
depois intercala os menores valores, copiando-os de
volta ao vetor original;
l MERGE_SORT: Divide o problema original em
subproblemas, e usa o procedimento anterior para
resolv-los.
170
Merge Sort - MERGE
l Cria dois subvetores, cada um correspondente a

uma metade do vetor original, depois intercala os
menores valores, copiando-os de volta ao vetor
original.
A 2 4 5 7 1 2 3 6
p q r
l p: Limite esquerdo do vetor; (

l r: Limite direito do vetor;
l q: Meio do vetor ; 171
Merge Sort - MERGE

original.
A 2 4 5 7 1 2 3 6
E 2 4 5 7 S D 1 2 3 6 S
p q Sentinela q+1 r Sentinela

172
Merge Sort - MERGE

original.
A ? ? ? ? ? ? ? ?
E 2 4 5 7 S D 1 2 3 6 S
173
Merge Sort - MERGE

original.
A 1 ? ? ? ? ? ? ?
E 2 4 5 7 S D 1 2 3 6 S
174
Merge Sort - MERGE

original.
A 1 2 ? ? ? ? ? ?
E 2 4 5 7 S D 1 2 3 6 S
175
Merge Sort - MERGE

original.
A 1 2 2 ? ? ? ? ?
E 2 4 5 7 S D 1 2 3 6 S
176
Merge Sort - MERGE

original.
A 1 2 2 3 ? ? ? ?
E 2 4 5 7 S D 1 2 3 6 S
177
Merge Sort - MERGE

original.
A 1 2 2 3 4 ? ? ?
E 2 4 5 7 S D 1 2 3 6 S
178
Merge Sort - MERGE

original.
A 1 2 2 3 4 5 ? ?
E 2 4 5 7 S D 1 2 3 6 S
179
Merge Sort - MERGE
l S um valor suficientemente grande, tal que,

sempre que comparado, ser maior que o elemento
original do vetor.
A 1 2 2 3 4 5 6 ?
E 2 4 5 7 S D 1 2 3 6 S
180
Merge Sort - MERGE
l Para que funcione, o vetor original deve ter
subvetores ordenados;
l Para isso, aplica-se recursivamente o algoritmo
l Quando chegar ao ponto deste exemplo, os subvetores estaro
ordenados.
A 1 2 2 3 4 5 6 7
E 2 4 5 7 S D 1 2 3 6 S
181
MERGE - Cdigo
MERGE(int A[], int p, int q, int r)!
{!
n1 = q-p+1;! //define o tamanho dos subvetores !
n2 = r-q;! //esquerdo e direito!
! !
for(i=0; i<n1; i++)! //preenche o subvetor esquerdo!
E[i] = A[p+i];! !
for(i=0; i<n2; i++)! //preenche o subvetor direito!
! D[i] = A[q+i+1];! !
! !
E[n1] = INT_MAX;! //sentinela esquerda!
D[n2] = INT_MAX;! //sentinela direita!
i = j = 0;! !
! !
for(k=p; k<=r; k++)! //Intercala as menores chaves!
if(E[i] <= D[j]) ! {! !
! ! A[k] = E[i]; i++;! !
! }! //e copia para o vetor original!
! else ! {!
! A[k] = D[j]; j++;!
! }!
}!
Exerccio: Alocao dos vetores E e D
dinamicamente, e posterior liberao da memria.
182
MERGE - Complexidade
MERGE(int A[], int p, int q, int r)!
{!
n1 = q-p+1;! !
n2 = r-q;! Custo
! Repeties
! !
for(i=0; i<n1; i++)! c1 ! ! !(n/2)+1!
E[i] = A[p+i];! !
for(i=0; i<n2; i++)! c2 ! ! !(n/2)+1!
! D[i] = A[q+i+1];! !
! !
E[n1] = INT_MAX;! !
D[n2] = INT_MAX;! !
i = j = 0;! !
! !
for(k=p; k<=r; k++)! c3 ! ! !n!
if(E[i] <= D[j]) ! {! !
! ! A[k] = E[i]; i++;! !
! }! !
! else ! {!
! A[k] = D[j]; j++;!
! }!
}!
Tempo = (n) 183

Merge Sort MERGE_SORT
l Divide o vetor ao meio recursivamente at que no

seja mais possvel
l Subvetor com apenas uma chave.
l Na volta das chamadas recursivas, combina e
ordena os ltimos 2 subvetores
l Na primeira vez, dois subvetores de apenas uma
chave.
l Os subvetores vo aumentando de tamanho, at
formar o vetor original.
184
MERGE_SORT
185
MERGE_SORT
186
MERGE_SORT
5 2 4 7
187
MERGE_SORT
5 2 4 7
5 2
Intercala
188
MERGE_SORT
52 25 4 7
5 2
189
MERGE_SORT
52 25 4 7
5 2 4 7
Intercala
190
MERGE_SORT
52 25 4 7
5 2 4 7
191
MERGE_SORT
52 25 4 7
5 2 4 7
Intercala
192
MERGE_SORT
52 25 4 7
5 2 4 7
193
MERGE_SORT
52 25 4 7
5 2 4 7
194
MERGE_SORT
52 25 4 7
5 2 4 7
Intercala
195
MERGE_SORT
52 25 4 7
5 2 4 7
Intercala
196
MERGE_SORT
52 25 4 7
Intercala
5 2 4 7
197
MERGE_SORT
Intercala 52 25 4 7
5 2 4 7
198
MERGE_SORT
52 25 4 7
5 2 4 7
199
MERGE_SORT - Cdigo
!
MERGE_SORT(int A[], int p, int r)!
{!
int q;!
!
if(p < r)!
{!
q = (p+r)/2;!
//dividir!
! MERGE_SORT(A, p, q);!
! MERGE_SORT(A, q+1, r);! //conquistar!
! MERGE(A, p, q, r);! !
}! //combinar!
}!
!
!
!
l Primeira chamada: MERGE_SORT(A, 0, n-1);!
200
Merge Sort - Complexidade
l A anlise da complexidade do Merge Sort

baseada nos trs passos do paradigma:
l Dividir D(n);
l Conquistar;
(1) se
l T (n) =
Combinar C(n).
l 2T (nrecursivo,
Em se tratando de um algoritmo
/ 2) + D(n) + C (n) nos out
a
complexidade definida por uma recorrncia:
201
l Claramente, dividir o problema leva tempo

constante, logo:
l Para resolver dois subproblemas, que consistem na

metade do problema original, temos:
l Para combinar os subproblemas, usamos o

procedimento MERGE, que conforme vimos, possui
complexidade:
202
T ( n) =
l Voltando recorrncia, temos ento: T ( n) =
l De acordo com o Teorema Mestre, caso 2 temos

que:
203
Merge Sort Resumo
l Tipo de Ordenao: Interna/Externa.

l Complexidade: (nlogn).
l Especificidades: Alto consumo de memria, devido s
vrias chamadas recursivas.
l Adaptabilidade:No.
204

Ordenacao e Pesquisa PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Ordenacao e Pesquisa PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Algoritmos de

Marco Antonio Moreira de Carvalho

l Cormen, Leiserson, Rivest. Introduction

l Aho, Alfred V., Hopcroft, John F.,

l Considerando um conjunto de dados:

l Os elementos so chamados de chaves;

l Dado um conjunto de n chaves {k1, k2, , kn}:

l Assume que as chaves esto ordenadas

l Determina a chave central do vetor;

l Determina a chave central do vetor;

l Determina a chave central do vetor;

l Determina a chave central do vetor;

l Alguns algoritmos tm sua complexidades

1. Se a > b k ento T (n) (n log a )

l Pelo segundo caso do Teorema Mestre, temos que

l Dado um conjunto de n chaves {k1, k2, , kn},

l Bubble Sort (Mtodo Bolha)

l O vetor analisado Posio Chave

l O vetor analisado Posio Chave

l O vetor analisado Posio Chave

A chave mais leve chegou ao topo.

l O vetor analisado Posio Chave

l O vetor analisado Posio Chave

l O vetor analisado Posio Chave

A segunda mais leve chegou

l O vetor analisado Posio Chave

l O vetor analisado Posio Chave

// Para cada bolha , exceto a ltima!

Troca(&A[j], &A[j-1]);!// Se for mais leve , troca as posies!

l Tipo de Ordenao: Interna.

Chave 4 na posio errada.

Valor da chave armazenado. 4

Valor da chave armazenada inserido na

Chaves nas posies corretas.

Chaves 5 na posio errada

Valor da chave armazenado. 5

Valor da chave armazenada inserido na

Chave na posio errada.

Valor da chave armazenado. 1

Valor da chave armazenada inserido na

Chave na posio errada.

Valor da chave armazenado. 2

Valor da chave armazenada inserido na

1 for(j=1; j<n; j++)! c1 ! !n!

Pior caso = O(n2)

l Tipo de Ordenao: Interna.

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

l A cada iterao procura a chave de menor valor

for(i=0; i<n-1; i++)! //para cada uma das chaves,!