Ordenação - DCC | Departamento de Ci??ncia da Computa????o · Projeto de Algoritmos – Cap.4 Ordenação 2 Introdução - Conceitos Básicos • Ordenar: processo de rearranjar

Ordenao

ltima alterao: 31 de Agosto de 2010

Transparncias elaboradas por Charles Ornelas Almeida, Israel Guerra e Nivio Ziviani

Projeto de Algoritmos Cap.4 Ordenao 1

Contedo do Captulo

4.1 Ordenao Interna

4.1.1 Seleo

4.1.2 Insero

4.1.3 Shellsort

4.1.4 Quicksort

4.1.5 Heapsort Filas de Prioridades Heaps

4.1.6 Ordenao Parcial Seleo Parcial Insero Parcial Heapsort Parcial Quicksort Parcial

4.1.7 Ordenao em Tempo Linear Ordenao por Contagem Radixsort para Inteiros Radixsort para Cadeias de

Caracteres

4.2 Ordenao Externa

4.2.1 Intercalao Balanceada deVrios Caminhos

4.2.2 Implementao por meio deSeleo por Substituio

4.2.3 Consideraes Prticas

4.2.4 Intercalao Polifsica

4.2.5 Quicksort Externo


Introduo - Conceitos Bsicos

Ordenar: processo de rearranjar um conjunto de objetos em umaordem ascendente ou descendente.

A ordenao visa facilitar a recuperao posterior de itens do conjuntoordenado.

Dificuldade de se utilizar um catlogo telefnico se os nomes daspessoas no estivessem listados em ordem alfabtica.

Notao utilizada nos algoritmos:

Os algoritmos trabalham sobre os registros de um arquivo.

Cada registro possui uma chave utilizada para controlar aordenao.

Podem existir outros componentes em um registro.



Estrutura de um registro:

typedef long TipoChave;

typedef struct TipoItem {

TipoChave Chave;

/ outros componentes /

} TipoItem;

Qualquer tipo de chave sobre o qual exista uma regra de ordenaobem-definida pode ser utilizado.

Um mtodo de ordenao estvel se a ordem relativa dos itens comchaves iguais no se altera durante a ordenao.

Alguns dos mtodos de ordenao mais eficientes no so estveis.

A estabilidade pode ser forada quando o mtodo no-estvel.

Sedgewick (1988) sugere agregar um pequeno ndice a cada chaveantes de ordenar, ou ento aumentar a chave de alguma outra forma.



Classificao dos mtodos de ordenao:

Interna: arquivo a ser ordenado cabe todo na memria principal.

Externa: arquivo a ser ordenado no cabe na memria principal.

Diferenas entre os mtodos:

Em um mtodo de ordenao interna, qualquer registro pode serimediatamente acessado.

Em um mtodo de ordenao externa, os registros so acessadosseqencialmente ou em grandes blocos.

A maioria dos mtodos de ordenao baseada em comparaesdas chaves.

Existem mtodos de ordenao que utilizam o princpio dadistribuio .



Exemplo de ordenao por distribuio: considere o problema deordenar um baralho com 52 cartas na ordem:

A < 2 < 3 < < 10 < J < Q < K

e

< < < .

Algoritmo:

1. Distribuir as cartas em treze montes: ases, dois, trs, . . ., reis.

2. Colete os montes na ordem especificada.

3. Distribua novamente as cartas em quatro montes: paus, ouros,copas e espadas.

4. Colete os montes na ordem especificada.



Mtodos como o ilustrado so tambm conhecidos como ordenaodigital , radixsort ou bucketsort .

O mtodo no utiliza comparao entre chaves.

Uma das dificuldades de implementar este mtodo est relacionadacom o problema de lidar com cada monte.

Se para cada monte ns reservarmos uma rea, ento a demanda pormemria extra pode tornar-se proibitiva.

O custo para ordenar um arquivo com n elementos da ordem deO(n).

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1 7

Ordenao Interna

Na escolha de um algoritmo de ordenao interna deve serconsiderado o tempo gasto pela ordenao.

Sendo n o nmero registros no arquivo, as medidas de complexidaderelevantes so:

Nmero de comparaes C(n) entre chaves.

Nmero de movimentaes M(n) de itens do arquivo.

O uso econmico da memria disponvel um requisito primordial naordenao interna.

Mtodos de ordenao in situ so os preferidos.

Mtodos que utilizam listas encadeadas no so muito utilizados.

Mtodos que fazem cpias dos itens a serem ordenados possuemmenor importncia.


Ordenao Interna

Classificao dos mtodos de ordenao interna:

Mtodos simples:

Adequados para pequenos arquivos. Requerem O(n2) comparaes. Produzem programas pequenos.

Mtodos eficientes:

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


Ordenao Interna

Tipos de dados e variveis utilizados nos algoritmos de ordenaointerna:

typedef int TipoIndice ;

typedef TipoItem TipoVetor [MAXTAM + 1];

/ MAXTAM + 1 por causa da sentinela em Insercao /

TipoVetor A;

O ndice do vetor vai de 0 at MaxTam, devido s chaves sentinelas .

O vetor a ser ordenado contm chaves nas posies de 1 at n.

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.1 10

Ordenao por Seleo (1)

Um dos algoritmos mais simples de ordenao.

Algoritmo:

Selecione o menor item do vetor.

Troque-o com o item da primeira posio do vetor.

Repita essas duas operaes com os n 1 itens restantes, depoiscom os n 2 itens, at que reste apenas um elemento.


Ordenao por Seleo (2)

O mtodo ilustrado abaixo:

1 2 3 4 5 6

Chaves iniciais: O R D E N A

i = 1 A R D E N O

i = 2 A D R E N O

i = 3 A D E R N O

i = 4 A D E N R O

i = 5 A D E N O R

As chaves em negrito sofreram uma troca entre si.


Ordenao por Seleo

void Selecao(TipoItem A, TipoIndice n)

