Algoritmos de Ordenacao e Pesquisa

Algoritmos de
Ordenao e Pesquisa
Marco Antonio Moreira de Carvalho
Algoritmos e Estrutura de Dados
2
Bibliografia Bsica
! Cormen, Leiserson, Rivest. Introduction
to Algorithms. 2nd edition. MIT Press,
2001. Captulos 2, 6, 7, 8.
! Aho, Alfred V., Hopcroft, John F.,
Ullman, Jeffrey D., Data Structure and
Algorithms, Massachusetts: Addison-
Wesley, 1987. Captulo 8.
3
Ordenao e Pesquisa
! Considerando um conjunto de dados:
! Organiz-los de acordo com algum critrio (>, <, !, ",
etc.); ou
! Encontrar algum que atenda um critrio especfico
(maior, menor, =, etc.).
! Estas tarefas devem ser realizadas eficientemente
! O tempo para execut-las depende da quantidade de
dados envolvidos.
! Aplicao direta: Organizao e manipulao de
dados.
4
Ordenao e Pesquisa
! Os elementos so chamados de chaves;
! Pode haver chaves de valores idnticos;
! Os valores no necessariamente so sequenciais.
! Chaves podem ser nmeros, strings, registros, etc.
5
Estrutura de Dados
! Vetores
! Mantm uma srie de elementos sequenciais
mantidos em uma ordem linear como um nico,
porm, com possibilidade de acesso individual;
! Cada elemento possui um ndice que indica sua
posio no vetor e permite acess-lo diretamente;
! Vetores tem tamanhos fixos.
0 1 2 3 4 5
4 8 15 16 23 42
ndice
Valor
6
Pesquisa
! Dado um conjunto de n chaves {k
1
, k
2
, #, k
n
}:
! Determinar a existncia e/ou determinar a posio de
determinada chave k
i
;
! Determinar a maior, a menor, etc.
! Dada a sequncia de chaves abaixo, como
determinar a existncia da chave 8? No sabemos
se as chaves esto ordenadas#
? ? ? ? ? ?
7
Mtodos de Pesquisa
! Pesquisa Sequencial
! Pesquisa Binria
8
Pesquisa Sequencial
! Mtodo intuitivo:
! Dada uma chave k, compar-la a cada chave no
vetor, caso haja uma igual, a chave est no vetor
! Caso todas as chaves tenham sido comparadas e no
houve nenhuma igual, a chave no existe no vetor.
42 16 4 15 8 23
k = 8
Chave encontrada!
9
Pesquisa Sequencial
Cdigo
int Sequencial(int A[], int n, int k, int *posicao)
{
int i;
int achou = 0;

for(i=0; i<n; i++)
if(A[i] == k)
{
*posicao = i;
achou = 1;
}
return achou;
}

//sinaliza se a chave foi encontrada

//para cada chave
//compara com a chave de busca

//se encontrou
//armazena a posio

//indica se encontrou ou no
10
Pesquisa Sequencial
Complexidade
int Sequencial(int A[], int n, int k, int *posicao)
{
int i;
int achou = 0;

for(i=0; i<n; i++)
if(A[i] == k)
{
*posicao = i;
achou = 1;
}
return achou;
}
Custo Repeties

c
1
n
c
2
n-1
Tempo = !(n)

11
Pesquisa Sequencial
! Exerccio
! Como torn-la mais rpida?
! 2 verses.
! Qual a complexidade desta pesquisa sequencial
aprimorada?
! Se o elemento procurado for o primeiro?
! Se o elemento procurado for o ltimo?
! E na mdia?
12
Pesquisa Binria
! Assume que as chaves esto ordenadas
! A partir disto, possvel diminuir o espao de busca,
restringindo-o por faixas de valores.
! Divide-se o problema ao meio seguidas vezes, at
que a chave desejada seja encontrada ou determine-
se sua inexistncia.
13
Pesquisa Binria
! Determina a chave central do vetor;
! Caso a chave pesquisada no seja a central, compare
seus valores
! Se a chave pesquisada for menor, volte ao primeiro passo,
porm, considere o vetor do incio at o ponto da chave central;
! Se a chave pesquisada for maior, volte ao primeiro passo,
porm, considere o vetor do ponto da chave central at o final.
4 8 15 16 23 42 49 51 62 70
k = 8
14
Pesquisa Binria
seus valores
4 8 15 16 23 42 49 51 62 70
k = 8
15
Pesquisa Binria
seus valores
4 8 15 16 23 42 49 51 62 70
k = 8
16
Pesquisa Binria
seus valores
4 8 15 16 23 42 49 51 62 70
k = 8
Chave encontrada!
17
Pesquisa Binria - Cdigo
int PesquisaBinaria( int A[], int k, int n)
{
int esquerda = 0;
int direita = n-1;
int meio;

while (esquerda <= direita)
{
meio = (esquerda+direita)/2;

if (k == A[meio])
return meio;
else if (k < A[meio])
direita = meio-1;
else
esquerda = meio+1;
}
return -1;
}

//determina onde comea a busca
//determina onde termina a busca
//determina a chave central

//enquanto houver mais que
//uma chave no intervalo
//calcula a chave central

//testa se a central a procurada

//compara se menor

//caso contrrio maior