{ TipoIndice i , j , Min;

TipoItem x;

for ( i = 1; i


Ordenao por Seleo

Vantagens:

Custo linar para o nmero de movimentos de registros.

o algoritmo a ser utilizado para arquivos com registros muitograndes.

muito interessante para arquivos pequenos.

Desvantagens:

O fato de o arquivo j estar ordenado no ajuda em nada, pois o custocontinua quadrtico.

O algoritmo no estvel .


Ordenao por Insero

Mtodo preferido dos jogadores de cartas .

Algoritmo:

Em cada passo a partir de i=2 faa:

Selecione o i-simo item da seqncia fonte. Coloque-o no lugar apropriado na seqncia destino de acordo

com o critrio de ordenao.


Ordenao por Insero

O mtodo ilustrado abaixo:

1 2 3 4 5 6


i = 2 O R D E N A

i = 3 D O R E N A

i = 4 D E O R N A

i = 5 D E N O R A

i = 6 A D E N O R

As chaves em negrito representam a seqncia destino.


Ordenao por Insero

void Insercao(TipoItem A, TipoIndice n)

{ TipoIndice i , j ;

TipoItem x;

for ( i = 2; i


Ordenao por Insero

Consideraes sobre o algoritmo:

O processo de ordenao pode ser terminado pelas condies:

Um item com chave menor que o item em considerao encontrado.

O final da seqncia destino atingido esquerda.

Soluo:

Utilizar um registro sentinela na posio zero do vetor.


Ordenao por Insero

Seja C(n) a funo que conta o nmero de comparaes.

No anel mais interno, na i-sima iterao, o valor de Ci :

Melhor caso : Ci(n) = 1

Pior caso : Ci(n) = i

Caso medio : Ci(n) =1i(1 + 2 + + i) = i+1

2

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

Melhor caso : C(n) = (1 + 1 + + 1) = n 1

Pior caso : C(n) = (2 + 3 + + n) = n2

2+ n

2 1

Caso medio : C(n) = 12(3 + 4 + + n+ 1) = n

2

4+ 3n

4 1


Ordenao por Insero

Seja M(n) a funo que conta o nmero de movimentaes deregistros.

O nmero de movimentaes na i-sima iterao :

Mi(n) = Ci(n) 1 + 3 = Ci(n) + 2

Logo, o nmero de movimentos :

Melhor caso : M(n) = (3 + 3 + + 3) = 3(n 1)

Pior caso : M(n) = (4 + 5 + + n+ 2) = n2

2+ 5n

2 3

Caso medio : M(n) = 12(5 + 6 + + n+ 3) = n

2

4+ 11n

4 3


Ordenao por Insero

O nmero mnimo de comparaes e movimentos ocorre quando ositens esto originalmente em ordem.

O nmero mximo ocorre quando os itens esto originalmente naordem reversa.

o mtodo a ser utilizado quando o arquivo est quase ordenado.

um bom mtodo quando se deseja adicionar uns poucos itens a umarquivo ordenado, pois o custo linear.

O algoritmo de ordenao por insero estvel .


Shellsort

Proposto por Shell em 1959.

uma extenso do algoritmo de ordenao por insero.

Problema com o algoritmo de ordenao por insero:

Troca itens adjacentes para determinar o ponto de insero.

So efetuadas n 1 comparaes e movimentaes quando omenor item est na posio mais direita no vetor.

O mtodo de Shell contorna este problema permitindo trocas deregistros distantes um do outro.


Shellsort

Os itens separados de h posies so rearranjados.

Todo h-simo item leva a uma seqncia ordenada.

Tal seqncia dita estar h-ordenada.

Exemplo de utilizao:

1 2 3 4 5 6


h = 4 N A D E O R

h = 2 D A N E O R

h = 1 A D E N O R

Quando h = 1 Shellsort corresponde ao algoritmo de insero.


Shellsort

Como escolher o valor de h:

Seqncia para h:

h(s) = 3h(s 1) + 1, para s > 1

h(s) = 1, para s = 1.

Knuth (1973, p. 95) mostrou experimentalmente que estaseqncia difcil de ser batida por mais de 20% em eficincia.

A seqncia para h corresponde a 1, 4, 13, 40, 121, 364, 1.093,3.280, . . .


Shellsort

void Shellsort (TipoItem A, TipoIndice n)

{ int i , j ; int h = 1;

TipoItem x;

do h = h 3 + 1; while (h < n) ;

do

{ h /= 3;

for ( i = h + 1; i x.Chave)

{ A[ j ] = A[ j h ] ; j = h;

i f ( j


Shellsort

A implementao do Shellsort no utiliza registros sentinelas .

Seriam necessrios h registros sentinelas, uma para cadah-ordenao.


Shellsort: Anlise

A razo da eficincia do algoritmo ainda no conhecida.

Ningum ainda foi capaz de analisar o algoritmo.

A sua anlise contm alguns problemas matemticos muito difceis.

A comear pela prpria seqncia de incrementos.

O que se sabe que cada incremento no deve ser mltiplo doanterior.

Conjecturas referente ao nmero de comparaes para a seqnciade Knuth:

Conjetura 1 : C(n) = O(n1,25)

Conjetura 2 : C(n) = O(n(lnn)2)


Shellsort

Vantagens:

Shellsort uma tima opo para arquivos de tamanho moderado.

Sua implementao simples e requer uma quantidade de cdigopequena.

Desvantagens:

O tempo de execuo do algoritmo sensvel ordem inicial doarquivo.

O mtodo no estvel ,


Quicksort

Proposto por Hoare em 1960 e publiccado em 1962.

o algoritmo de ordenao interna mais rpido que se conhece parauma ampla variedade de situaes.

Provavelmente o mais utilizado.

A idia bsica dividir o problema de ordenar um conjunto com n itensem dois problemas menores.

Os problemas menores so ordenados independentemente.

Os resultados so combinados para produzir a soluo final.


Quicksort

A parte mais delicada do mtodo o processo de partio.

O vetor A[Esq..Dir] rearranjado por meio da escolha arbitrria de umpiv x.

O vetor A particionado em duas partes:

A parte esquerda com chaves menores ou iguais a x.

A parte direita com chaves maiores ou iguais a x.


Quicksort

Algoritmo para o particionamento:

1. Escolha arbitrariamente um piv x.

2. Percorra o vetor a partir da esquerda at que A[i] x.

3. Percorra o vetor a partir da direita at que A[j] x.

4. Troque A[i] com A[j].

5. Continue este processo at os apontadores i e j se cruzarem.

Ao final, o vetor A[Esq..Dir] est particionado de tal forma que:

Os itens em A[Esq], A[Esq + 1], . . . , A[j] so menores ou iguais a x.

Os itens em A[i], A[i+ 1], . . . , A[Dir] so maiores ou iguais a x.


Quicksort

Ilustrao do processo de partio:

1 2 3 4 5 6

O R D E N A

A R D E N O

A D R E N O

O piv x escolhido como sendo A[(i+ j) div 2].

Como inicialmente i = 1 e j = 6, ento x = A[3] = D.

Ao final do processo de partio i e j se cruzam em i = 3 e j = 2.


QuicksortProcedimento Particao:

void Particao(TipoIndice Esq, TipoIndice Dir , TipoIndice i , TipoIndice j , TipoItem A)

{ TipoItem x , w;

i = Esq; j = Dir ;

x = A[( i + j ) / 2 ] ; / obtem o pivo x /

do

{ while (x.Chave > A[ i ] .Chave) ( i )++;

while (x.Chave < A[ j ] .Chave) ( j );

i f ( i


Quicksort

Procedimento Quicksort:

/Entra aqui o procedimento Particao da transparencia 32/

void Ordena(TipoIndice Esq, TipoIndice Dir , TipoItem A)


Particao(Esq, Dir , & i , & j , A) ;

i f (Esq < j ) Ordena(Esq, j , A) ;

i f ( i < Dir ) Ordena( i , Dir , A) ;

}

void QuickSort(TipoItem A, TipoIndice n)

{ Ordena(1 , n, A) ; }


Quicksort

Exemplo do estado do vetor em cada chamada recursiva doprocedimento Ordena:

1 2 3 4 5 6


1 A D R E N O

2 A D

3 E R N O

4 N R O

5 O R

A D E N O R


Quicksort: Anlise

Seja C(n) a funo que conta o nmero de comparaes.

Pior caso:C(n) = O(n2)

O pior caso ocorre quando, sistematicamente, o piv escolhido comosendo um dos extremos de um arquivo j ordenado.

Isto faz com que o procedimento Ordena seja chamadorecursivamente n vezes, eliminando apenas um item em cadachamada.

O pior caso pode ser evitado empregando pequenas modificaes noalgoritmo.

Para isso basta escolher trs itens quaisquer do vetor e usar amediana dos trs como piv.


Quicksort: Anlise

Melhor caso:

C(n) = 2C(n/2) + n = n log n n+ 1

Esta situao ocorre quando cada partio divide o arquivo em duaspartes iguais.

Caso mdio de acordo com Sedgewick e Flajolet (1996, p. 17):

C(n) 1, 386n log n 0, 846n,

Isso significa que em mdia o tempo de execuo do Quicksort O(n log n).


Quicksort

Vantagens:

extremamente eficiente para ordenar arquivos de dados.

Necessita de apenas uma pequena pilha como memria auxiliar.

Requer cerca de n log n comparaes em mdia para ordenar nitens.

Desvantagens:

Tem um pior caso O(n2) comparaes.

Sua implementao muito delicada e difcil:

Um pequeno engano pode levar a efeitos inesperados paraalgumas entradas de dados.

O mtodo no estvel .


Heapsort

Possui o mesmo princpio de funcionamento da ordenao porseleo.

Algoritmo:

1. Selecione o menor item do vetor.

2. Troque-o com o item da primeira posio do vetor.

3. Repita estas operaes com os n 1 itens restantes, depois comos n 2 itens, e assim sucessivamente.

O custo para encontrar o menor (ou o maior) item entre n itens n 1comparaes.

Isso pode ser reduzido utilizando uma fila de prioridades.


Heapsort

Filas de Prioridades

uma estrutura de dados onde a chave de cada item reflete suahabilidade relativa de abandonar o conjunto de itens rapidamente.

Aplicaes:

SOs usam filas de prioridades, nas quais as chaves representam otempo em que eventos devem ocorrer.

Mtodos numricos iterativos so baseados na seleo repetida deum item com maior (menor) valor.

Sistemas de gerncia de memria usam a tcnica de substituir apgina menos utilizada na memria principal por uma nova pgina.


HeapsortFilas de Prioridades - Tipo Abstrato de Dados

Operaes:

1. Constri uma fila de prioridades a partir de um conjunto com nitens.

2. Informa qual o maior item do conjunto.

3. Retira o item com maior chave.

4. Insere um novo item.

5. Aumenta o valor da chave do item i para um novo valor que maiorque o valor atual da chave.

6. Substitui o maior item por um novo item, a no ser que o novo itemseja maior.

7. Altera a prioridade de um item.

8. Remove um item qualquer.

9. Ajunta duas filas de prioridades em uma nica.


Heapsort

Filas de Prioridades - Representao

Representao atravs de uma lista linear ordenada:

Neste caso, Constri leva tempo O(n log n).

Insere O(n).

Retira O(1).

Ajunta O(n).

Representao atravs de uma lista linear no ordenada:

Neste caso, Constri tem custo linear.

Insere O(1).

Retira O(n).

Ajunta O(1) para apontadores e O(n) para arranjos.


Heapsort

Filas de Prioridades - Representao

A melhor representao atravs de uma estruturas de dadoschamada heap:

Neste caso, Constri O(n).

Insere, Retira, Substitui e Altera so O(log n).

Observao :Para implementar a operao Ajunta de forma eficiente e aindapreservar um custo logartmico para as operaes Insere, Retira,Substitui e Altera necessrio utilizar estruturas de dados maissofisticadas, tais como rvores binomiais (Vuillemin, 1978).


Heapsort

Filas de Prioridades - Algoritmos de Ordenao

As operaes das filas de prioridades podem ser utilizadas paraimplementar algoritmos de ordenao.

Basta utilizar repetidamente a operao Insere para construir a fila deprioridades.

Em seguida, utilizar repetidamente a operao Retira para receber ositens na ordem reversa.

O uso de listas lineares no ordenadas corresponde ao mtodo daseleo.

O uso de listas lineares ordenadas corresponde ao mtodo dainsero.

O uso de heaps corresponde ao mtodo Heapsort.


Heap

uma seqncia de itens com chaves c[1], c[2], . . . , c[n], tal que:

c[i] c[2i],

c[i] c[2i+ 1],

para todo i = 1, 2, . . . , n/2.

A definio pode ser facilmente visualizada em uma rvore binriacompleta:

1

2 3

75 64 E N

R

S

O

A D


Heap

rvore binria completa :

Os ns so numerados de 1 a n.

O primeiro n chamado raiz.

O n k/2 o pai do n k, para 1 < k n.

Os ns 2k e 2k+1 so os filhos esquerda e direita do n k, para1 k k/2.


Heap

As chaves na rvore satisfazem a condio do heap.

A chave em cada n maior do que as chaves em seus filhos.

A chave no n raiz a maior chave do conjunto.

Uma rvore binria completa pode ser representada por um array:

1 2 3 4 5 6 7

S R O E N A D

A representao extremamente compacta.

Permite caminhar pelos ns da rvore facilmente.

Os filhos de um n i esto nas posies 2i e 2i+ 1.

O pai de um n i est na posio i div 2.


Heap

Na representao do heap em um arranjo, a maior chave est semprena posio 1 do vetor.

Os algoritmos para implementar as operaes sobre o heap operamao longo de um dos caminhos da rvore.

Um algoritmo elegante para construir o heap foi proposto por Floyd em1964.

O algoritmo no necessita de nenhuma memria auxiliar.

Dado um vetor A[1], A[2], . . . , A[n].

Os itens A[n/2 + 1], A[n/2 + 2], . . . , A[n] formam um heap:

Neste intervalo no existem dois ndices i e j tais que j = 2i ouj = 2i+ 1.


Heap

1 2 3 4 5 6 7

Chaves iniciais: O R D E N A S

Esq = 3 O R S E N A D

Esq = 2 O R S E N A D

Esq = 1 S R O E N A D

Os itens de A[4] a A[7] formam um heap.

O heap estendido para a esquerda (Esq = 3), englobando o itemA[3], pai dos itens A[6] e A[7].


Heap

A condio de heap violada:

O heap refeito trocando os itens D e S.

O item R incluindo no heap (Esq = 2), o que no viola a condio deheap.

O item O incluindo no heap (Esq = 1).

A Condio de heap violada:

O heap refeito trocando os itens O e S, encerrando o processo.

O Programa que implementa a operao que informa o item com maiorchave:

TipoItem Max(TipoItem A)

{ return (A[1 ] ) ; }


Heap

Programa para refazer a condio de heap:

void Refaz(TipoIndice Esq, TipoIndice Dir , TipoItem A)

{ TipoIndice i = Esq;

int j ; TipoItem x;

j = i 2;

x = A[ i ] ;

while ( j = A[ j ] .Chave) goto L999;

A[ i ] = A[ j ] ; i = j ; j = i 2;

}

L999: A[ i ] = x;

}


Heap

Programa para construir o heap:

void Constroi(TipoItem A, TipoIndice n)

{ TipoIndice Esq;

Esq = n / 2 + 1;

while (Esq > 1)

{ Esq;

Refaz(Esq, n, A) ;

}

}


Heap

Programa que implementa a operao de retirar o item com maior chave:

TipoItem RetiraMax(TipoItem A, TipoIndice n)

{ TipoItem Maximo;

i f (n < 1)

pr int f ( "Erro : heap vazio \n" ) ;

else { Maximo = A[1 ] ; A[1] = A[n ] ; (n);

Refaz(1 , n, A) ;

}

return Maximo;

}


Heap

Programa que implementa a operao de aumentar o valor da chave doitem i:

void AumentaChave(TipoIndice i , TipoChave ChaveNova, TipoItem A)

{ TipoItem x;

i f (ChaveNova < A[ i ] .Chave)

{ pr int f ( "Erro : ChaveNova menor que a chave atual \n" ) ;

return ;

}

A[ i ] .Chave = ChaveNova;

while ( i > 1 && A[ i / 2 ] .Chave < A[ i ] .Chave)

{ x = A[ i / 2 ] ; A[ i / 2 ] = A[ i ] ; A[ i ] = x;

i /= 2;

}

}


Heap

Exemplo da operao de aumentar o valor da chave do item naposio i:

(c)

(a) (b)

(d)

i i

i

i

OE N

S

U

D E

EDANE

R

S

O R

S

O

DUN

U

SR

N O D

R

O tempo de execuo do procedimento AumentaChave em um item doheap O(log n).


Heap

Programa que implementa a operao de inserir um novo item no heap:

void Insere(TipoItem x , TipoItem A, TipoIndice n)

{(n)++; A[n] = x ; A[n] .Chave = INT_MIN;

AumentaChave(n, x>Chave, A) ;

}


Heapsort

Algoritmo:

1. Construir o heap.

2. Troque o item na posio 1 do vetor (raiz do heap) com o item daposio n.

3. Use o procedimento Refaz para reconstituir o heap para os itensA[1], A[2], . . . , A[n 1].

4. Repita os passos 2 e 3 com os n 1 itens restantes, depois com osn 2, at que reste apenas um item.


Heapsort

Exemplo de aplicao do Heapsort:

1 2 3 4 5 6 7

S R O E N A D

R N O E D A S

O N A E D R

N E A D O

E D A N

D A E

A D

O caminho seguido pelo procedimento Refaz para reconstituir acondio do heap est em negrito.

Por exemplo, aps a troca dos itens S e D na segunda linha da Figura,o item D volta para a posio 5, aps passar pelas posies 1 e 2.


Heapsort

Programa que mostra a implementao do Heapsort:

void Heapsort(TipoItem A, TipoIndice n)

{ TipoIndice Esq, Dir ;

TipoItem x;

Constroi(A, n) ; / constroi o heap /

Esq = 1; Dir = n;

while ( Dir > 1)

{ / ordena o vetor /

x = A[1 ] ; A[1] = A[ Dir ] ; A[ Dir ] = x ; Dir;

Refaz(Esq, Dir , A) ;

}

}

Anlise

O procedimento Refazgasta cerca de log n opera-es, no pior caso.

Logo, Heapsort gasta um tempo de execuo proporcional a n log n, nopior caso.


Heapsort

Vantagens:

O comportamento do Heapsort sempre O(n log n), qualquer queseja a entrada.

Desvantagens:

O anel interno do algoritmo bastante complexo se comparadocom o do Quicksort.

O Heapsort no estvel .

Recomendado:

Para aplicaes que no podem tolerar eventualmente um casodesfavorvel.

No recomendado para arquivos com poucos registros, por causado tempo necessrio para construir o heap.


Comparao entre os Mtodos

Complexidade:

Complexidade

Insero O(n2)

Seleo O(n2)

Shellsort O(n log n)

Quicksort O(n log n)

Heapsort O(n log n)

Apesar de no se conhecer analiticamente o comportamento doShellsort, ele considerado um mtodo eficiente).



Tempo de execuo:

Oservao: O mtodo que levou menos tempo real para executarrecebeu o valor 1 e os outros receberam valores relativos a ele.

Registros na ordem aleatria:

5.00 5.000 10.000 30.000

Insero 11,3 87 161

Seleo 16,2 124 228

Shellsort 1,2 1,6 1,7 2

Quicksort 1 1 1 1

Heapsort 1,5 1,6 1,6 1,6



Registros na ordem ascendente:

500 5.000 10.000 30.000

Insero 1 1 1 1

Seleo 128 1.524 3.066

Shellsort 3,9 6,8 7,3 8,1

Quicksort 4,1 6,3 6,8 7,1

Heapsort 12,2 20,8 22,4 24,6



Tempo de execuo:

Registros na ordem descendente:

500 5.000 10.000 30.000

Insero 40,3 305 575

Seleo 29,3 221 417

Shellsort 1,5 1,5 1,6 1,6

Quicksort 1 1 1 1

Heapsort 2,5 2,7 2,7 2,9


Comparao entre os MtodosObservaes sobre os mtodos:

1. Shellsort, Quicksort e Heapsort tm a mesma ordem de grandeza.

2. O Quicksort o mais rpido para todos os tamanhos aleatriosexperimentados.

3. A relao Heapsort/Quicksort constante para todos os tamanhos.

4. A relao Shellsort/Quicksort aumenta se o nmero de elementos aumenta.

5. Para arquivos pequenos (500 elementos), o Shellsort mais rpido que oHeapsort.

6. Se a entrada aumenta, o Heapsort mais rpido que o Shellsort.

7. O Insero o mais rpido se os elementos esto ordenados.

8. O Insero o mais lento para qualquer tamanho se os elementos esto emordem descendente.

9. Entre os algoritmos de custo O(n2), o Insero melhor para todos ostamanhos aleatrios experimentados.


Comparao entre os MtodosInfluncia da ordem inicial dos registros:

Shellsort Quicksort Heapsort

5.000 10.000 30.000 5.000 10.000 30.000 5.000 10.000 30.000

Asc 1 1 1 1 1 1 1,1 1,1 1,1

Des 1,5 1,6 1,5 1,1 1,1 1,1 1 1 1

Ale 2,9 3,1 3,7 1,9 2,0 2,0 1,1 1 1

1. Shellsort bastante sensvel ordenao ascendente ou descendente daentrada.

2. Em arquivos do mesmo tamanho, o Shellsort executa mais rpido paraarquivos ordenados.

3. Quicksort sensvel ordenao ascendente ou descendente da entrada.

4. Em arquivos do mesmo tamanho, o Quicksort executa mais rpido paraarquivos ordenados.

5. O Quicksort o mais rpido para qualquer tamanho para arquivos na ordemascendente.

6. O Heapsort praticamente no sensvel ordenao da entrada.



Mtodo da Insero:

o mais interessante para arquivos com menos do que 20 elementos.

O mtodo estvel.

Possui comportamento melhor do que o mtodo da bolha(Bubblesort) que tambm estvel.

Sua implementao to simples quanto as implementaes doBubblesort e Seleo.

Para arquivos j ordenados, o mtodo O(n).

O custo linear para adicionar alguns elementos a um arquivo jordenado.



Mtodo da Seleo:

vantajoso quanto ao nmero de movimentos de registros, que O(n).

Deve ser usado para arquivos com registros muito grandes, desde queo tamanho do arquivo no exceda 1.000 elementos.



Shellsort:

o mtodo a ser escolhido para a maioria das aplicaes por sermuito eficiente para arquivos de tamanho moderado.

Mesmo para arquivos grandes, o mtodo cerca de apenas duasvezes mais lento do que o Quicksort.

Sua implementao simples e geralmente resulta em um programapequeno.

No possui um pior caso ruim e quando encontra um arquivoparcialmente ordenado trabalha menos.


Comparao entre os MtodosQuicksort:

o algoritmo mais eficiente que existe para uma grande variedade desituaes.

um mtodo bastante frgil no sentido de que qualquer erro deimplementao pode ser difcil de ser detectado.

O algoritmo recursivo, o que demanda uma pequena quantidade dememria adicional.

Seu desempenho da ordem de O(n2) operaes no pior caso.

O principal cuidado a ser tomado com relao escolha do piv.

A escolha do elemento do meio do arranjo melhora muito odesempenho quando o arquivo est total ou parcialmente ordenado.

O pior caso tem uma probabilidade muito remota de ocorrer quando oselementos forem aleatrios.



Quicksort:

Geralmente se usa a mediana de uma amostra de trs elementos paraevitar o pior caso.

Esta soluo melhora o caso mdio ligeiramente.

Outra importante melhoria para o desempenho do Quicksort evitarchamadas recursivas para pequenos subarquivos.

Para isto, basta chamar um mtodo de ordenao simples nosarquivos pequenos.

A melhoria no desempenho significativa, podendo chegar a 20%para a maioria das aplicaes (Sedgewick, 1988).



Heapsort:

um mtodo de ordenao elegante e eficiente.

Apesar de ser cerca de duas vezes mais lento do que o Quicksort, nonecessita de nenhuma memria adicional.

Executa sempre em tempo proporcional a n log n,

Aplicaes que no podem tolerar eventuais variaes no tempoesperado de execuo devem usar o Heapsort.


Comparao entre os MtodosConsideraes finais:

Para registros muito grandes desejvel que o mtodo de ordenaorealize apenas n movimentos dos registros.

Com o uso de uma ordenao indireta possvel se conseguir isso.

Suponha que o arquivo A contenha os seguintes registros:A[1], A[2], . . . , A[n].

Seja P um arranjo P [1], P [2], . . . , P [n] de apontadores.

Os registros somente so acessados para fins de comparaes e todamovimentao realizada sobre os apontadores.

Ao final, P [1] contm o ndice do menor elemento de A, P [2] o ndicedo segundo menor e assim sucessivamente.

Essa estratgia pode ser utilizada para qualquer dos mtodos deordenao interna.


Ordenao Parcial

Consiste em obter os k primeiros elementos de um arranjo ordenadocom n elementos.

Quando k = 1, o problema se reduz a encontrar o mnimo (ou omximo) de um conjunto de elementos.

Quando k = n camos no problema clssico de ordenao.


Ordenao Parcial

Aplicaes:

Facilitar a busca de informao na Web com as mquinas de busca :

comum uma consulta na Web retornar centenas de milhares dedocumentos relacionados com a consulta.

O usurio est interessado apenas nos k documentos maisrelevantes.

Em geral k menor do que 200 documentos.

Normalmente so consultados apenas os dez primeiros.

Assim, so necessrios algoritmos eficientes de ordenao parcial.


Ordenao Parcial

Algoritmos considerados:

Seleo parcial.

Insero parcial.

Heapsort parcial.

Quicksort parcial.


Seleo Parcial

Um dos algoritmos mais simples.

Princpio de funcionamento:

Selecione o menor item do vetor.

Troque-o com o item que est na primeira posio do vetor.

Repita estas duas operaes com os itens n 1, n 2 . . . n k.


Seleo Parcial

void SelecaoParcial(TipoVetor A,

TipoIndice n, TipoIndice k)

{ TipoIndice i , j , Min; TipoItem x;

for ( i = 1; i


Seleo Parcial

muito simples de ser obtido a partir da implementao do algoritmode ordenao por seleo.

Possui um comportamento espetacular quanto ao nmero demovimentos de registros:

Tempo de execuo linear no tamanho de k.


Insero Parcial

Pode ser obtido a partir do algoritmo de ordenao por Insero pormeio de uma modificao simples:

Tendo sido ordenados os primeiros k itens, o item da k-simaposio funciona como um piv.

Quando um item entre os restantes menor do que o piv, ele inserido na posio correta entre os k itens de acordo com oalgoritmo original.


Insero Parcial

void InsercaoParcial (TipoVetor A, TipoIndice n,

TipoIndice k)

{ /Nao preserva o restante do vetor/

TipoIndice i , j ; TipoItem x;

for ( i = 2; i k) j = k ; else j = i 1;

A[0] = x ; / sentinela /

while (x.Chave < A[ j ] .Chave)

{ A[ j +1] = A[ j ] ;

j;

}

A[ j +1] = x;

}

}

A modificao realizadaverifica o momento emque i se torna maior doque k e ento passa aconsiderar o valor de jigual a k a partir desteponto.


Insero Parcial: Preserva Restante do Vetor

void InsercaoParcial2(TipoVetor A, TipoIndice n, TipoIndice k)

{ /Preserva o restante do vetor/

TipoIndice i , j ; TipoItem x;

for ( i = 2; i k)

{ j = k ; i f (x.Chave < A[k ] .Chave) A[ i ] = A[k ] ; }

else j = i 1;

A[0] = x ; / sentinela /

while (x.Chave < A[ j ] .Chave)

{ i f ( j < k ) {A[ j +1] = A[ j ] ; }

j;

}

i f ( j < k) A[ j +1] = x;

}

}


Insero Parcial: Anlise

No anel mais interno, na i-sima iterao o valor de Ci :

Melhor caso : Ci(n) = 1

Pior caso : Ci(n) = i

Caso medio : Ci(n) =1i(1 + 2 + + i) = i+1

2

Assumindo que todas as permutaes de n so igualmente provveis,o nmero de comparaes :

Melhor caso : C(n) = (1 + 1 + + 1) = n 1

Pior caso : C(n) = (2 + 3 + + k + (k + 1)(n k))

= kn+ n k2

2 k

2 1

Caso medio : C(n) = 12(3 + 4 + + k + 1 + (k + 1)(n k))

= kn2+ n

2 k

2

4+ k

4 1


Insero Parcial: Anlise

O nmero de movimentaes na i-sima iterao :

Mi(n) = Ci(n) 1 + 3 = Ci(n) + 2

Logo, o nmero de movimentos :

Melhor caso : M(n) = (3 + 3 + + 3) = 3(n 1)

Pior caso : M(n) = (4 + 5 + + k + 2 + (k + 1)(n k))

= kn+ n k2

2+ 3k

2 3

Caso medio : M(n) = 12(5 + 6 + + k + 3 + (k + 1)(n k))

= kn2+ n

2 k

2

4+ 5k

4 2

O nmero mnimo de comparaes e movimentos ocorre quando ositens esto originalmente em ordem.

O nmero mximo ocorre quando os itens esto originalmente naordem reversa.


Heapsort Parcial

Utiliza um tipo abstrato de dados heap para informar o menor item doconjunto.

Na primeira iterao, o menor item que est em a[1] (raiz do heap) trocado com o item que est em A[n].

Em seguida o heap refeito.

Novamente, o menor est em A[1], troque-o com A[n-1].

Repita as duas ltimas operaes at que o k-simo menor sejatrocado com A[n k].

Ao final, os k menores esto nas k ltimas posies do vetor A.


Heapsort Parcial

/Entram aqui os procedimentos Refaz e Constroi das transparencias 50 e 51/

/Coloca menor em A[n] , segundo menor em A[n1] , . . . , /

/ ksimo em A[nk ] /

void HeapsortParcial(TipoItem A, TipoIndice n, TipoIndice k)

{ TipoIndice Esq = 1; TipoIndice Dir ;

TipoItem x ; long Aux = 0;

Constroi(A, n) ; / constroi o heap /

Dir = n;

while (Aux < k)

{ / ordena o vetor /

x = A[1] ;

A[1] = A[n Aux] ;

A[n Aux] = x;

Dir; Aux++;

Refaz(Esq, Dir , A) ;

}

}


Heapsort Parcial: Anlise:

O HeapsortParcial deve construir um heap a um custo O(n).

O procedimento Refaz tem custo O(log n).

O procedimento HeapsortParcial chama o procedimento Refaz kvezes.

Logo, o algoritmo apresenta a complexidade:

O(n+ k log n) =

O(n) se k nlogn

O(k log n) se k > nlogn


Quicksort Parcial

Assim como o Quicksort, o Quicksort Parcial o algoritmo deordenao parcial mais rpido em vrias situaes.

A alterao no algoritmo para que ele ordene apenas os k primeirositens dentre n itens muito simples.

Basta abandonar a partio direita toda vez que a partio esquerda contiver k ou mais itens.

Assim, a nica alterao necessria no Quicksort evitar a chamadarecursiva Ordena(i,Dir).


Quicksort Parcial

1 2 3 4 5 6


1 A D R E N O

2 A D

3 E R N O

4 N R O

5 O R

A D E N O R

Considere k = 3 e D o piv para gerar as linhas 2 e 3.

A partio esquerda contm dois itens e a partio direita, quatro itens.

A partio esquerda contm menos do que k itens.

Logo, a partio direita no pode ser abandonada.

Considere E o piv na linha 3.

A partio esquerda contm trs itens e a partio direita tambm.

Assim, a partio direita pode ser abandonada.


Quicksort Parcial

void Ordena(TipoVetor A, TipoIndice Esq, TipoIndice Dir , TipoIndice k)


Particao(A, Esq, Dir , & i , & j ) ;

i f ( j Esq >= k 1) { i f (Esq < j ) Ordena(A, Esq, j , k ) ; return ; }

i f (Esq < j ) Ordena(A, Esq, j , k ) ;

i f ( i < Dir ) Ordena(A, i , Dir , k ) ;

}

void QuickSortParcial (TipoVetor A, TipoIndice n, TipoIndice k)

{ Ordena(A, 1 , n, k ) ; }


Quicksort Parcial: Anlise:

A anlise do Quicksort difcil.

O comportamento muito sensvel escolha do piv.

Podendo cair no melhor caso O(k log k).

Ou em algum valor entre o melhor caso e O(n log n).


Comparao entre os Mtodos de Ordenao Parcial (1)

n, k Seleo Quicksort Insero Insero2 Heapsort

n : 101 k : 100 1 2,5 1 1,2 1,7

n : 101 k : 101 1,2 2,8 1 1,1 2,8

n : 102 k : 100 1 3 1,1 1,4 4,5

n : 102 k : 101 1,9 2,4 1 1,2 3

n : 102 k : 102 3 1,7 1 1,1 2,3

n : 103 k : 100 1 3,7 1,4 1,6 9,1

n : 103 k : 101 4,6 2,9 1 1,2 6,4

n : 103 k : 102 11,2 1,3 1 1,4 1,9

n : 103 k : 103 15,1 1 3,9 4,2 1,6

n : 105 k : 100 1 2,4 1,1 1,1 5,3

n : 105 k : 101 5,9 2,2 1 1 4,9

n : 105 k : 102 67 2,1 1 1,1 4,8

n : 105 k : 103 304 1 1,1 1,3 2,3

n : 105 k : 104 1445 1 33,1 43,3 1,7

n : 105 k : 105 1 1,9


Comparao entre os Mtodos de Ordenao Parcial (2)

n, k Seleo Quicksort Insero Insero2 Heapsort

n : 106 k : 100 1 3,9 1,2 1,3 8,1

n : 106 k : 101 6,6 2,7 1 1 7,3

n : 106 k : 102 83,1 3,2 1 1,1 6,6

n : 106 k : 103 690 2,2 1 1,1 5,7

n : 106 k : 104 1 5 6,4 1,9

n : 106 k : 105 1 1,7

n : 106 k : 106 1 1,8

n : 107 k : 100 1 3,4 1,1 1,1 7,4

n : 107 k : 101 8,6 2,6 1 1,1 6,7

n : 107 k : 102 82,1 2,6 1 1,1 6,8

n : 107 k : 103 3,1 1 1,1 6,6

n : 107 k : 104 1,1 1 1,2 2,6

n : 107 k : 105 1 2,2

n : 107 k : 106 1 1,2

n : 107 k : 107 1 1,7


Comparao entre os Mtodos de Ordenao Parcial

1. Para valores de k at 1.000, o mtodo da InseroParcial imbatvel.

2. O QuicksortParcial nunca ficar muito longe da InseroParcial.

3. Na medida em que o k cresce,o QuicksortParcial a melhor opo.

4. Para valores grandes de k, o mtodo da InseroParcial se torna ruim.

5. Um mtodo indicado para qualquer situao o QuicksortParcial.

6. O HeapsortParcial tem comportamento parecido com o doQuicksortParcial.

7. No entano, o HeapsortParcial mais lento.


Ordenao em Tempo Linear

Nos algoritmos apresentados a seguir no existe comparao entrechaves.

Eles tm complexidade de tempo linear na prtica.

Necessitam manter uma cpia em memria dos itens a seremordenados e uma rea temporria de trabalho.


Ordenao por Contagem

Este mtodo assume que cada item do vetor A um nmero inteiroentre 0 e k.

O algoritmo conta, para cada item x, o nmero de itens antes de x.

A seguir, cada item colocado no vetor de sada na sua posiodefinitiva.



1 1 1 3 48

476543

02

01

11

A

(b) (c)(a)

(d) (e)

2 3 4 5 6 7 8

0 1 2 3 4C

B

C

1 2 3 4 5 6 7 8

10 2 3 4

44 0 3 0 1 1

2 3 0 1 2

41

42 5 6 7

10 2 3 42 5 5 6 8

11 4

1

2 3 4 5 6 7 81

0 2 3 42 3 5 6 7

B

C

1

14

B

C

2 3 4 5 6 7 8

0 2 3 41

2 5 6 8

B

(f)

A contm oito chaves de inteiros entre 0 e 4. Cada etapa mostra:

(a) o vetor de entrada A e o vetor auxiliar C contendo o nmero deitens iguais a i, 0 i 4;

(b) o vetor C contendo o nmero de itens i, 0 i 4;

(c), (d), (e) os vetores auxiliares B e C aps uma, duas e trsiteraes, considerando os itens em A da direita para a esquerda;

(f) o vetor auxiliar B ordenado.



void Contagem(TipoItem A, TipoIndice n, int k)

{ int i ;

for ( i = 0; i



Os arranjos auxiliares B e C devem ser declarados fora doprocedimento Contagem para evitar que sejam criados a cadachamada do procedimento.

No quarto for, como podem haver itens iguais no vetor A, ento o valorde C[A[j]] decrementado de 1 toda vez que um item A[j] colocadono vetor B. Isso garante que o prximo item com valor igual a A[j], seexistir, vai ser colocado na posio imediatamente antes de A[j] novetor B.

O ltimo for copia para A o vetor B ordenado. Essa cpia pode serevitada colocando o vetor B como parmetro de retorno noprocedimento Contagem, como mostrado no Exerccio 4.24.

A ordenao por contagem um mtodo estvel.


Ordenao por Contagem: Anlise

O primeiro for tem custo O(k).

O segundo for tem custo O(n).

O terceiro for tem custo O(k).

O quarto for tem custo O(n+ k).

Na prtica o algoritmo deve ser usado quando k = O(n), o que leva oalgoritmo a ter custo O(n).

De outra maneira, as complexidades de espao e de tempo ficamproibitivas. Na seo seguinte vamos apresentar um algoritmo prticoe eficiente para qualquer valor de k.


Radixsort para Inteiros

Utiliza o princpio da distribuio das antigas classificadoras decartes perfurados.

Os cartes eram organizados em 80 colunas e cada coluna permitiauma perfurao em 1 de 12 lugares.

Para nmeros inteiros positivos, apenas 10 posies da coluna eramusadas para os valores entre 0 e 9.

A classificadora examinava uma coluna de cada carto e distribuiamecanicamente o carto em um dos 12 escaninhos, dependendo dolugar onde fora perfurado.

Um operador ento recolhia os 12 conjuntos de cartes na ordemdesejada, ascendente ou descendente.



Radixsort considera o dgito menos significativo primeiro e ordena ositens para aquele dgito.

Depois repete o processo para o segundo dgito menos significativo, eassim sucessivamente.

07 01 01

33 22 07

18 33 07

22 07 18

01 07 22

07 18 33



Primeiro refinamento:

#define BASE 256

#define M 8

#define NBITS 32

RadixsortInt (TipoItem A, TipoIndice n)

{ for ( i = 0; i < NBITS / M; i++)

Ordena A sobre o dgito i menos signif icativo usando um algoritmo estvel ;

}

O programa recebe o vetor A e o tamanho n do vetor.

O nmero de bits da chave (NBits) e o nmero de bits a considerar emcada passada (m) determinam o nmero de passadas, que igual aNBits div m.



O algoritmo de ordenao por contagem uma excelente opo paraordenar o vetor A sobre o dgito i por ser estvel e de custo O(n).

O vetor auxiliar C ocupa um espao constante que depende apenasda base utilizada.

Por exemplo, para a base 10, o vetor C armazena valores de kentre 0 e 9, isto , 10 posies.

A implementao a seguir utiliza Base = 256 e o vetor C armazenavalores de k entre 0 e 255 para representar os caracteres ASCII.

Nesse caso podemos ordenar inteiros de 32 bits (4 bytes com valoresentre 0 e 232) em apenas d = 4 chamadas do algoritmo de ordenaopor contagem.



O algoritmo de ordenao por contagem precisa ser alterado paraordenar sobre m bits de cada chave do vetor A.

A funo GetBits extrai um conjunto contguo de m bits do nmerointeiro.

Em linguagem de mquina, os bits so extrados de nmeros binriosusando operaes and, shl (shift left), shr (shift right), e not(complementa todos os bits).

Por exemplo, os 2 bits menos significativos de um nmero x de 10 bitsso extrados movendo os bits para a direita com x shr 2 e umaoperao and com a mscara 0000000011.


Ordenao por Contagem Alterado

#define GetBits(x,k, j ) ( x >> k) & ~((~0)



No Programa, quando qualquer posio i do vetor C contm um valorigual a n significa que todos os n nmeros do vetor de entrada A soiguais a i.

Isso verificado no comando if logo aps o segundo for para C[0].Nesse caso todos os valores de A so iguais a zero no byteconsiderado como chave de ordenao e o restante do anel noprecisa ser executado.

Essa situao ocorre com frequncia nos bytes mais significativos deum nmero inteiro.

Por exemplo, para ordenar nmeros de 32 bits que tenham valoresentre 0 e 255, os trs bytes mais significativos so iguais a zero.



void RadixsortInt (TipoItem A, TipoIndice n)

{ int i ;

for ( i = 0; i < NBITS / M; i ++) ContagemInt(A, n, i ) ;

}


Radixsort para Inteiros: Anlise

Cada passada sobre n inteiros em ContagemInt custa O(n+ Base).

Como so necessrias d passadas, o custo total O(dn+ dBase).

Radixsort tem custo O(n) quando d constante e Base = O(n).

Se cada nmero cabe em uma palavra de computador, ento ele podeser tratado como um nmero de d dgitos na notao base n.

Para A contendo 1 bilho de nmeros de 32 bits (4 dgitos na base28 = 256), apenas 4 chamadas de Contagem so necessrias.

Se considerarmos um algoritmo que utiliza o princpio da comparaode chaves, como o Quicksort, ento so necessrias log n = 30operaes por nmero (considerando que uma palavra de computadorocupa O(log n) bits).

Isso significa que o Radixsort mais rpido para ordenar inteiros.

O aspecto negativo o espao adicional para B e C.


Radixsort para Cadeias de Caracteres

O algoritmo de ordenao por contagem precisa ser alterado paraordenar sobre o caractere k da chave de cada item x do vetor A.

void ContagemCar(TipoItem A, TipoIndice n, int k)

{ int i , j ;

for ( i = 0; i


Radixsort para Cadeias de Caracteres

void RadixsortCar(TipoItem A, TipoIndice n)

{ int i ;

for ( i = TAMCHAVE 1; i >= 0; i) ContagemCar (A, n, i ) ;

}


Ordenao Externa

A ordenao externa consiste em ordenar arquivos de tamanho maiorque a memria interna disponvel.

Os mtodos de ordenao externa so muito diferentes dos deordenao interna.

Na ordenao externa os algoritmos devem diminuir o nmero deacesso as unidades de memria externa.

Nas memrias externas, os dados ficam em um arquivo seqencial.

Apenas um registro pode ser acessado em um dado momento. Essa uma restrio forte se comparada com as possibilidades de acessoem um vetor.

Logo, os mtodos de ordenao interna so inadequados paraordenao externa.

Tcnicas de ordenao diferentes devem ser utilizadas.


Ordenao Externa

Fatores que determinam as diferenas das tcnicas de ordenao externa:

1. Custo para acessar um item algumas ordens de grandeza maior.

2. O custo principal na ordenao externa relacionado a transfernciade dados entre a memria interna e externa.

3. Existem restries severas de acesso aos dados.

4. O desenvolvimento de mtodos de ordenao externa muitodependente do estado atual da tecnologia.

5. A variedade de tipos de unidades de memria externa torna osmtodos dependentes de vrios parmetros.

6. Assim, apenas mtodos gerais sero apresentados.


Ordenao Externa

O mtodo mais importante o de ordenao por intercalao.

Intercalar significa combinar dois ou mais blocos ordenados em umnico bloco ordenado.

A intercalao utilizada como uma operao auxiliar na ordenao.

Estratgia geral dos mtodos de ordenao externa:

1. Quebre o arquivo em blocos do tamanho da memria internadisponvel.

2. Ordene cada bloco na memria interna.

3. Intercale os blocos ordenados, fazendo vrias passadas sobre oarquivo.

4. A cada passada so criados blocos ordenados cada vez maiores,at que todo o arquivo esteja ordenado.


Ordenao Externa

Os algoritmos para ordenao externa devem reduzir o nmero depassadas sobre o arquivo.

Uma boa medida de complexidade de um algoritmo de ordenao porintercalao o nmero de vezes que um item lido ou escrito namemria auxiliar.

Os bons mtodos de ordenao geralmente envolvem no total menosdo que dez passadas sobre o arquivo.


Intercalao Balanceada de Vrios Caminhos

Considere um arquivo armazenado em uma fita de entrada:

I N T E R C A L A C A O B A L A N C E A D A

Objetivo:

Ordenar os 22 registros e coloc-los em uma fita de sada.

Os registros so lidos um aps o outro.

Considere uma memria interna com capacidade para para trsregistros.

Considere que esteja disponvel seis unidades de fita magntica.



Fase de criao dos blocos ordenados:

fita 1: I N T A C O A D E

fita 2: C E R A B L A

fita 3: A A L A C N



Fase de intercalao - Primeira passada:

1. O primeiro registro de cada fita lido.

2. Retire o registro contendo a menor chave.

3. Armazene-o em uma fita de sada.

4. Leia um novo registro da fita de onde o registro retirado proveniente.

5. Ao ler o terceiro registro de um dos blocos, sua fita fica inativa.

6. A fita reativada quando o terceiro registro das outras fitas foremlidos.



Fase de intercalao - Primeira passada:

7. Neste instante um bloco de nove registros ordenados foi formadona fita de sada.

8. Repita o processo para os blocos restantes.

Resultado da primeira passada da segunda etapa:

fita 4: A A C E I L N R T

fita 5: A A A B C C L N O

fita 6: A A D E



Quantas passadas so necessrias para ordenar um arquivo detamanho arbitrrio?

Seja n, o nmero de registros do arquivo.

Suponha que cada registro ocupa m palavras na memria interna.

A primeira etapa produz n/m blocos ordenados.

Seja P (n) o nmero de passadas para a fase de intercalao.

Seja f o nmero de fitas utilizadas em cada passada.

Assim:P (n) = logf

n

m.

No exemplo acima, n=22, m=3 e f=3 temos:

P (n) = log322

3= 2.



No exemplo foram utilizadas 2f fitas para umaintercalao-de-f -caminhos.

possvel usar apenas f + 1 fitas:

Encaminhe todos os blocos para uma nica fita.

Redistribuia estes blocos entre as fitas de onde eles foram lidos.

O custo envolvido uma passada a mais em cada intercalao.

No caso do exemplo de 22 registros, apenas quatro fitas seriamsuficientes:

A intercalao dos blocos a partir das fitas 1, 2 e 3 seria todadirigida para a fita 4.

Ao final, o segundo e o terceiro blocos ordenados de nove registrosseriam transferidos de volta para as fitas 1 e 2.


Implementao por meio de Seleo por Substituio

A implementao do mtodo de intercalao balanceada pode serrealizada utilizando filas de prioridades.

As duas fases do mtodo podem ser implementadas de formaeficiente e elegante.

Operaes bsicas para formar blocos ordenados:

Obter o menor dentre os registros presentes na memria interna.

Substitu-lo pelo prximo registro da fita de entrada.

Estrutura ideal para implementar as operaes: heap.

Operao de substituio:

Retirar o menor item da fila de prioridades.

Colocar um novo item no seu lugar.

Reconstituir a propriedade do heap.



Algoritmo:

1. Inserir m elementos do arquivo na fila de prioridades.

2. Substituir o menor item da fila de prioridades pelo prximo item doarquivo.

3. Se o prximo item menor do que o que saiu, ento:

Considere-o membro do prximo bloco.

Trate-o como sendo maior do que todos os itens do bloco corrente.

4. Se um item marcado vai para o topo da fila de prioridades ento:

O bloco corrente encerrado.

Um novo bloco ordenado iniciado.



Entra 1 2 3

E I N T

R N E* T

C R E* T

A T E* C*

L A* E* C*

A C* E* L*

C E* A L*

A L* A C

O A A C

B A O C

A B O C

Entra 1 2 3

L C O A*

A L O A*

N O A* A*

C A* N* A*

E A* N* C*

A C* N* E*

D E* N* A

A N* D A

A D A

A D

D

Primeira passada sobre o arquivo exemplo.

Os asteriscos indicam quais chaves pertencem a blocos diferentes.



Fase de intercalao dos blocos ordenados obtidos na primeira fase:

Operao bsica: obter o menor item dentre os ainda no retiradosdos f blocos a serem intercalados.

Algoritmo:

Monte uma fila de prioridades de tamanho f .

A partir de cada uma das f entradas:

Substitua o item no topo da fila de prioridades pelo prximo item domesmo bloco do item que est sendo substitudo.

Imprima em outra fita o elemento substitudo.



Exemplo:

Entra 1 2 3

A A C I

L A C I

E C L I

R E L I

N I L R

L N R

T N R

R T

T

Para f pequeno no vantajosoutilizar seleo por substituiopara intercalar blocos:

Obtm-se o menor item fa-zendo f 1 comparaes.

Quando f 8 ou mais, o mtodo adequado:

Obtm-se o menor item fa-zendo log2 f comparaes.


Consideraes Prticas

As operaes de entrada e sada de dados devem ser implementadaseficientemente.

Deve-se procurar realizar a leitura, a escrita e o processamentointerno dos dados de forma simultnea.

Os computadores de maior porte possuem uma ou mais unidadesindependentes para processamento de entrada e sada.

Assim, pode-se realizar processamento e operaes de E/Ssimultaneamente.


Consideraes Prticas

Tcnica para obter superposio de E/S e processamento interno:

Utilize 2f reas de entrada e 2f de sada.

Para cada unidade de entrada ou sada, utiliza-se duas reas dearmazenamento:

1. Uma para uso do processador central2. Outra para uso do processador de entrada ou sada.

Para entrada, o processador central usa uma das duas reasenquanto a unidade de entrada est preenchendo a outra rea.

Depois a utilizao das reas invertida entre o processador deentrada e o processador central.

Para sada, a mesma tcnica utilizada.


Consideraes Prticas

Problemas com a tcnica:

Apenas metade da memria disponvel utilizada.

Isso pode levar a uma ineficincia se o nmero de reas for grande.Ex: Intercalao-de-f -caminhos para f grande.

Todas as f reas de entrada em uma intercalao-de-f -caminhosse esvaziando aproximadamente ao mesmo tempo.


Consideraes Prticas

Soluo para os problemas:

Tcnica de previso:

Requer a utilizao de uma nica rea extra de armazenamentodurante a intercalao.

Superpe a entrada da prxima rea que precisa ser preenchidacom a parte de processamento interno do algoritmo.

fcil saber qual rea ficar vazia primeiro. Basta olhar para o ltimo registro de cada rea. A rea cujo ltimo registro o menor, ser a primeira a se

esvaziar.


Consideraes Prticas

Escolha da ordem de intercalao f :

Para fitas magnticas:

f deve ser igual ao nmero de unidades de fita disponveismenos um.

A fase de intercalao usa f fitas de entrada e uma fita de sada. O nmero de fitas de entrada deve ser no mnimo dois.

Para discos magnticos:

O mesmo raciocnio acima vlido. O acesso seqencial mais eficiente.

Sedegwick (1988) sugere considerar f grande o suficiente paracompletar a ordenao em poucos passos.

Porm, a melhor escolha para f depende de vrios parmetrosrelacionados com o sistema de computao disponvel.


Intercalao Polifsica

Problema com a intercalao balanceada de vrios caminhos:

Necessita de um grande nmero de fitas.

Faz vrias leituras e escritas entre as fitas envolvidas.

Para uma intercalao balanceada de f caminhos so necessrias2f fitas.

Alternativamente, pode-se copiar o arquivo quase todo de umanica fita de sada para f fitas de entrada.

Isso reduz o nmero de fitas para f + 1.

Porm, h um custo de uma cpia adicional do arquivo.

Soluo:

Intercalao polifsica .



Os blocos ordenados so distribudos de forma desigual entre as fitasdisponveis.

Uma fita deixada livre.

Em seguida, a intercalao de blocos ordenados executada at queuma das fitas esvazie.

Neste ponto, uma das fitas de sada troca de papel com a fita deentrada.



Exemplo:

Blocos ordenados obtidos por meio de seleo por substituio:

fita 1: I N R T A C E L A A B C L O

fita 2: A A C E N A A D

fita 3:

Configurao aps uma intercalao-de-2-caminhos das fitas 1 e 2para a fita 3:

fita 1: A A B C L O

fita 2:

fita 3: A A C E I N N R T A A A C D E L



Exemplo:

Depois da intercalao-de-2-caminhos das fitas 1 e 3 para a fita 2:

fita 1:

fita 2: A A A A B C C E I L N N O R T

fita 3: A A A C D E L

Finalmente:

fita 1: A A A A A A A B C C C D E E I L L N N O R T

fita 2:

fita 3:

A intercalao realizada em muitas fases.

As fases no envolvem todos os blocos.

Nenhuma cpia direta entre fitas realizada.



A implementao da intercalao polifsica simples.

A parte mais delicada est na distribuio inicial dos blocos ordenadosentre as fitas.

Distribuio dos blocos nas diversas etapas do exemplo:

fita 1 fita 2 fita 3 Total

3 2 0 5

1 0 2 3

0 1 1 2

1 0 0 1



Anlise:

A anlise da intercalao polifsica complicada.

O que se sabe que ela ligeiramente melhor do que a intercalaobalanceada para valores pequenos de f .

Para valores de f > 8, a intercalao balanceada pode ser maisrpida.


Quicksort Externo

Foi proposto por Monard em 1980.

Utiliza o paradigma de diviso e conquista .

O algoritmo ordena in situ um arquivo A = {R1, . . . , Rn} de n registros.

Os registros esto armazenados consecutivamente em memriasecundria de acesso randmico.

O algoritmo utiliza somente O(log n) unidades de memria interna eno necessria nenhuma memria externa adicional.


Quicksort Externo

Seja Ri, 1 i n, o registro que se encontra na i-sima posio de A.

Algoritmo:

1. Particionar A da seguinte forma:{R1, . . . , Ri} Ri+1 Ri+2 . . . Rj2 Rj1 {Rj, . . . , Rn},

2. chamar recursivamente o algoritmo em cada um dos subarquivosA1 = {R1, . . . , Ri} e A2 = {Rj, . . . , Rn}.


Quicksort Externo

Para o partionamento utilizanda uma rea de armazenamento namemria interna.

Tamanho da rea: TamArea = j i 1, com TamArea 3.

Nas chamadas recusivas deve-se considerar que:

Primeiro deve ser ordenado o subarquivo de menor tamanho.

Condio para que, na mdia, O(log n) subarquivos tenham oprocessamento adiado.

Subarquivos vazios ou com um nico registro so ignorados.

Caso o arquivo de entrada A possua no mximo TamArea registros,ele ordenado em um nico passo.


Quicksort Externo

5 3 10 6 1 7 4

5 3 10 6 1 7 4

3 10 6 1 7 75

3 10 6 1 7 73

10 6 1 7 73 1

10 6 1 73 1 10

10 73 1 106 6

i Li j

EsEi

Ls

i j

EsEi

LsLi

i j

Ei

Li Ls

Es

i jLs

Es

Li

Ei

j

Es

Li Lsi

Ei

i

Ei

Ls j

Es

Li

i

Ei

jLs Li

Es

4 5 3 7

4 5 3 7

74 5 3

734 5

74 5

4 5

5 3 10 6 1 7 4

5 3 10 6 1 7 4

3 10 6 1 7 75

3 10 6 1 7 73

10 6 1 7 73 1

10 6 1 73 1 10

1 4 65 7103

i j

EsEi

Li Ls

i j

Ei

Ls

Es

Li

i j

Es

Li

Ei

Ls

j

Es

i

Ei

LsLi

i

Ei

j

Es

Ls Li

i jLs Li

EsEi

ji Li Ls

Ei Es

4 5 6

4 5

4 5

3 7

3 7

3 7

3 7

3 4 5 7

4 5 7

4

rea Linf Lsup

a)

c)

e)

g)

i)

k)

m) n)

l)

j)

h)

f)

d)

b)

LsupLinfrea


Quicksort Externo

void QuicksortExterno(FILE ArqLi , FILE ArqEi , FILE ArqLEs,int Esq, int Dir )

{ int i , j ;TipoArea Area; / Area de armazenamento interna/

i f ( Dir Esq < 1) return ;FAVazia(&Area) ;

Particao(ArqLi , ArqEi , ArqLEs, Area, Esq, Dir , & i , & j ) ;

i f ( i Esq < Dir j ){ / ordene primeiro o subarquivo menor /

QuicksortExterno(ArqLi , ArqEi , ArqLEs, Esq, i ) ;

QuicksortExterno(ArqLi , ArqEi , ArqLEs, j , Dir ) ;

}

else{ QuicksortExterno(ArqLi , ArqEi , ArqLEs, j , Dir ) ;

QuicksortExterno(ArqLi , ArqEi , ArqLEs, Esq, i ) ;

}

}


Quicksort Externo: Procedimentos Auxiliares

void LeSup(FILE ArqLEs,TipoRegistro UltLido , int Ls,short OndeLer)

{ fseek(ArqLEs, (Ls 1) sizeof (TipoRegistro) ,SEEK_SET ) ;

fread(UltLido , sizeof (TipoRegistro) , 1 , ArqLEs) ;

(Ls); OndeLer = FALSE;

}