//retorna -1 se no encontrou
18
Pesquisa Binria -
Complexidade
! Melhor Caso
! A chave pesquisada a primeira chave central: !(1);
! Pior Caso
! A chave procurada no existe no vetor, todas as
divises tero de ser feitas.
!
"
#
$ +
= $
=
. ) 1 ( ) 2 / (
, 1 ) 1 (
) (
casos outros nos n T
n se
n T
19
Teorema Mestre Resumido
! Alguns algoritmos tm sua complexidades
determinadas atravs de recorrncias da forma
) ( ) ( . 3
) log ( ) ( . 2
1 ), ( ) ( . 1
log
k k
k k
a k
n n T ento b a Se
n n n T ento b a Se
b para n n T ento b a Se
b
! " <
! " =
> ! " >
k
n b n aT n T + = ) / ( ) (
! O Teorema Mestre estabelece trs casos que
podem ser simplificados:
20
Pesquisa Binria -
Complexidade
! Pelo segundo caso do Teorema Mestre, temos que
no pior caso a complexidade da Pesquisa Binria
) (log ) (
) 1 ( ) 2 / ( ) (
n O n T
n T n T
=
! + =
21
Ordenao
! Dado um conjunto de n chaves {k
1
, k
2
, #, k
n
},
organiz-las tal que k
1
" k
2
" ! " k
n.
! Por exemplo, dado (5, 3, 1, 2, 4), n = 5, temos 1 " 2
" 3 " 4 " 5.
! Como ordenar a sequncia de chaves abaixo?
15 23 4 42 8 16
4 8 15 16 23 42
22
Ordenao - Tipos
! Ordenao Interna
! Todas as chaves na memria principal facilidade de
acesso.
! Ordenao externa
! Chaves na memria principal e em memria externa
movimentao de chaves entre as duas.
! Diferentes mtodos para cada tipo.
23
Ordenao - Propriedades
! Estabilidade
! Manuteno da ordem relativa entre chaves de
mesmo valor;
! Especialmente importante para casos em que cada
elemento possui mais de uma chave.
! Adaptabilidade
! Mtodos adaptveis tm o tempo de execuo
reduzido caso a entrada j esteja ordenada.
24
O que importante saber
sobre cada mtodo
! Funcionamento;
! Tipo de ordenao efetuada;
! Complexidade
! Comportamento de acordo com o caso, em termos da
quantidade de chaves.
! Estabilidade;
! Adaptabilidade;
! Especificidades;
25
Mtodos de Ordenao
! Bubble Sort (Mtodo Bolha)
! Insertion Sort (Mtodo de Insero)
! Selection Sort (Mtodo de Seleo)
! Quicksort
! Heapsort
! Bucket Sort (Bin Sort)
! Radix Sort
! Merge Sort (Ordenao por Intercalao)
26
Bubble Sort
(Mtodo Bolha)
! O mtodo mais simples:
! 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.
! Operao Troca(A[i], A[j]): os elementos das
posies i e j trocam de posio.
27
Bubble Sort - Funcionamento
! O vetor analisado
comparando-se pares de
chaves;
! A mais leve sobe, a
mais pesada desce;
! Caso j estejam na
posio correta, o
prximo par analisado.
1 ?
2 ?
3 3
4 1
Comparao: 1 e 3
Posio Chave
Troca(A[4], A[3])
28
Bubble Sort Procedimento
de Troca
Troca(int *i, int *j)
{
int temp;
temp = *i;
*i = *j;
*j = temp;
}
1 ?
2 2
3 1
4 3
Comparao: 1 e 2
Posio Chave
Troca(A[3], A[2])
29
! O vetor analisado
chaves;
mais pesada desce;
! Caso j estejam na
posio correta, o
1 4
2 1
3 2
4 3
Comparao: 1 e 4
Posio Chave
Troca(A[2], A[1])
30
! O vetor analisado
chaves;
mais pesada desce;
! Caso j estejam na
posio correta, o
1 1
2 4
3 2
4 3
A chave mais leve chegou ao topo.
Posio Chave
No ser utilizada em futuras comparaes.
31
! O vetor analisado
chaves;
mais pesada desce;
! Caso j estejam na
posio correta, o
1 1
2 4
3 2
4 3
Comparao: 3 e 2
Posio Chave
No h troca.
32
! O vetor analisado
chaves;
mais pesada desce;
! Caso j estejam na
posio correta, o
1 1
2 4
3 2
4 3
Comparao: 2 e 4
Posio Chave
Troca(A[3], A[2])
33
! O vetor analisado
chaves;
mais pesada desce;
! Caso j estejam na
posio correta, o
1 1
2 2
3 4
4 3
A segunda mais leve chegou
sua posio.
Posio Chave
34
! O vetor analisado
chaves;
mais pesada desce;
! Caso j estejam na
posio correta, o
1 1
2 2
3 4
4 3
Comparao: 3 e 4
Posio Chave
Troca(A[4], A[3])
35
! O vetor analisado
chaves;
mais pesada desce;
! Caso j estejam na
posio correta, o
1 1
2 2
3 3
4 4
Posio Chave
Chaves ordenadas.
36
Bubble Sort - Cdigo
for(i=0; i<n-1; i++)
{
for(j=n-1; j>i; j--)
if(A[j] < A[j-1])
Troca(&A[j], &A[j-1]);
}
// Para cada bolha, exceto a ltima
// Percorre o vetor, exceto as chaves j
// ordenadas
// Compara os pares
// Se for mais leve, troca as posies
37
Bubble Sort Complexidade
1 for(i=0; i<n-1; i++)
{
2 for(j=n-1; j>i; j--)
3 if(A[j] < A[j-1])
4 Troca(&A[j], &A[j-1]);
}
Custo Repeties

c
1
n

c
2
n-i
c
3
n-i

c
4
n-i
38
Bubble Sort Complexidade
n
c c c c
n
c c c
!
"
#
$
%
&
+ + +
+
!
"
#
$
%
&
+ +
=
2 2
4 3 2 1 2 4 3 2
!
!
"
#
$
$
%
& '
+
!
!
"
#
$
$
%
& '
+
!
!
"
#
$
$
%
& '
+ =
2 2 2
2
4
2
3
2
2 1
n n
c
n n
c
n n
c n c
! ! !
"
=
"
=
"
=
" + " + " +
1
1
1
1
4 3
1
1
2 1
) ( ) ( ) (
n
i
n
i
n
i
i n c i n c i n c n c
Tempo = O(n
2
)
!
"
#
$
%
&
'
+
!
"
#
$
%
&
'
+
!
"
#
$
%
&
'
+ =
2
) 1 (
2
) 1 (
2
) 1 (
4 3 2 1
n n
c
n n
c
n n
c n c
39
Bubble Sort Resumo
! Tipo de Ordenao: Interna.
! Complexidade: O(n
2
).
! Quantidade de dados: Poucos.
! Especificidades: Complexidade fixa e cdigo
compacto.
! Estabilidade: Sim.
! Adaptabilidade: No. A implementao clssica
realiza a mesma quantidade de operaes mesmo
se as chaves j estiverem ordenadas.
40
Insertion Sort
(Mtodo de Insero)
! Analogia com a
organizao de cartas de
baralho na mo;
! Cartas so recebidas e
colocadas na mo
aleatoriamente;
! Durante a organizao,
cada carta colocada no
seu lugar certo, uma por
vez, deslocando as
demais.

Extrado de Cormen, Leiserson, Rivest, (2001).
41
Insertion Sort - Funcionamento
! Compara-se os pares de chaves;
! Cada chave colocada na posio correta
! Para isso, outras so movidas.
! Caso j esteja na posio certa, passa-se ao
prximo par.
6 4 ? ? ? ?
Chave 4 na posio errada.
42
6 ? ? ? ?
Move-se as outras chaves para abrir o espao.
Valor da chave armazenado.
4
prximo par.
43
prximo par.
4 6 ? ? ? ?
Valor da chave armazenada inserido na
posio certa.
44
prximo par.
4 6 7 ? ? ?
Chaves nas posies corretas.
45
prximo par.
4 6 7 5 ? ?
Chaves 5 na posio errada
46
prximo par.
4 6 7 ? ?
5
47
prximo par.
4 5 6 7 ? ?
posio certa.
48
prximo par.
4 5 6 7 1 ?
Chave na posio errada.
49
prximo par.
4 5 6 7 ?
1
50
prximo par.
1 4 5 6 7 ?
posio certa.
51
prximo par.
1 4 5 6 7 2
Chave na posio errada.
52
prximo par.
1 4 5 6 7
2
53
prximo par.
1 2 4 5 6 7
posio certa.
Chaves ordenadas.
54
Insertion Sort - Cdigo
int ChaveAtual;

for(j=1; j<n; j++)
{
ChaveAtual = A[j];
i = j-1;

while(i>=0 && A[i] > ChaveAtual)
{
A[i+1] = A[i];
i--;
}

A[i+1] = ChaveAtual;
}
//Varivel auxiliar para as comparaes
//Para cada uma das chaves, exceto a ltima
//Chave comparada atualmente
//Compara com as demais chaves
//Abre o espao entre as chaves maiores
//Insere a chave na posio correta
55
Insertion Sort - Complexidade
1 for(j=1; j<n; j++)
{
2 ChaveAtual = A[j];
3 i = j-1;

4 while(i>=0 && A[i] > ChaveAtual)
{
5 A[i+1] = A[i];
6 i--;
}

7 A[i+1] = ChaveAtual;
}
Custo Repeties

c
1
n

c
2
n-1
c
3
n-1

c
4
j

c
5
j-1
c
6
j-1

c
7
n-1
56
Insertion Sort - Complexidade
! ! !
"
=
"
=
"
=
" + " + " + + " + " +
1
1
7
1
1
6 5
1
1
4 3 2 1
) 1 ( ) 1 ( ) 1 ( ) ( ) 1 ( ) 1 (
n
j
n
j
n
j
n c j c j c j c n c n c n c
) (
2 2 2 2 2 2
7 4 3 2 7
6 5 4
3 2 1
2 6 5 4
c c c c n c
c c c
c c c n
c c c
+ + + !
"
#
$
%
&
'
+ + + + + + +
"
#
$
%
&
'
+ + =
Pior caso = O(n
2
)

7 7 6 5 4 3 3 2 2 1
2
) 1 (
2
) 1 (
1
2
) 1 (
c n c
n n
c
n n
c
n n
c c n c c n c n c ! +
"
#
$
%
&
'
!
+
"
#
$
%
&
'
!
+
"
#
$
%
&
'
!
+
+ ! + ! + =
57
Insertion Sort Resumo
! Complexidade: O(n
2
).
! Especificidades: A complexidade, apesar de alta,
no fixa.
! Adaptabilidade: Sim.
58
Selection Sort
(Mtodo de Seleo)
! Princpio simples;
! A cada iterao procura a chave de menor valor ainda
no ordenada;
! Depois de encontrada, ela inserida na posio correta
do vetor.

59
Selection Sort - Funcionamento
! A cada iterao procura a chave de menor valor
ainda no ordenada;
! Depois de encontrada, ela inserida na posio
correta.
? ? ? ? ?
?
Menor chave
?
Posio
60
ainda no ordenada;
correta.
6 ? ? ? ?
6
Menor chave
1
Posio
61
ainda no ordenada;
correta.
6 4 ? ? ?
4
Menor chave
2
Posio
62
ainda no ordenada;
correta.
6 4 3 ? ?
3
Menor chave
3
Posio
63
ainda no ordenada;
correta.
6 4 3 5 ?
3
Menor chave
3
Posio
64
ainda no ordenada;
correta.
6 4 3 5 1
1
Menor chave
5
Posio
65
ainda no ordenada;
correta.
6 4 3 5
1
Menor chave
5
Posio
66
ainda no ordenada;
correta.
1 6 4 3 5
3
Menor chave
4
Posio
Acelerando!
67
ainda no ordenada;
correta.
1 6 4 5
3
Menor chave
4
Posio
68
ainda no ordenada;
correta.
1 3 6 4 5
?
Menor chave
?
Posio
69
ainda no ordenada;
correta.
1 3 6 4 5
4
Menor chave
4
Posio
Acelerando!
70
ainda no ordenada;
correta.
1 3 6 5
4
Menor chave
4
Posio
71
ainda no ordenada;
correta.
1 3 4 6 5
?
Menor chave
?
Posio
72
ainda no ordenada;
correta.
1 3 4 6 5
5
Menor chave
5
Posio
Acelerando!
73
ainda no ordenada;
correta.
1 3 4 6
5
Menor chave
5
Posio
74
ainda no ordenada;
correta.
1 3 4 5 6
Chaves ordenadas.
75
Selection Sort - Cdigo
for(i=0; i<n-1; i++)
{
MenorChave = A[i];
indice = i;

for(j=i+1; j<n; j++)
{
if(A[j] < MenorChave)
{
MenorChave = A[j];
indice = j;
}
}

Troca(&A[i], &A[indice]);
}
//para cada uma das chaves,
//exceto a ltima
//inicializa o menor valor
//e menor ndice

//Entre as chaves no ordenadas

//Procura a menor

//atualiza as variveis

//Troca de lugar com a primeira
//chave no ordenada
76
Selection Sort - Complexidade
for(i=0; i<n-1; i++)
{
MenorChave = A[i];
indice = i;

for(j=i+1; j<n; j++)
{
if(A[j] < MenorChave)
{
MenorChave = A[j];
indice = j;
}
}

Troca(&A[i], &A[indice]);
}
c
1
n

c
2
n-1
c
3
n-1

c
4
n-i

c
5
n-i

c
6
n-i
c
7
n-i

c
8
n-1

Custo Repeties
77
Selection Sort - Complexidade
) 1 ( ) ( ) ( ) ( ) ( ) 1 ( ) 1 (
8
1
1
1
1
7
1
1
6 5
1
1
4 3 2 1
! + ! + ! + ! + ! + ! + ! +
" " " "
!
=
!
=
!
=
!
=
n c i n c i n c i n c i n c n c n c n c
n
i
n
i
n
i
n
i
8 8 7 6 5 4 3 3 2 2 1
2
) 1 (
2
) 1 (
2
) 1 (
2
) 1 (
c n c
n n
c
n n
c
n n
c
n n
c c n c c n c n c ! +
"
#
$
%
&
'
!
+
"
#
$
%
&
'
!
+
"
#
$
%
&
'
!
+
"
#
$
%
&
'
!
+ ! + ! +
) (
2 2 2 2 2 2 2 2
8 3 2 8
7 6 5 4
3 2 1
2 7 6 5 4
c c c n c
c c c c
c c c n
c c c c
+ + !
"
#
$
%
&
'
+ + + + + + + +
"
#
$
%
&
'
+ + +
Tempo = O(n
2
)
78
Selection Sort Resumo
! Complexidade: O(n
2
).
! Especificidades: A complexidade fixa.
! Estabilidade: Depende da implementao. A
apresentada estvel.
! Adaptabilidade: No.
79
Quicksort
! Provavelmente o mais eficiente para ordenao
interna;
! Baseado no paradigma Dividir-e-Conquistar;
! Divide o problema original em problemas menores,
semelhantes.
! Procedimento recursivo;
! Complexidade varia com o caso;
! Funcionamento no trivial como os anteriores.

80
Quicksort
! Trs passos bsicos:
! 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;
! Conquistar: Ordene os subvetores recursivamente,
dividindo-os tambm;
! Combinar: Uma vez que todos os subvetores estejam
ordenados, o vetor original tambm estar.
81
Quicksort - Funcionamento
! Escolhe-se o piv: primeira chave do vetor (existem outras
estratgias);
! Percorre-se o vetor de esquerda a direita, comparando-se as
chaves;
! Menores para a esquerda, maiores para a direita.
3 1 ? ? ? ? ? ? ? ?
Piv
Chave 1 permanecer esquerda.
82
chaves;
3 1 4 ? ? ? ? ? ? ?
Piv
Chave 4 permanecer direita.
Diviso
83
chaves;
3 1 4 1 ? ? ? ? ? ?
Piv
Diviso
84
chaves;
3 1 1 4 5 ? ? ? ? ?
Piv
Diviso
85
chaves;
3 1 1 4 5 9 ? ? ? ?
Piv
Diviso
86
chaves;
3 1 1 4 5 9 2 ? ? ?
Piv
Diviso
87
chaves;
3 1 1 2 5 9 4 6 ? ?
Piv
Diviso
88
chaves;
3 1 1 2 5 9 4 6 5 ?
Piv
Diviso
89
chaves;
3 1 1 2 5 9 4 6 5 3
Piv
Diviso
90
! Inserir o piv na posio correta.
3 1 1 2 5 9 4 6 5 3
Piv Diviso
91
! Inserir o piv na posio correta;
! Agora o vetor deve ser dividido em duas partes:
! Do incio a antes do piv;
! De depois do piv ao final.
2 1 1 3 5 9 4 6 5 3
92
! Cada metade do vetor submetida ao mesmo processo
individualmente, podendo ser dividida novamente;
! No fim, junta-se as partes ordenadas.
2 1 1
Piv
1 1 2
93
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
1 1 3 4 5 6 9
3 1 4 1 5 9 2 6 5 3
94
int Particao(int A[], int esquerda, int direita)
{
int i;
int j;

i = esquerda;
for(j=esquerda+1; j<=direita; j++)
{
if (A[j] < A[esquerda])
{
i++;
Troca(&A[i], &A[j]);
}
}

Troca(&A[esquerda], &A[i]);

return i;
}

Quicksort - Cdigo

//varivel de controle
//percorre o subvetor

//se a chave analisada
//for menor que o piv

//troca as chaves de
//posio

//insere o piv na
//posio correta
95
Quicksort - Cdigo
Quicksort(int A[], int esquerda, int direita)
{
int p;

if (direita > esquerda)
{
p = Dividir(A, esquerda, direita);
Quicksort(A, esquerda, p-1);
Quicksort(A, p+1, direita);
}
}

//piv

//se o subvetor no
//for vazio
//ele ordenado
//divide em parte esquerda
//e parte direita
96
int Particao(int A[], int esquerda, int direita)
{
int i;
int j;

i = esquerda;
1 for(j=esquerda+1; j<=direita; j++)
{
2 if (A[j] < A[esquerda])
{
3 i++;
4 Troca(&A[i], &A[j]);
}
}

Troca(&A[esquerda], &A[i]);

return i;
}

Quicksort - Complexidade

c
1
n

c
2
n-1

c
3
n-1
c
4
n-1
Custo Repeties
Tempo = !(n)
97
! Suponha que para ordenar n chaves, a
complexidade dada pela recorrncia
T(n) = T(i)+T(n-i-1) + !(n)
! Em que i representa o tamanho da partio obtida e
T(0) = !(1).
! 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;
! Isto ocorre quando o vetor j est ordenado;

98
! No pior caso, para i=0, temos ento:
! "
2 / n
) ( ) (
) ( ) 1 ( ) (
2
n O n T
n n T n T
=
! + " =
! No melhor caso, para i= ou -1 (partio
perfeita), temos:
) log ( ) (
) (
2
2 ) (
) ( 1
2 2
) (
n n O n T
n
n
T n T
n
n
n T
n
T n T
=
! +
"
#
$
%
&
'
(
! +
"
#
$
%
&
'
) ) +
"
#
$
%
&
'
(
(Pelo Teorema Mestre, caso 2)
! "
2 / n
99
! 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;
! Isto quer dizer que, na rvore de recurso, parties
boa e ruins se alternaro aleatoriamente em cada
nvel;
! razovel pensar que elas se alternam em cada
nvel deterministicamente no caso mdio.
100
n
0 n-1
!(n) n
(n-1)/2
!(n)
(n-1)/2
! A pior partio
! A melhor partio
101
! Uma m partio seguida por uma boa partio
n
n-1
!(n)
(n-1)/2 [(n-1)/2]-1
0
! Temos 3 subvetores, obtidos aos custos
!(n)+!(n-1) = !(n)
! O custo das boas parties absorvem o das ms.
102
! Logo, se a complexidade para boas parties !
(nlogn), para o caso mdio temos uma constante
maior, resultando ainda em O(nlogn).
! Esta no uma prova da complexidade, uma
intuio sobre a mesma, que pode ser confirmada
matematicamente.
103
Quicksort Resumo
! Complexidade: O(n
2
) no pior caso e O(nlogn) no melhor caso
e tambm no caso mdio.
! Quantidade de dados: Muitos.
! 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.
! Estabilidade: Depende da partio. A verso apresentada
instvel. Uma verso in place estvel. Infelizmente,
mtodos eficientes so instveis.
104
Heapsort
! Utiliza uma estrutura de dados especfica: o Heap
! rvore binria completa em todos os nveis, exceto
o ltimo (possivelmente);
! Tambm pode ser visto como um vetor e possui as
seguintes propriedades:
! A raiz da rvore armazenada em A[1];
! Para um dado n i:
! O seu n pai ;
! Seu filho esquerda 2i;
! Seu filho direita 2i+1;
! "
2 / i
105
Heapsort - Heaps
16
10
9 3
14
8 7
2 4 1
1
2
3
4 5
6 7
8 9 10
1 4 2 3 9 7 8 10 14 16 1 4 2 3 9 7 8 10 14 16
1 2 3 4 5 6 7 8 9 10
!(lgn)
106
Heaps
! Os heaps podem ser mximos ou mnimos;
! Raiz com o maior valor e pais com valor ! que os
filhos MaxHeap.
! Raiz com o menor valor e pais com valor " que os
filhos MinHeap.
! No Heapsort, chaves so inseridas em um heap
mximo;
! Ao serem retiradas do heap, as chaves estaro
ordenadas;
! necessrio manter as propriedades do heap
durante as inseres e excluses.
107
Heapsort Funcionamento
! Utiliza 3 operaes sobre heaps:
! MAX-HEAPIFY: mantm a propriedade do heap
mximo;
! BUILD-MAX-HEAP: produz um heap a partir de um
vetor de entrada;
! HEAPSORT: ordena o vetor que representa o heap.
108
Heapsort MAX-HEAPIFY
! Cada subrvore deve ser um heap mximo,
portanto, um n pai no pode ser maior que os ns
filhos;
! Caso o n pai seja menor que um dos filhos, ele
trocar de posio com o maior deles;
! aplicado recursivamente para garantir que uma
mudana realizada no viola a propriedade em
outras subrvores.
109
16
10
9
3
4
14 7
2 8 1
1
2
3
4 5
6
7
8 9 10
110
16
10
9
3
14
4 7
2 8 1
1
2
3
4 5
6
7
8 9 10
111
16
10
9
3
14
8 7
2 4 1
1
2
3
4 5
6
7
8 9 10
112
MAX-HEAPIFY - Cdigo
void MAX_HEAPIFY(int A[], int i, int n){
int esquerdo;
int direito;
int maior;

esquerdo = 2*i;
direito = 2*i+1;

if(esquerdo <= n && A[esquerdo] > A[i])
maior = esquerdo;
else
maior = i;

if (direito <= n && A[direito] > A
[maior])
maior = direito;

if(maior != i) {
Troca(&A[i], &A[maior]);
MAX_HEAPIFY(A, maior, n);
}
}

//determina o filho esquerdo
//determina o filho direito

//se o filho esquerdo for
//maior que o pai, registra

//seno
//o maior o pai mesmo
//se o direito maior que o maior

//registra

//se o maior no o pai

//troca as posies
//verifica se a subrvore viola a
//propriedade

113
MAX-HEAPIFY - Complexidade
! !(1) para fazer as trocas em um mesmo nvel;
! Uma subrvore pode ter no mximo tamanho 2n/3;
! No pior caso ento, a complexidade dada pela
recorrncia
) (log ) (
) 1 (
3
2
) (
n O n T
n
T n T
= =
! +
"
#
$
%
&
'
=
(Pelo teorema mestre, caso 2)
114
Heapsort BUILD-MAX-HEAP
! Utiliza o procedimento anterior para transformar um
vetor em um heap mximo;
! aplicado de baixo para cima na rvore;
! Da metade do vetor em diante esto as folhas da
rvore, ento o procedimento aplicado deste
ponto para trs no vetor;
! A propriedade do heap mantida pelo
procedimento anterior.
115
4
3
9
10
1
2 16
14 8 7
1
2
3
4
5
6
7
8 9 10
4 1 3 2 16 9 10 14 8 7
116
4
3
9
10
1
2 16
14 8 7
1
2
3
4
5
6
7
8 9 10
117
4
3
9
10
1
14 16
2 8 7
1
2
3
4
5
6
7
8 9 10
118
4
10
9
3
1
14 16
2 8 7
1
2
3
4
5
6
7
8 9 10
119
4
10
9
3
16
14 7
2 8 1
1
2
3
4
5
6
7
8 9 10
120
16
10
9
3
14
8 7
2 4
1
1
2
3
4
5
6
7
8 9 10
121
BUILD-MAX-HEAP - Cdigo
void BUILD_MAX_HEAP(int A[],int n)
{
int i;

for(i=n/2; i>0; i--)
MAX_HEAPIFY(A, i, n);
}

//Para cada uma das subrvores,
//verifica corrige a propriedade
//do heap
//folhas no so verificadas
122
BUILD-MAX-HEAP
Complexidade
! Aparentemente, a complexidade O(nlogn);
! 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);
! Em outras palavras, construir um heap a partir de
um vetor aleatrio possvel em tempo linear.
123
Heapsort - Funcionamento
! Inicialmente constri um heap (BUILD-MAX-HEAP);
! A maior chave estar na raiz do heap, ento ela
ser a ltima chave na ordenao ela removida
do heap;
! A nova raiz pode violar a propriedade do heap,
portanto, aplica-se o procedimento MAX-HEAPIFY;
! Agora, a segunda maior chave est na raiz, ela ser
a penltima na ordenao final;
! E assim por diante#
! A rvore diminui a cada remoo.
124
16
10
9
3
14
8 7
2 4 1
125
14
10
9
3
8
4 7
2 1 16
i
Como esta chave veio
parar aqui?
126
10
9
1
3
8
4 7
2 16
i
14
127
9
3
1
2
8
4 7
10 16
i
14
128
8
3
1
9
7
4 2
10 16
i
14
129
7
3
8
9
4
1 2
10 16
i
14
130
4
3
8
9
2
1 7
10 16
i
14
131
3
1
8
9
2
4 7
10 16
i
14
132
2
3
8
9
1
4 7
10 16
i
14
133
1
3
8
9
2
4 7
10 16
i
14
1 2 3 4 7 8 9 10 14 16
134
Heapsort - Cdigo
void HEAPSORT(int A[], int n)
{
int i;

BUILD_MAX_HEAP(A, n-1);

for(i=n-1; i>0; i--)
{
Troca(&A[1], &A[i]);
MAX_HEAPIFY(A, 1, i-1);
}
}

//constri o heap inicial

//para cada chave
//coloca a raiz do heap na
//posio correta da ordenao
//verifica e corrige a
//propriedade do heap
135
Heapsort - Complexidade
void HEAPSORT(int A[], int n)
{
int i;

BUILD_MAX_HEAP(A, n-1);

for(i=n-1; i>0; i--)
{
Troca(&A[1], &A[i]);
MAX_HEAPIFY(A, 1, i-1);
}
}
O(n) 1

c
1
n

c
3
n-1
O(logn) n-1

Custo Repeties

136
Heapsort - Complexidade
n n
n c c n n
n n n c n c n c n
n n n c n c n
log
) 1 ( log ) 1 (
log log
) 1 ( log ) 1 (
3 1
3 3 1
3 1
=
+ + + ! =
! + ! + + =
! + ! + +
Tempo = O(nlogn)
137
Heapsort Resumo
! Complexidade: O(nlogn) no pior caso.
! Especificidades: Melhor complexidade, porm, uma
boa implementao do Quicksort melhor na
prtica, devido a questes de hardware (cache).
! Estabilidade: No.
138
Bucket Sort (Bin Sort)
! Pressupe que a entrada consiste em nmeros
inteiros distribudos uniformemente sobre um
intervalo
! Ou seja, que h um limite nos valores das chaves.
! O intervalo ento dividido em n subintervalos de
tamanhos iguais, os chamados buckets (baldes);
! Cada chave vai para o balde correspondente sua
faixa de valor
! Considerando a uniformidade da distribuio, no
esperamos muitas chaves em um mesmo balde.
139
Bucket Sort Funcionamento
! Cada balde posteriormente ordenado,
isoladamente dos demais;
! Considerando o limite [0,1), e chaves com dois
dgitos decimais, determinamos o nmero de baldes
como 10 (0, #9).
! A funo para determinao do ndice balde correto
;
! "
] [i A n#
140
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1 /
2 /
3 /
4 /
5 /
6 /
7 /
8 /
9 /
A

B
141
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1 /
2 /
3 /
4 /
5 /
6 /
7
8 /
9 /
A

B
0,78 /
142
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2 /
3 /
4 /
5 /
6 /
7
8 /
9 /
A

B
0,78 /
0,17 /
143
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2 /
3
4 /
5 /
6 /
7
8 /
9 /
A

B
0,78 /
0,17 /
0,39 /
144
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6 /
7
8 /
9 /
A

B
0,78 /
0,17 /
0,39 /
0,26 /
145
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6 /
7
8 /
9 /
A

B
0,72
0,17 /
0,39 /
0,26 /
0,78 /
146
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6 /
7
8 /
9
A

B
0,72
0,17 /
0,39 /
0,26 /
0,78 /
0,94 /
147
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6 /
7
8 /
9
A

B
0,72
0,17 /
0,39 /
0,21
0,78 /
0,94 /
0,26 /
148
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6 /
7
8 /
9
A

B
0,72
0,12
0,39 /
0,21
0,78 /
0,94 /
0,26 /
0,17 /
149
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6 /
7
8 /
9
A

B
0,72
0,12
0,39 /
0,23
0,78 /
0,94 /
0,26 /
0,17 /
0,21
150
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6
7
8 /
9
A

B
0,72
0,12
0,39 /
0,23
0,78 /
0,94 /
0,26 /
0,17 /
0,21
0,68 /
151
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6
7
8 /
9
A

B
0,72
0,12
0,39 /
0,23
0,78 /
0,94 /
0,26 /
0,17 /
0,21
0,68 /
Balde desordenado.
152
0,78 0,17 0,39 0,26 0,72 0,94 0,21 0,12 0,23 0,68
0 /
1
2
3
4 /
5 /
6
7
8 /
9
A

B
0,72
0,12
0,39 /
0,21
0,78 /
0,94 /
0,26 /
0,17 /
0,23
0,68 /
153
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);
}
154
Bucket Sort Complexidade
void BucketSort(int A[], int n)
{
int i;

for(i=0; i<n; i++)
InserirLista

for(i=0; i<n-1; i++)
InsertionSortLista(&B[i]);

ConcatenarListasEncadeadas(n-1);
}