void LeInf (FILE ArqLi ,TipoRegistro UltLido , int Li ,short OndeLer)

{ fread(UltLido , sizeof (TipoRegistro) , 1 , ArqLi ) ;

(Li )++; OndeLer = TRUE;

}

void InserirArea(TipoArea Area, TipoRegistro UltLido , int NRArea)

{ /Insere UltLido de forma ordenada na Area/

InsereItem(UltLido , Area) ; NRArea = ObterNumCelOcupadas(Area) ;

}


Quicksort Externo: Procedimentos Auxiliares

void EscreveMax(FILE ArqLEs, TipoRegistro R, int Es)

{ fseek(ArqLEs, (Es 1) sizeof (TipoRegistro) ,SEEK_SET ) ;

fwrite(&R, sizeof (TipoRegistro) , 1 , ArqLEs) ; (Es);

}

void EscreveMin(FILE ArqEi , TipoRegistro R, int Ei)

{ fwrite(&R, sizeof (TipoRegistro) , 1 , ArqEi ) ; (Ei)++; }

void RetiraMax(TipoArea Area, TipoRegistro R, int NRArea)

{ RetiraUltimo(Area, R) ; NRArea = ObterNumCelOcupadas(Area) ; }

void RetiraMin(TipoArea Area, TipoRegistro R, int NRArea)