c
1
n
O(1) n-1

c
3
n-1
O(n
i
2
) n-1
Custo Repeties
155
Bucket Sort - Complexidade
! O custo das sucessivas chamadas a ordenao por
insero pode ser calculado pela recorrncia
!
"
=
+ # =
1
0
2
) ( ) ( ) (
n
i
i
n O n n T
! Em que n
i
denota a quantidade de chaves no balde i;
! Tomando as expectativas de ambos os lados e usando a
linearidade de expectativa, temos:
!
!
!
"
"
"
+ # =
+ # =
$
%
&
'
(
)
+ # =
1
0
2
1
0
2
1
0
2
]) [ ( ) (
)] ( [ ) (
) ( ) ( )] ( [
n
i
n
i
n
i
n E O n
n O E n
n O n E n T E
156
Bucket Sort - Complexidade
! O valor esperado para 2-1/n;
! Substituindo na ltima equao, temos
] [
2
i
n E
) ( ) / 1 2 ( ) ( n n O n n ! = " # + !
! Desta maneira, o Bucket Sort linear;
! Pode ser provado que, mesmo a entrada no sendo
uma distribuio uniforme o Bucket Sort ainda
executar em tempo linear.
157
Bucket Sort Resumo
! Complexidade: O(n).
! Quantidade de dados: Muitos, porm, com valores
limitados.
! 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).
! Estabilidade: Depende do algoritmo de ordenao
interna dos buckets.
! Adaptabilidade: Depende do algoritmo de ordenao
interna dos buckets.
158
Radix Sort
! Utiliza o conceito do Bucket Sort;
! Pressupe que as chaves de entrada possuem
limite no valor e no tamanho (quantidade de
dgitos);
! essencial utilizar um segundo algoritmo estvel
para realizar a ordenao;
! Ordena nmeros um digito de cada vez;
! A partir do menos significativo;
! Ou a partir do menos significativo.
159
Radix Sort
! Como os valores possuem limite, e a quantidade de
dgitos fixa, possvel aplicar o Bucket Sort para
cada nvel;
! 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.
! O Bucket Sort linear neste caso, uma vez que no
necessrio ordenar os baldes isoladamente.
160
Radix Sort - Funcionamento
! 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
161
chaves.
3 2 9
4 5 7
6 5 7
8 3 9
4 3 6
7 2 0
3 5 5
7 2 0
3 5 5
4 3 6
4 5 7
6 5 7
3 2 9
8 3 9
162
chaves.
3 2 9
4 5 7
6 5 7
8 3 9
4 3 6
7 2 0
3 5 5
7 2 0
3 5 5
4 3 6
4 5 7
6 5 7
3 2 9
8 3 9
163
chaves.
3 2 9
4 5 7
6 5 7
8 3 9
4 3 6
7 2 0
3 5 5
7 2 0
3 5 5
4 3 6
4 5 7
6 5 7
3 2 9
8 3 9
7 2 0
3 2 9
4 3 6
8 3 9
3 5 5
4 5 7
6 5 7
164
chaves.
3 2 9
4 5 7
6 5 7
8 3 9
4 3 6
7 2 0
3 5 5
7 2 0
3 5 5
4 3 6
4 5 7
6 5 7
3 2 9
8 3 9
7 2 0
3 2 9
4 3 6
8 3 9
3 5 5
4 5 7
6 5 7
165
chaves.
3 2 9
4 5 7
6 5 7
8 3 9
4 3 6
7 2 0
3 5 5
7 2 0
3 5 5
4 3 6
4 5 7
6 5 7
3 2 9
8 3 9
7 2 0
3 2 9
4 3 6
8 3 9
3 5 5
4 5 7
6 5 7
3 2 9
3 5 5
4 3 6
4 5 7
6 5 7
7 2 0
8 3 9
166
Radix Sort Pseudo Cdigo
! Como dito anteriormente, o Radix Sort consiste em
usar um outro mtodo de ordenao (estvel) para
ordenar as chaves em relao a cada dgito;
! O cdigo, portanto, muito simples:

RadixSort(A[], d)
{
for(i=0; i<d; i++)
BucketSort(A, d);
}
! Em que d o dgito em relao ao qual as chaves
sero ordenadas.
167
Radix Sort - Complexidade
! Considerando n chaves de d dgitos e valores at k,
temos:
)) ( ( k n d + !
! Quando d constante e k = O(n), que o caso
quando usamos o Bucket Sort, temos:
) (n !
168
Radix Sort Resumo
! Complexidade: O(n).
! Quantidade de dados: Muitos, porm, com chaves de
tamanhos limitados.
! Especificidades: Pressupe caractersticas da entrada, e a
implementao depende de tais caractersticas.
! Estabilidade: Usando o dgito menos significativo sim, usando o
mais significativo, no.
! 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.
169
Merge Sort
(Ordenao por Intercalao)
! Baseado no paradigma Dividir-e-Conquistar
! Divide o problema original em problemas menores
semelhantes;
! Resolve os problemas menores mais fceis;
! Combina os problemas menores para formar a
soluo para o problema original
! mais fcil ordenar chaves parcialmente ordenadas.
! um algoritmo recursivo.
170
Merge Sort
! Baseado em dois procedimentos:
! 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;
! MERGE_SORT: Divide o problema original em
subproblemas, e usa o procedimento anterior para
resolv-los.
171
Merge Sort - 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.
2 4 5 7 1 2 3 6
p
q r
! p: Limite esquerdo do vetor;
! r: Limite direito do vetor;
! q: Meio do vetor ;
A
! "
2 / ) ( r p +
172
Merge Sort - MERGE
original.
2 4 5 7 1 2 3 6
2 4 5 7 S 1 2 3 6 S
A
E D
p
q r q+1 Sentinela Sentinela
173
Merge Sort - MERGE
original.
? ? ? ? ? ? ? ?
2 4 5 7 S 1 2 3 6 S
A
E D
174
Merge Sort - MERGE
original.
1 ? ? ? ? ? ? ?
2 4 5 7 S 1 2 3 6 S
A
E D
175
Merge Sort - MERGE
original.
1 2 ? ? ? ? ? ?
2 4 5 7 S 1 2 3 6 S
A
E D
176
Merge Sort - MERGE
original.
1 2 2 ? ? ? ? ?
2 4 5 7 S 1 2 3 6 S
A
E D
177
Merge Sort - MERGE
original.
1 2 2 3 ? ? ? ?
2 4 5 7 S 1 2 3 6 S
A
E D
178
Merge Sort - MERGE
original.
1 2 2 3 4 ? ? ?
2 4 5 7 S 1 2 3 6 S
A
E D
179
Merge Sort - MERGE
original.
1 2 2 3 4 5 ? ?
2 4 5 7 S 1 2 3 6 S
A
E D
180
Merge Sort - MERGE
! S um valor suficientemente grande, tal que,
sempre que comparado, ser maior que o elemento
original do vetor.
1 2 2 3 4 5 6 ?
2 4 5 7 S 1 2 3 6 S
A
E D
181
Merge Sort - MERGE
! Para que funcione, o vetor original deve ter
subvetores ordenados;
! Para isso, aplica-se recursivamente o algoritmo
! Quando chegar ao ponto deste exemplo, os subvetores estaro
ordenados.
1 2 2 3 4 5 6 7
2 4 5 7 S 1 2 3 6 S
A
E D
182
MERGE - Cdigo
MERGE(int A[], int p, int q, int r)
{
n1 = q-p+1;
n2 = r-q;

for(i=0; i<n1; i++)
E[i] = A[p+i];
for(i=0; i<n2; i++)
D[i] = A[q+i+1];

E[n1] = INT_MAX;
D[n2] = INT_MAX;
i = j = 0;

for(k=p; k<=r; k++)
if(E[i] <= D[j]) {
A[k] = E[i]; i++;
}
else {
A[k] = D[j]; j++;
}
}
//define o tamanho dos subvetores
//esquerdo e direito

//preenche o subvetor esquerdo

//preenche o subvetor direito

//sentinela esquerda
//sentinela direita

//Intercala as menores chaves

//e copia para o vetor original
Exerccio: Alocao dos vetores E e D
dinamicamente, e posterior liberao da memria.
183
MERGE - Complexidade
MERGE(int A[], int p, int q, int r)
{
n1 = q-p+1;
n2 = r-q;

for(i=0; i<n1; i++)
E[i] = A[p+i];
for(i=0; i<n2; i++)
D[i] = A[q+i+1];

E[n1] = INT_MAX;
D[n2] = INT_MAX;
i = j = 0;

for(k=p; k<=r; k++)
if(E[i] <= D[j]) {
A[k] = E[i]; i++;
}
else {
A[k] = D[j]; j++;
}
}

c
1
(n/2)+1

c
2
(n/2)+1

c
3
n

Custo Repeties
Tempo = !(n)
184
Merge Sort MERGE_SORT
! Divide o vetor ao meio recursivamente at que no
seja mais possvel
! Subvetor com apenas uma chave.
! Na volta das chamadas recursivas, combina e
ordena os ltimos 2 subvetores
! Na primeira vez, dois subvetores de apenas uma
chave.
! Os subvetores vo aumentando de tamanho, at
formar o vetor original.
185
MERGE_SORT
5 2 4 7 1 3 2 6
186
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
187
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
188
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
Intercala
189
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
190
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
Intercala
191
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
192
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
Intercala
193
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
2 4 5 7
194
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
2 4 5 7
1 3 2 6
195
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
2 4 5 7
1 3 2 6
1 3
Intercala
196
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
2 4 5 7
1 3 2 6
1 3 2 6
Intercala
197
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
2 4 5 7
1 3 2 6
1 3 2 6
Intercala
198
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
2 4 5 7
1 3 2 6
1 3 2 6
1 2 3 6
Intercala
199
MERGE_SORT
5 2 4 7 1 3 2 6
1 3 2 6
5 2 4 7
5 2 4 7
5 2
2 5
7 4
2 4 5 7
1 3 2 6
1 3 2 6
1 2 3 6
1 2 2 3 4 5 6 7
200
MERGE_SORT - Cdigo

MERGE_SORT(int A[], int p, int r)
{
int q;

if(p < r)
{
q = (p+r)/2;
MERGE_SORT(A, p, q);
MERGE_SORT(A, q+1, r);
MERGE(A, p, q, r);
}
}

! Primeira chamada: MERGE_SORT(A, 0, n-1);
//dividir
//conquistar

//combinar
201
Merge Sort - Complexidade
! A anlise da complexidade do Merge Sort
baseada nos trs passos do paradigma:
! Dividir D(n);
! Conquistar;
! Combinar C(n).
! Em se tratando de um algoritmo recursivo, a
complexidade definida por uma recorrncia:
!
"
#
+ +
= $
=
. ) ( ) ( ) 2 / ( 2
, 1 ) 1 (
) (
casos outros nos n C n D n T
n se
n T
202
! Claramente, dividir o problema leva tempo
constante, logo:
) 2 / ( 2 n T
! Para resolver dois subproblemas, que consistem na
metade do problema original, temos:
! Para combinar os subproblemas, usamos o
procedimento MERGE, que conforme vimos, possui
complexidade:
) ( ) ( n O n C =
) 1 ( ) ( ! = n D
203
! Voltando recorrncia, temos ento:
!
"
#
$ +
= $
=
. ) ( ) 2 / ( 2
, 1 ) 1 (
) (
casos outros nos n n T
n se
n T
! De acordo com o Teorema Mestre, caso 2 temos
que:
) log ( ) (
) ( ) 2 / ( 2 ) (
n n n T
n n T n T
! =
! + =
204
Merge Sort Resumo
! Tipo de Ordenao: Interna/Externa.
! Complexidade: !(nlogn).
! Especificidades: Alto consumo de memria, devido s
vrias chamadas recursivas.
! Adaptabilidade:No.

Algoritmos de Ordenacao e Pesquisa

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Algoritmos de Ordenacao e Pesquisa

Enviado por

Direitos autorais:

Formatos disponíveis

Algoritmos de

Você também pode gostar