{ RetiraPrimeiro(Area, R) ; NRArea = ObterNumCelOcupadas(Area) ; }


Quicksort Externo: Procedimento Particao

void Particao(FILE ArqLi , FILE ArqEi , FILE ArqLEs,

TipoArea Area, int Esq, int Dir , int i , int j )

{ int Ls = Dir , Es = Dir , Li = Esq, Ei = Esq,

NRArea = 0 , Linf = INT_MIN , Lsup = INT_MAX;

short OndeLer = TRUE ; TipoRegistro UltLido , R;

fseek (ArqLi , ( Li 1) sizeof (TipoRegistro ) , SEEK_SET ) ;

fseek (ArqEi , ( Ei 1) sizeof (TipoRegistro ) , SEEK_SET ) ;

i = Esq 1; j = Dir + 1;

while (Ls >= Li )

{ i f (NRArea < TAMAREA 1)

{ i f (OndeLer)

LeSup(ArqLEs, &UltLido , &Ls, &OndeLer) ;

else LeInf (ArqLi, &UltLido , &Li , &OndeLer) ;

InserirArea(&Area, &UltLido , &NRArea) ;

continue ;

}

i f (Ls == Es)

LeSup(ArqLEs, &UltLido , &Ls, &OndeLer) ;

else i f ( Li == Ei ) LeInf (ArqLi, &UltLido , &Li , &OndeLer) ;

else i f (OndeLer) LeSup(ArqLEs, &UltLido , &Ls, &OndeLer) ;

else LeInf (ArqLi, &UltLido , &Li , &OndeLer) ;


Quicksort Externo: Procedimento Particao

i f ( UltLido .Chave > Lsup)

{ j = Es; EscreveMax(ArqLEs, UltLido , &Es) ;

continue ;

}

i f ( UltLido .Chave < Linf )

{ i = Ei ; EscreveMin(ArqEi , UltLido , &Ei ) ;

continue ;

}

InserirArea(&Area, &UltLido , &NRArea) ;

i f ( Ei Esq < Dir Es)

{ RetiraMin(&Area, &R, &NRArea) ;

EscreveMin(ArqEi , R, &Ei ) ; Linf = R.Chave;

}

else { RetiraMax(&Area, &R, &NRArea) ;

EscreveMax(ArqLEs, R, &Es) ; Lsup = R.Chave;

}

}

while ( Ei


Quicksort Externo: Programa Testetypedef int TipoApontador;

/Entra aqui o Programa C.23/

typedef TipoItem TipoRegistro ;

/Declaracao dos tipos utilizados pelo quicksort externo/

FILE ArqLEs; / Gerencia o Ls e o Es /

FILE ArqLi ; / Gerencia o Li /

FILE ArqEi ; / Gerencia o Ei /

TipoItem R;

/Entram aqui os Programas J.4, D.26, D.27 e D.28/

int main( int argc , char argv [ ] )

{ ArqLi = fopen ( " teste .dat" , "wb" ) ;

i f (ArqLi == NULL){ pr int f ( "Arquivo nao pode ser aberto \n" ) ; exit (1) ; }

R.Chave = 5; fwrite(&R, sizeof (TipoRegistro ) , 1 , ArqLi ) ;







fclose(ArqLi ) ;


Quicksort Externo: Programa Teste

ArqLi = fopen ( " teste .dat" , " r+b" ) ;

i f ( ArqLi == NULL){ pr int f ( "Arquivo nao pode ser aberto \n" ) ; exit (1) ; }

ArqEi = fopen ( " teste .dat" , " r+b" ) ;

i f (ArqEi == NULL){ pr int f ( "Arquivo nao pode ser aberto \n" ) ; exit (1) ; }

ArqLEs = fopen ( " teste .dat" , " r+b" ) ;

i f (ArqLEs == NULL) { pr int f ( "Arquivo nao pode ser aberto \n" ) ; exit (1) ; }

QuicksortExterno(&ArqLi, &ArqEi, &ArqLEs, 1 , 7) ;

ff lush (ArqLi ) ; fclose(ArqEi ) ; fclose(ArqLEs) ; fseek(ArqLi ,0 , SEEK_SET) ;

while ( fread(&R, sizeof (TipoRegistro ) , 1 , ArqLi ) ) { pr int f ( "Registro=%d\n" , R.Chave) ; }

fclose(ArqLi ) ; return 0;

}


Quicksort Externo: Anlise

Seja n o nmero de registros a serem ordenados.

Seja e b o tamanho do bloco de leitura ou gravao do Sistemaoperacional.

Melhor caso: O(nb)

Por exemplo, ocorre quando o arquivo de entrada j est ordenado.

Pior caso: O( n2

TamArea)

ocorre quando um dos arquivos retornados pelo procedimentoParticao tem o maior tamanho possvel e o outro vazio.

A medida que n cresce, a probabilidade de ocorrncia do pior casotende a zero.

Caso Mdio: O(nblog( n

TamArea))

o que tem amaior probabilidade de ocorrer.

Documents

Ordenação - DCC | Departamento de Ci??ncia da Computa????o · Projeto de Algoritmos – Cap.4 Ordenação 2 Introdução - Conceitos Básicos • Ordenar: processo de rearranjar