Cap 4

Ordenao
ltima alterao: 10 de Outubro de 2006
elaboradas por Fabiano C. Botelho, Leonardo Rocha, Leonardo Mata e Nivio Ziviani
Transparncias
Projeto de Algoritmos Cap.4 Ordenao
Ordenao
Introduo - Conceitos Bsicos Ordenao Interna Ordenao por Seleo Ordenao por Insero Shellsort Quicksort Heapsort Ordenao Parcial Seleo Parcial Insero Parcial Heapsort Parcial Quicksort Parcial Ordenao Externa Intercalao Balanceada de Vrios Caminhos Implementao por meio de Seleo por Substituio Consideraes Prticas Intercalao Polifsica Quicksort Externo
Introduo - Conceitos Bsicos

Ordenar: processo de rearranjar um conjunto de objetos em uma ordem ascendente ou descendente. A ordenao visa facilitar a recuperao posterior de itens do conjunto ordenado. Diculdade de se utilizar um catlogo telefnico se os nomes das pessoas no estivessem listados em ordem alfabtica. A maioria dos mtodos de ordenao baseada em comparaes das chaves. Existem mtodos de ordenao que utilizam o princpio da distribuio.

Exemplo de ordenao por distribuio: considere o problema de ordenar um baralho com 52 cartas na ordem: A < 2 < 3 < < 10 < J < Q < K e < < < . Algoritmo: 1. Distribuir as cartas abertas em treze montes: ases, dois, trs, . . ., reis. 2. Colete os montes na ordem especicada. 3. Distribua novamente as cartas abertas em quatro montes: paus, ouros, copas e espadas. 4. Colete os montes na ordem especicada.

Mtodos como o ilustrado so tambm conhecidos como ordenao digital, radixsort ou bucketsort. O mtodo no utiliza comparao entre chaves. Uma das diculdades de implementar este mtodo est relacionada com o problema de lidar com cada monte. Se para cada monte ns reservarmos uma rea, ento a demanda por memria extra pode tornar-se proibitiva. O custo para ordenar um arquivo com n elementos da ordem de O(n). Notao utilizada nos algoritmos: Os algoritmos trabalham sobre os registros de um arquivo. Cada registro possui uma chave utilizada para controlar a ordenao. Podem existir outros componentes em um registro.

Qualquer tipo de chave sobre o qual exista uma regra de ordenao bem-denida pode ser utilizado. Em Java pode-se criar um tipo de registro genrico chamado iterface Uma interface uma classe que no pode ser instanciada e deve ser implementada por outra classe. A iterface para a chave de ordenao chama-se Item inclui os mtodos compara , alteraChave e recuperaChave .
package cap4; public interface Item { public int compara ( Item i t ) ; public void alteraChave ( Object chave) ; public Object recuperaChave ( ) ; }

A classe MeuItem dene o tipo de dados int para a chave e implementa os mtodos compara , alteraChave e recuperaChave . O mtodo compara retorna um valor menor do que zero se a < b, um valor maior do que zero se a > b, e um valor igual a zero se a = b.
package cap4; import java . io . ; public class MeuItem implements Item { private int chave; / / outros componentes do registro public MeuItem ( int chave ) { this .chave = chave ; } public int compara ( Item i t ) { MeuItem item = (MeuItem) i t ; i f ( this .chave < item .chave) return 1; else i f ( this .chave > item .chave) return 1; return 0; } / / Continua na prxima transparncia

public void alteraChave ( Object chave) { Integer ch = ( Integer ) chave; this .chave = ch. intValue ( ) ; } public Object recuperaChave ( ) { return new Integer ( this .chave ) ; } }
Deve-se ampliar a interface Item sempre que houver necessidade de manipular a chave de um registro. O mtodo compara sobrescrito para determinar como so comparados dois objetos da classe MeuItem . Os mtodos alteraChave e recuperaChave so sobrescritos para determinar como alterar e como recuperar o valor da chave de um objeto da classe MeuItem .

Um mtodo de ordenao estvel se a ordem relativa dos itens com chaves iguais no se altera durante a ordenao. Alguns dos mtodos de ordenao mais ecientes no so estveis. A estabilidade pode ser forada quando o mtodo no-estvel. Sedgewick (1988) sugere agregar um pequeno ndice a cada chave antes de ordenar, ou ento aumentar a chave de alguma outra forma.

Classicao dos mtodos de ordenao: Ordenao interna: arquivo a ser ordenado cabe todo na memria principal. Ordenao externa: arquivo a ser ordenado no cabe na memria principal. Diferenas entre os mtodos: Em um mtodo de ordenao interna, qualquer registro pode ser imediatamente acessado. Em um mtodo de ordenao externa, os registros so acessados seqencialmente ou em grandes blocos.
Projeto de Algoritmos Cap.4 Ordenao Seo 4.1
10
Ordenao Interna
Na escolha de um algoritmo de ordenao interna deve ser considerado o tempo gasto pela ordenao. Sendo n o nmero registros no arquivo, as medidas de complexidade relevantes 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 na ordenao 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 possuem menor importncia.
11
Ordenao Interna
Classicao dos mtodos de ordenao interna: Mtodos simples: Adequados para pequenos arquivos. Requerem O(n2 ) comparaes. Produzem programas pequenos. Mtodos ecientes: Adequados para arquivos maiores. Requerem O(n log n) comparaes. Usam menos comparaes. As comparaes so mais complexas nos detalhes. Mtodos simples so mais ecientes para pequenos arquivos.
12
Ordenao Interna
A classe mostrada a seguir apresenta os mtodos de ordenao interna que sero estudados. Utilizaremos um vetor v de registros do tipo Item e uma varivel inteira n com o tamanho de v . O vetor contm registros nas posies de 1 at n, e a 0 utilizada para sentinelas.
package cap4. ordenacaointerna ; import cap4. Item ; / / vide transparncia 6
public class Ordenacao { public static void selecao ( Item v [ ] , int n) public static void insercao ( Item v [ ] , int n) public static void shellsort ( Item v [ ] , int n) public static void quicksort ( Item v [ ] , int n) public static void heapsort ( Item v [ ] , int n) }
Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.1
13
Ordenao por Seleo

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, depois com os n 2 itens, at que reste apenas um elemento. O mtodo ilustrado abaixo:
1 Chaves iniciais: i=1 i=2 i=3 i=4 i=5 O A A A A A 2 R R D D D D 3 D D R E E E 4 E E E R N N 5 N N N N R O 6 A O O O O R
As chaves em negrito sofreram uma troca entre si.
14
Ordenao por Seleo

public static void selecao ( Item v [ ] , int n) { for ( int i = 1; i <= n 1; i ++) { int min = i ; for ( int j = i + 1; j <= n ; j ++) i f ( v [ j ] .compara ( v [min] ) < 0 ) min = j ; Item x = v [min ] ; v [min] = v [ i ] ; v [ i ] = x ; } }
Anlise Comparaes entre chaves e movimentaes de registros: C (n) =

n2 2
n 2
M (n) = 3(n 1) A atribuio min = j executada em mdia n log n vezes, Knuth (1973).
15
Ordenao por Seleo

Vantagens: Custo linear no tamanho da entrada para o nmero de movimentos de registros. o algoritmo a ser utilizado para arquivos com registros muito grandes. muito interessante para arquivos pequenos. Desvantagens: O fato de o arquivo j estar ordenado no ajuda em nada, pois o custo continua quadrtico. O algoritmo no estvel.
16
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. O mtodo ilustrado abaixo:
1 Chaves iniciais: i=2 i=3 i=4 i=5 i=6 O O D D D A 2 R R O E E D 3 D D R O N E 4 E E E R O N 5 N N N N R O 6 A A A A A R
As chaves em negrito representam a seqncia destino.
17
Ordenao por Insero

public static void insercao ( Item v [ ] , int n) { int j ; for ( int i = 2; i <= n ; i ++) { Item x = v [ i ] ; j = i 1; v[0] = x ; / / sentinela while ( x .compara ( v [ j ] ) < 0 ) { v [ j + 1] = v [ j ] ; j ; } v [ j + 1] = x ; } }
A colocao do item no seu lugar apropriado na seqncia destino realizada movendo-se itens com chaves maiores para a direita e ento inserindo o item na posio deixada vazia.
18
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 nal da seqncia destino atingido esquerda. Soluo: Utilizar um registro sentinela na posio zero do vetor.
19
Ordenao por Insero

Anlise 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 caso m edio : Ci (n) = i : Ci (n) = 1 (1 + 2 + + i) = i
i+1 2
Assumindo que todas as permutaes de n so igualmente provveis no caso mdio, temos: melhor caso : C (n) = (1 + 1 + + 1) = n 1 pior caso caso m edio : C (n) = (2 + 3 + + n) = : C (n) =
n 1 2 1 (3 + 4 + 2 n2 3n + 1 4 4 n2 + 2
+ n + 1) =
20
Ordenao por Insero

Anlise Seja M (n) a funo que conta o nmero de movimentaes de registros. 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 caso m edio : M (n) = (4 + 5 + + n + 2) = : M (n) =
5n n2 + 3 2 2 1 (5 + 6 + 2 n2 11n + 3 4 4
+ n + 3) =
21
Ordenao por Insero

O nmero mnimo de comparaes e movimentos ocorre quando os itens esto originalmente em ordem. O nmero mximo ocorre quando os itens esto originalmente na ordem reversa. o mtodo a ser utilizado quando o arquivo est quase ordenado. um bom mtodo quando se deseja adicionar uns poucos itens a um arquivo ordenado, pois o custo linear. O algoritmo de ordenao por insero estvel.
22
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 o menor item est na posio mais direita no vetor. O mtodo de Shell contorna este problema permitindo trocas de registros distantes um do outro.
23
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 Chaves iniciais: h=4 h=2 h=1 O N D A 2 R A A D 3 D D N E 4 E E E N 5 N O O O 6 A R R R
Quando h = 1 Shellsort corresponde ao algoritmo de insero.
24
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 esta seqncia difcil de ser batida por mais de 20% em ecincia. A seqncia para h corresponde a 1, 4, 13, 40, 121, 364, 1.093, 3.280, . . .
25
Shellsort
public static void shellsort ( Item v [ ] , int n) { int h = 1; do h = h 3 + 1; while (h < n) ; do { h /= 3; for ( int i = h + 1; i <= n ; i ++) { Item x = v [ i ] ; int j = i ; while ( v [ j h ] .compara ( x) > 0) { v [ j ] = v [ j h ] ; j = h; i f ( j <= h) break ; } v[ j ] = x; } } while (h ! = 1 ) ; }
A implementao do Shellsort no utiliza registros sentinelas. Seriam necessrios h registros sentinelas, uma para cada h-ordenao.
26
Shellsort
Anlise A razo da ecincia 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 do anterior. Conjecturas referente ao nmero de comparaes para a seqncia de Knuth: Conjetura 1 : C (n) = O(n1,25 ) Conjetura 2 : C (n) = O(n(ln n)2 )
27
Shellsort
Vantagens: Shellsort uma tima opo para arquivos de tamanho moderado. Sua implementao simples e requer uma quantidade de cdigo pequena. Desvantagens: O tempo de execuo do algoritmo sensvel ordem inicial do arquivo. O mtodo no estvel,
28
Quicksort
Proposto por Hoare em 1960 e publiccado em 1962. o algoritmo de ordenao interna mais rpido que se conhece para uma ampla variedade de situaes. Provavelmente o mais utilizado. A idia bsica dividir o problema de ordenar um conjunto com n itens em dois problemas menores. Os problemas menores so ordenados independentemente. Os resultados so combinados para produzir a soluo nal.
29
Quicksort
A parte mais delicada do mtodo relativa ao mtodo particao . O vetor v [esq ..dir ] rearranjado por meio da escolha arbitrria de um piv x. O vetor v particionado em duas partes: A parte esquerda com chaves menores ou iguais a x. A parte direita com chaves maiores ou iguais a x.
30
Quicksort
Algoritmo para o particionamento: 1. Escolha arbitrariamente um piv x. 2. Percorra o vetor a partir da esquerda at que v [i] x. 3. Percorra o vetor a partir da direita at que v [j ] x. 4. Troque v [i] com v [j ]. 5. Continue este processo at os apontadores i e j se cruzarem. Ao nal, o vetor v [esq ..dir ] est particionado de tal forma que: Os itens em v [esq ], v [esq + 1], . . . , v [j ] so menores ou iguais a x. Os itens em v [i], v [i + 1], . . . , v [dir ] so maiores ou iguais a x.
31
Quicksort
Ilustrao do processo de partio:
1 O A A 2 R R D 3 D D R 4 E E E 5 N N N 6 A O O
O piv x escolhido como sendo v [(i + j ) / 2]. Como inicialmente i = 1 e j = 6, ento x = v [3] = D. Ao nal do processo de partio i e j se cruzam em i = 3 e j = 2.
32
Quicksort
Mtodo Partio:
private static class LimiteParticoes { int i ; int j ; } private static LimiteParticoes particao (Item v [ ] , int esq, int dir ) { LimiteParticoes p = new LimiteParticoes ( ) ; p. i = esq ; do { while ( x .compara ( v [p. i ] ) > 0 ) p. i ++; while ( x .compara ( v [p. j ] ) < 0 ) p. j ; i f (p. i <= p. j ) { Item w = v [p. i ] ; v [p. i ] = v [p. j ] ; v [p. j ] = w; p. i ++; p. j ; } } while (p. i <= p. j ) ; return p; } p. j = dir ; Item x = v [ (p. i + p. j ) / 2 ] ; / / obtm o pivo x
O modicador private nessa classe encapsula os mtodos para serem utilizados somente dentro da classe Ordenacao . O anel interno do procedimento Particao extremamente simples. Razo pela qual o algoritmo Quicksort to rpido.
33
Quicksort
Mtodo ordena e algoritmo Quicksort :
private static void ordena ( Item v [ ] , int esq, int dir ) { LimiteParticoes p = particao ( v , esq, dir ) ; i f (esq < p. j ) ordena ( v , esq, p. j ) ; i f (p. i < dir ) ordena ( v , p. i , dir ) ; } public static void quicksort ( Item v [ ] , int n) { ordena ( v , 1 , n) ; }
34
Quicksort
Exemplo do estado do vetor em cada chamada recursiva do procedimento Ordena:
Chaves iniciais: 1 2 3 4 5
O A A
R D D
D R E
E E R N
N N N R O O
A O O O R R
O piv mostrado em negrito.
35
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 como sendo um dos extremos de um arquivo j ordenado. Isto faz com que o procedimento Ordena seja chamado recursivamente n vezes, eliminando apenas um item em cada chamada. O pior caso pode ser evitado empregando pequenas modicaes no algoritmo. Para isso basta escolher trs itens quaisquer do vetor e usar a mediana dos trs como piv.
36
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 duas partes iguais. Caso mdio de acordo com Sedgewick e Flajolet (1996, p. 17): C (n) 1, 386n log n 0, 846n, Isso signica que em mdia o tempo de execuo do Quicksort O(n log n).
37
Quicksort
Vantagens: extremamente eciente 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 n itens. Desvantagens: Tem um pior caso O(n2 ) comparaes. Sua implementao muito delicada e difcil: Um pequeno engano pode levar a efeitos inesperados para algumas entradas de dados. O mtodo no estvel.
38
Heapsort
Possui o mesmo princpio de funcionamento da ordenao por seleo. 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 com os n 2 itens, e assim sucessivamente. O custo para encontrar o menor (ou o maior) item entre n itens n 1 comparaes. Isso pode ser reduzido utilizando uma la de prioridades.
39
Heapsort
Filas de Prioridades uma estrutura de dados onde a chave de cada item reete sua habilidade relativa de abandonar o conjunto de itens rapidamente. Aplicaes: SOs usam las de prioridades, nas quais as chaves representam o tempo em que eventos devem ocorrer. Mtodos numricos iterativos so baseados na seleo repetida de um item com maior (menor) valor. Sistemas de gerncia de memria usam a tcnica de substituir a pgina menos utilizada na memria principal por uma nova pgina.
40
Heapsort
Filas de Prioridades - Tipo Abstrato de Dados Operaes: 1. Constri uma la de prioridades a partir de um conjunto com n itens. 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 maior que o valor atual da chave. 6. Substitui o maior item por um novo item, a no ser que o novo item seja maior. 7. Altera a prioridade de um item. 8. Remove um item qualquer. 9. Ajunta duas las de prioridades em uma nica.
41
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.
42
Heapsort
Filas de Prioridades - Representao A melhor representao atravs de uma estruturas de dados chamada heap: Neste caso, Constri O(n). Insere, Retira, Substitui e Altera so O(log n). Observao: Para implementar a operao Ajunta de forma eciente e ainda preservar um custo logartmico para as operaes Insere, Retira, Substitui e Altera necessrio utilizar estruturas de dados mais sosticadas, tais como rvores binomiais (Vuillemin, 1978).
43
Heapsort
Filas de Prioridades - Algoritmos de Ordenao As operaes das las de prioridades podem ser utilizadas para implementar algoritmos de ordenao. Basta utilizar repetidamente a operao Insere para construir a la de prioridades. Em seguida, utilizar repetidamente a operao Retira para receber os itens na ordem reversa. O uso de listas lineares no ordenadas corresponde ao mtodo da seleo. O uso de listas lineares ordenadas corresponde ao mtodo da insero. O uso de heaps corresponde ao mtodo Heapsort .
44
Heapsort
Heaps 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 denio pode ser facilmente visualizada em uma rvore binria completa:
1 S
2 R
5 N
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 lhos esquerda e direita do n k , para 1 k k/2 .
45
Heapsort
Heaps As chaves na rvore satisfazem a condio do heap. As chaves em cada n s ao maiores do que as chaves em seus lhos. A chave no n raiz a maior chave do conjunto. Uma rvore binria completa pode ser representada por um arranjo:
1 S 2 R 3 O 4 E 5 N 6 A 7 D
A representao extremamente compacta. Permite caminhar pelos ns da rvore facilmente. Os lhos de um n i esto nas posies 2i e 2i + 1. O pai de um n i est na posio i / 2.
46
Heapsort
Heaps Na representao do heap em um arranjo, a maior chave est sempre na posio 1 do vetor. Os algoritmos para implementar as operaes sobre o heap operam ao longo de um dos caminhos da rvore. Um algoritmo elegante para construir o heap foi proposto por Floyd em 1964. O algoritmo no necessita de nenhuma memria auxiliar. Dado um vetor v [1], v [2], . . . , v [n]. Os itens v [n/2 + 1], v [n/2 + 2], . . . , v [n] formam um heap: Neste intervalo no existem dois ndices i e j tais que j = 2i ou j = 2i + 1.
47
Heapsort
Estrutura de dados la de prioridades implementada utilizando um heap
package cap4. ordenacaointerna ; import cap4. Item ; / / vide transparncia 6 public class FPHeapMax { private Item v [ ] ; private int n; public FPHeapMax ( Item v [ ] ) { this . v = v ; this .n = this . v . length 1; } public void refaz ( int esq, int dir ) public void constroi ( ) public Item max ( ) public Item retiraMax ( ) throws Exception public void aumentaChave ( int i , Object chaveNova) throws Exception public void insere ( Item x ) throws Exception }
48
Heapsort
Heaps Algoritmo:
1 Chaves iniciais: Esq = 3 Esq = 2 Esq = 1 O O O S 2 R R R R 3 D S S O 4 E E E E 5 N N N N 6 A A A A 7 S D D D
Os itens de v [4] a v [7] formam um heap. O heap estendido para a esquerda (esq = 3), englobando o item v [3], pai dos itens v [6] e v [7]. 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 de heap. 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.
49
Heapsort
Heaps O Programa que implementa a operao que informa o item com maior chave:
public Item max ( ) { return this . v [ 1 ] ; }
Mtodo para refazer o heap:

public void refaz ( int esq, int dir ) { int j = esq 2 ; Item x = this . v [esq ] ; while ( j <= dir ) { i f ( ( j < dir ) && ( this . v [ j ] .compara ( this . v [ j + 1]) < 0)) j ++; i f ( x .compara ( this . v [ j ]) >= 0) break ; this . v [esq] = this . v [ j ] ; esq = j ; j = esq 2; } this . v [esq] = x ; }
50
Heapsort
Heaps Mtodo para construir o heap:
/ / Usa o mtodo refaz da transparncia 49 public void constroi ( ) { int esq = n / 2 + 1 ; while (esq > 1) { esq; this . refaz (esq, this .n) ; } }
51
Heapsort
Heaps Programa que implementa a operao de retirar o item com maior chave:
/ / Usa o mtodo refaz da transparncia 49 public Item retiraMax ( ) throws Exception { Item maximo; i f ( this .n < 1) throw new Exception ( "Erro : heap vazio" ) ; else { maximo = this . v [ 1 ] ; this . v[1] = this . v [ this .n]; refaz ( 1 , this .n) ; } return maximo; }
52
Heapsort
Heaps Programa que implementa a operao de aumentar o valor da chave do item i:
public void aumentaChave ( int i , Object chaveNova) throws Exception { Item x = this . v [ i ] ; i f (chaveNova == null ) throw new Exception ( "Erro : chaveNova com valor null " ) ; x . alteraChave (chaveNova) ; while ( ( i > 1) && (x .compara ( this . v [ i / 2 ] ) > = 0 ) ) { this . v [ i ] = this . v [ i / 2 ] ; i /= 2; } this . v [ i ] = x ; }
53
Heapsort
Heaps Exemplo da operao de aumentar o valor da chave do item na posio i:
(a)
S
(b)
i
E N S A D E N U
i
U D
(c)
(d) i
i
S
O tempo de execuo do procedimento AumentaChave em um item do heap O(log n).
54
Heapsort
Heaps Programa que implementa a operao de inserir um novo item no heap:
/ / Usa o mtodo aumentaChave da tranparncia 52 public void insere ( Item x ) throws Exception { this .n++; i f ( this .n == this . v . length ) throw new Exception ( "Erro : heap cheio" ) ; Object chaveNova = x .recuperaChave ( ) ; this . v [ this .n] = x ; this . v [ this .n ] . alteraChave (new Integer ( Integer . MIN_VALUE ) ) ; / / this .aumentaChave ( this .n, chaveNova) ; }
55
Heapsort
Algoritmo: 1. Construir o heap. 2. Troque o item na posio 1 do vetor (raiz do heap) com o item da posio n. 3. Use o procedimento Refaz para reconstituir o heap para os itens v [1], v [2], . . . , v [n 1]. 4. Repita os passos 2 e 3 com os n 1 itens restantes, depois com os n 2, at que reste apenas um item.
56
Heapsort
Exemplo de aplicao do Heapsort :
1 S R O N E D A 2 R N N E D A D 3 O O A A A E 4 E E E D N 5 N D D O 6 A A R 7 D S
O caminho seguido pelo procedimento Refaz para reconstituir a condio 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.
57
Heapsort
Programa que mostra a implementao do Heapsort para um conjunto de n itens implementado como um vetor do tipo Item :
public static void heapsort ( Item v [ ] , int n) { / / Usa a classe FPHeapMax da transparncia 47 FPHeapMax fpHeap = new FPHeapMax ( v ) ; int dir = n; fpHeap. constroi ( ) ; / / constroi o heap while ( dir > 1 ) { / / ordena o vetor Item x = v [ 1 ] ; v[1] = v [ dir ] ; v [ dir ] = x ; dir ; fpHeap. refaz ( 1 , dir ) ; } }
Anlise O procedimento Refaz gasta cerca de log n operaes, no pior caso. Logo, Heapsort gasta um tempo de execuo proporcional a n log n, no pior caso.
58
Heapsort
Vantagens: O comportamento do Heapsort sempre O(n log n), qualquer que seja a entrada. Desvantagens: O anel interno do algoritmo bastante complexo se comparado com o do Quicksort . O Heapsort no estvel. Recomendado: Para aplicaes que no podem tolerar eventualmente um caso desfavorvel. No recomendado para arquivos com poucos registros, por causa do tempo necessrio para construir o heap.
59
Comparao entre os Mtodos

Complexidade:
Complexidade Insero Seleo Shellsort Quicksort Heapsort O (n2 ) O (n2 ) O(n log n) O(n log n) O(n log n)
Apesar de no se conhecer analiticamente o comportamento do Shellsort , ele considerado um mtodo eciente.
60

Tempo de execuo: Oservao: O mtodo que levou menos tempo real para executar recebeu o valor 1 e os outros receberam valores relativos a ele. Registros na ordem aleatria:
5.00 Insero Seleo Shellsort Quicksort Heapsort 11,3 16,2 1,2 1 1,5 5.000 87 124 1,6 1 1,6 10.000 161 228 1,7 1 1,6 30.000 2 1 1,6
Registros na ordem ascendente:

500 Insero Seleo Shellsort Quicksort Heapsort 1 128 3,9 4,1 12,2 5.000 1 1.524 6,8 6,3 20,8 10.000 1 3.066 7,3 6,8 22,4 30.000 1 8,1 7,1 24,6
61

Tempo de execuo: Registros na ordem descendente:
500 Insero Seleo Shellsort Quicksort Heapsort 40,3 29,3 1,5 1 2,5 5.000 305 221 1,5 1 2,7 10.000 575 417 1,6 1 2,7 30.000 1,6 1 2,9
62

Observaes sobre os mtodos: 1. Shellsort , Quicksort e Heapsort tm a mesma ordem de grandeza. 2. O Quicksort o mais rpido para todos os tamanhos aleatrios experimentados. 3. A relao Heapsort /Quicksort se mantm constante para todos os tamanhos, sendo o Heapsort mais lento. 4. A relao Shellsort /Quicksort aumenta medida que o nmero de elementos aumenta; para arquivos pequenos (500 elementos), o Shellsort mais rpido que o Heapsort ; porm, quando o tamanho da entrada cresce, essa relao se inverte. 5. O mtodo da Insero o mais rpido para qualquer tamanho se os elementos esto ordenados; Ele o mais lento para qualquer tamanho se os elementos esto em ordem descendente; 6. Entre os algoritmos de custo O(n2 ), o Insero melhor para todos os tamanhos aleatrios experimentados.
63

Inuncia da ordem inicial do registros:
Shellsort 5.000 Asc Des Ale 1 1,5 2,9 10.000 1 1,6 3,1 30.000 1 1,5 3,7 5.000 1 1,1 1,9 Quicksort 10.000 1 1,1 2,0 30.000 1 1,1 2,0 5.000 1,1 1 1,1 Heapsort 10.000 1,1 1 1 30.000 1,1 1 1
1. O Shellsort bastante sensvel ordenao ascendente ou descendente da entrada; 2. Em arquivos do mesmo tamanho, o Shellsort executa mais rpido para arquivos ordenados. 3. O Quicksort sensvel ordenao ascendente ou descendente da entrada. 4. Em arquivos do mesmo tamanho, o Quicksort executa mais rpido para arquivos ordenados. 5. O Quicksort o mais rpido para qualquer tamanho para arquivos na ordem ascendente. 6. O Heapsort praticamente no sensvel ordenao da entrada.
64

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 do Bubblesort e Seleo. Para arquivos j ordenados, o mtodo O(n). O custo linear para adicionar alguns elementos a um arquivo j ordenado.
65

Mtodo da Seleo: vantajoso quanto ao nmero de movimentos de registros, que O(n). Deve ser usado para arquivos com registros muito grandes, desde que o tamanho do arquivo no exceda 1.000 elementos.
66

Shellsort: o mtodo a ser escolhido para a maioria das aplicaes por ser muito eciente para arquivos de tamanho moderado. Mesmo para arquivos grandes, o mtodo cerca de apenas duas vezes mais lento do que o Quicksort . Sua implementao simples e geralmente resulta em um programa pequeno. No possui um pior caso ruim e quando encontra um arquivo parcialmente ordenado trabalha menos.
67

Quicksort: o algoritmo mais eciente que existe para uma grande variedade de situaes. um mtodo bastante frgil no sentido de que qualquer erro de implementao pode ser difcil de ser detectado. O algoritmo recursivo, o que demanda uma pequena quantidade de memria 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 o desempenho quando o arquivo est total ou parcialmente ordenado. O pior caso tem uma probabilidade muito remota de ocorrer quando os elementos forem aleatrios.
68

Quicksort: Geralmente se usa a mediana de uma amostra de trs elementos para evitar o pior caso. Esta soluo melhora o caso mdio ligeiramente. Outra importante melhoria para o desempenho do Quicksort evitar chamadas recursivas para pequenos subarquivos. Para isto, basta chamar um mtodo de ordenao simples nos arquivos pequenos. A melhoria no desempenho signicativa, podendo chegar a 20% para a maioria das aplicaes (Sedgewick, 1988).
69

Heapsort: um mtodo de ordenao elegante e eciente. Apesar de ser cerca de duas vezes mais lento do que o Quicksort , no necessita de nenhuma memria adicional. Executa sempre em tempo proporcional a n log n, Aplicaes que no podem tolerar eventuais variaes no tempo esperado de execuo devem usar o Heapsort .
70

Consideraes nais: Para registros muito grandes desejvel que o mtodo de ordenao realize 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: v [1], v [2], . . . , v [n]. Seja p um arranjo p [1], p [2], . . . , p [n] de apontadores. Os registros somente so acessados para ns de comparaes e toda movimentao realizada sobre os apontadores. Ao nal, p [1] contm o ndice do menor elemento de v , p [2] o ndice do segundo menor e assim sucessivamente. Essa estratgia pode ser utilizada para qualquer dos mtodos de ordenao interna.
71
Ordenao Parcial
Consiste em obter os k primeiros elementos de um vetor ordenado com n elementos. Quando k = 1, o problema se reduz a encontrar o mnimo (ou o mximo) de um conjunto de elementos. Quando k = n camos no problema clssico de ordenao.
72
Ordenao Parcial
Aplicaes: Facilitar a busca de informao na Web com as mquinas de busca: comum uma consulta na Web retornar centenas de milhares de documentos relacionados com a consulta. O usurio est interessado apenas nos k documentos mais relevantes. Em geral k menor do que 200 documentos. Normalmente so consultados apenas os dez primeiros. Assim, so necessrios algoritmos ecientes de ordenao parcial.
73
Ordenao Parcial
Algoritmos considerados: Seleo parcial. Insero parcial. Heapsort parcial. Quicksort parcial. A classe OrdenacaoParcial mostrada a seguir.
package cap4. ordenacaointerna ; import cap4. Item ; / / vide transparncia 5
public class OrdenacaoParcial { public static void selecaoParcial(Item v [ ] , int n, int k) public static void insercaoParcial (Item v [ ] , int n, int k) public static void insercaoParcial2(Item V[ ] , int n, int k) public static void quicksortParcial (Item v [ ] , int n, int k) public static void heapsortParcial (Item v [ ] , int n, int k) }
74
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 .
75
Seleo Parcial
public static void selecaoParcial ( Item v [ ] , int n, int k) { for ( int i = 1; i <= k ; i ++) { int min = i ; for ( int j = i + 1; j <= n ; j ++) i f ( v [ j ] .compara ( v [min] ) < 0 ) min = j ; Item x = v [min ] ; v [min] = v [ i ] ; v [ i ] = x ; } }
Anlise: Comparaes entre chaves e movimentaes de registros: C (n) = kn M (n) = 3k

k2 2
k 2
76
Seleo Parcial
muito simples de ser obtido a partir da implementao do algoritmo de ordenao por seleo. Possui um comportamento espetacular quanto ao nmero de movimentos de registros: Tempo de execuo linear no tamanho de k .
77
Insero Parcial
Pode ser obtido a partir do algoritmo de ordenao por Insero por meio de uma modicao simples: Tendo sido ordenados os primeiros k itens, o item da k -sima posio 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 o algoritmo original.
78
Insero Parcial
public static void insercaoParcial ( Item v [ ] , int n, int k) { int j ; for ( int i = 2; i <= n ; i ++) { Item x = v [ i ] ; i f ( i > k ) j = k ; else j = i 1; v[0] = x ; / / sentinela while ( x .compara ( v [ j ] ) < 0 ) { v [ j + 1] = v [ j ] ; j ; } v [ j + 1] = x ; } }
Obs: 1. A modicao realizada verica o momento em que i se torna maior do que k e ento passa a considerar o valor de j igual a k a partir deste ponto. 2. O algoritmo no preserva o restante do vetor.
79
Insero Parcial
Algoritmo de Insero Parcial que preserva o restante do vetor:
public static void insercaoParcial2 ( Item v [ ] , int n, int k) { int j ; for ( int i = 2; i <= n ; i ++) { Item x = v [ i ] ; if ( i > k) { j = k; i f ( x .compara ( v [ k] ) < 0 ) v [ i ] = v [ k ] ; } else j = i 1; v[0] = x ; / / sentinela while ( x .compara ( v [ j ] ) < 0 ) { i f ( j < k ) v [ j + 1] = v [ j ] ; j ; } i f ( j < k ) v [ j + 1] = x ; } }
80
Insero Parcial
Anlise: No anel mais interno, na i-sima iterao o valor de Ci :
melhor caso pior caso caso m edio : Ci (n) = 1 : Ci (n) = i : Ci (n) =
1 (1 i
+ 2 + + i) =
i+1 2
Assumindo que todas as permutaes de n so igualmente provveis, o nmero de comparaes :

melhor caso pior caso caso m edio : C (n) : C (n) : C (n) = (1 + 1 + + 1) = n 1 = (2 + 3 + + k + (k + 1)(n k)) = kn + n = =
1 (3 + 4 2 kn +n 2 2 k2 2 k2 4 k 2
1 1
+ + k + 1 + (k + 1)(n k)) +
k 4
81
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 pior caso caso m edio : M (n) : M (n) : M (n) = (3 + 3 + + 3) = 3(n 1) = (4 + 5 + + k + 2 + (k + 1)(n k)) = kn + n = =
1 (5 + 6 2 kn +n 2 2 k2 2 k2 4
3k 2
3 2
+ + k + 3 + (k + 1)(n k)) +
5k 4
O nmero mnimo de comparaes e movimentos ocorre quando os itens esto originalmente em ordem. O nmero mximo ocorre quando os itens esto originalmente na ordem reversa.
82
Heapsort Parcial
Utiliza um tipo abstrato de dados heap para informar o menor item do conjunto. Na primeira iterao, o menor item que est em v [1] (raiz do heap) trocado com o item que est em v [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 seja trocado com v [n k ]. Ao nal, os k menores esto nas k ltimas posies do vetor v .
83
Heapsort Parcial
public static void heapsortParcial ( Item v [ ] , int n, int k) { / / Coloca menor em v[n], segundo em v[n-1],...,k-esimo em v[n-k] FPHeapMin fpHeap = new FPHeapMin ( v ) ; int dir = n, aux = 0; fpHeap. constroi ( ) ; / / constroi o heap while (aux < k ) { / / ordena o vetor Item x = v [ 1 ] ; v[1] = v [ dir ] ; v [ dir ] = x ; dir ; aux++; fpHeap. refaz ( 1 , dir ) ; } }
84
Heapsort Parcial
Anlise: O Heapsort Parcial deve construir um heap a um custo O(n). O mtodo refaz tem custo O(log n). O mtodo heapsortParcial chama o mtodo refaz k vezes. Logo, o algoritmo apresenta a complexidade: O(n + k log n) =
O (n)
se k
O (k log n) se k >
n log n n log n
85
Quicksort Parcial
Assim como o Quicksort, o Quicksort Parcial o algoritmo de ordenao parcial mais rpido em vrias situaes. A alterao no algoritmo para que ele ordene apenas os k primeiros itens 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 chamada recursiva ordena (i, dir ).
86
Quicksort Parcial
Chaves iniciais: 1 2 3 4 5 A D E N O A A R D D E R N N R O O O O R R D R E E N N A O
Considere k = 3 e D o piv para gerar as linhas 2 e 3. A partio esquerda contm dois itens e a partio direita contm 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.
87
Quicksort Parcial
private static void ordena(Item v [ ] , int esq, int dir , int k) { LimiteParticoes p = particao ( v , esq, dir ) ; i f (p. j esq >= k 1) { i f (esq < p. j ) ordena ( v , esq, p. j , k ) ; return ; } i f (esq < p. j ) ordena ( v , esq, p. j , k ) ; i f (p. i < dir ) ordena ( v , p. i , dir , k ) ; } public static void quicksortParcial (Item v [ ] , int n, int k) { ordena ( v , 1 , n, k ) ; }
88
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).
89
Comparao entre os Mtodos de Ordenao Parcial

n, k n : 10 n : 10
1 1
Seleo
0 1
Quicksort 2,5 2,8 3 2,4 1,7 3,7 2,9 1,3 1 2,4 2,2 2,1 1 1 1 3,9 2,7 3,2 2,2 1 1 1 3,4 2,6 2,6 3,1 1,1 1 1 1
Insero 1 1 1,1 1 1 1,4 1 1 3,9 1,1 1 1 1,1 33,1 1,2 1 1 1 5 1,1 1 1 1 1
Insero2 1,2 1,1 1,4 1,2 1,1 1,6 1,2 1,4 4,2 1,1 1 1,1 1,3 43,3 1,3 1 1,1 1,1 6,4 1,1 1,1 1,1 1,1 1,2
Heapsort 1,7 2,8 4,5 3 2,3 9,1 6,4 1,9 1,6 5,3 4,9 4,8 2,3 1,7 1,9 8,1 7,3 6,6 5,7 1,9 1,7 1,8 7,4 6,7 6,8 6,6 2,6 2,2 1,2 1,7
k : 10 k : 10
1 1,2 1 1,9 3 1 4,6 11,2 15,1 1 5,9 67 304 1445 1 6,6 83,1 690 1 8,6 82,1
n : 102 k : 100 n : 10 n : 10
2 2
k : 10 k : 10
1 2
n : 103 k : 100 n : 10 n : 10 n : 10 n : 10 n : 10 n : 10 n : 10 n : 10
3 3 3 5 5 5
k : 10 k : 10 k : 10 k : 10 k : 10 k : 10 k : 10 k : 10
1 2 3 0 1 2
n : 105 k : 103
5 5 4 5
n : 106 k : 100 n : 10 n : 10 n : 10 n : 10 n : 10 n : 10
6 6 6 6 6 6
k : 10 k : 10 k : 10 k : 10 k : 10 k : 10
1 2 3 4 5 6
n : 107 k : 100 n : 10 n : 10 n : 10 n : 10 n : 10 n : 10
7 7 7 7 7 7
k : 10 k : 10 k : 10 k : 10 k : 10 k : 10
1 2 3 4 5 6
n : 107 k : 107
90
Comparao entre os Mtodos de Ordenao Parcial

1. Para valores de k at 1.000, o mtodo da InseroParcial imbatvel. 2. O Quicksort Parcial nunca car muito longe da InseroParcial. 3. Na medida em que o k cresce,o Quicksort Parcial 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 Heapsort Parcial tem comportamento parecido com o do Quicksort Parcial. 7. No entano, o Heapsort Parcial mais lento.
91
Ordenao Externa
A ordenao externa consiste em ordenar arquivos de tamanho maior que a memria interna disponvel. Os mtodos de ordenao externa so muito diferentes dos de ordenao interna. Na ordenao externa os algoritmos devem diminuir o nmero de acesso as unidades de memria externa. Nas memrias externas, os dados so armazenados como um arquivo seqencial. Apenas um registro pode ser acessado em um dado momento. Esta uma restrio forte se comparada com as possibilidades de acesso em um vetor. Logo, os mtodos de ordenao interna so inadequados para ordenao externa. Tcnicas de ordenao completamente diferentes devem ser utilizadas.
92
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 transferncia de dados entre a memria interna e externa. 3. Existem restries severas de acesso aos dados. 4. O desenvolvimento de mtodos de ordenao externa muito dependente do estado atual da tecnologia. 5. A variedade de tipos de unidades de memria externa torna os mtodos dependentes de vrios parmetros. 6. Assim, apenas mtodos gerais sero apresentados.
93
Ordenao Externa
O mtodo mais importante o de ordenao por intercalao. Intercalar signica combinar dois ou mais blocos ordenados em um nico 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 interna disponvel. 2. Ordene cada bloco na memria interna. 3. Intercale os blocos ordenados, fazendo vrias passadas sobre o arquivo. 4. A cada passada so criados blocos ordenados cada vez maiores, at que todo o arquivo esteja ordenado.
94
Ordenao Externa
Os algoritmos para ordenao externa devem reduzir o nmero de passadas sobre o arquivo. Uma boa medida de complexidade de um algoritmo de ordenao por intercalao o nmero de vezes que um item lido ou escrito na memria auxiliar. Os bons mtodos de ordenao geralmente envolvem no total menos do que dez passadas sobre o arquivo.
95
Intercalao Balanceada de Vrios Caminhos

Considere um arquivo armazenado em uma ta de entrada:
INTERCALACAOBALANCEADA
Objetivo: Ordenar os 22 registros e coloc-los em uma ta de sada. Os registros so lidos um aps o outro. Considere uma memria interna com capacidade para para trs registros. Considere que esteja disponvel seis unidades de ta magntica.
96

Fase de criao dos blocos ordenados:
ta 1: ta 2: ta 3: INT CER AAL ACO ABL ACN ADE A
97

Fase de intercalao - Primeira passada: 1. O primeiro registro de cada ta lido. 2. Retire o registro contendo a menor chave. 3. Armazene-o em uma ta de sada. 4. Leia um novo registro da ta de onde o registro retirado proveniente. 5. Ao ler o terceiro registro de um dos blocos, sua ta ca inativa. 6. A ta reativada quando o terceiro registro das outras tas forem lidos. 7. Neste instante um bloco de nove registros ordenados foi formado na ta de sada. 8. Repita o processo para os blocos restantes. Resultado da primeira passada da segunda etapa:
ta 4: ta 5: ta 6: AACEILNRT AAABCCLNO AADE
98

Quantas passadas so necessrias para ordenar um arquivo de tamanho 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 tas utilizadas em cada passada. Assim: n . m No exemplo acima, n=22, m=3 e f=3 temos: 22 P (n) = log3 = 2. 3 P (n) = logf
99

No exemplo foram utilizadas 2f tas para uma intercalao-de-f -caminhos. possvel usar apenas f + 1 tas: Encaminhe todos os blocos para uma nica ta. Redistribuia estes blocos entre as tas de onde eles foram lidos. O custo envolvido uma passada a mais em cada intercalao. No caso do exemplo de 22 registros, apenas quatro tas seriam sucientes: A intercalao dos blocos a partir das tas 1, 2 e 3 seria toda dirigida para a ta 4. Ao nal, o segundo e o terceiro blocos ordenados de nove registros seriam transferidos de volta para as tas 1 e 2.
100
Implementao por meio de Seleo por Substituio

A implementao do mtodo de intercalao balanceada pode ser realizada utilizando las de prioridades. As duas fases do mtodo podem ser implementadas de forma eciente e elegante. Operaes bsicas para formar blocos ordenados: Obter o menor dentre os registros presentes na memria interna. Substitu-lo pelo prximo registro da ta de entrada. Estrutura ideal para implementar as operaes: heap. Operao de substituio: Retirar o menor item da la de prioridades. Colocar um novo item no seu lugar. Reconstituir a propriedade do heap.
101

Algoritmo: 1. Inserir m elementos do arquivo na la de prioridades. 2. Substituir o menor item da la de prioridades pelo prximo item do arquivo. 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 la de prioridades ento: O bloco corrente encerrado. Um novo bloco ordenado iniciado.
102

Primeira passada sobre o arquivo exemplo:
Entra E R C A L A C A O B A L A N C E A D A 1 I N R T A* C* E* L* A A B C L O A* A* C* E* N* A A D 2 N E* E* E* E* E* A A A O O O O A* N* N* N* N* D D D 3 T T T C* C* L* L* C C C C A* A* A* A* C* E* A A A
Os asteriscos indicam quais chaves pertencem a blocos diferentes.
103

Tamanho dos blocos produzidas para chaves randmicas: Os blocos ordenados so cerca de duas vezes o tamanho dos blocos criados pela ordenao interna. Isso pode salvar uma passada na fase de intercalao. Se houver alguma ordem nas chaves, os blocos ordenados podem ser ainda maiores. Se nenhuma chave possui mais do que m chaves maiores do que ela, o arquivo ordenado em um passo. Exemplo para as chaves RAPAZ:
Entra A Z 1 A A P R Z 2 R R R Z 3 P P Z
104

Fase de intercalao dos blocos ordenados obtidos na primeira fase: Operao bsica: obter o menor item dentre os ainda no retirados dos f blocos a serem intercalados. Algoritmo: Monte uma la de prioridades de tamanho f . A partir de cada uma das f entradas: Substitua o item no topo da la de prioridades pelo prximo item do mesmo bloco do item que est sendo substitudo. Imprima em outra ta o elemento substitudo.
105

Exemplo:
Entra A L E R N T 1 A A C E I L N R T 2 C C L L L N R T 3 I I I I R R
Para f pequeno no vantajoso utilizar seleo por substituio para intercalar blocos: Obtm-se o menor item fazendo f 1 comparaes. Quando f 8 ou mais, o mtodo adequado: Obtm-se o menor item fazendo log2 f comparaes.
106
Consideraes Prticas
As operaes de entrada e sada de dados devem ser implementadas ecientemente. Deve-se procurar realizar a leitura, a escrita e o processamento interno dos dados de forma simultnea. Os computadores de maior porte possuem uma ou mais unidades independentes para processamento de entrada e sada. Assim, pode-se realizar processamento e operaes de E/S simultaneamente.
107
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 de armazenamento: 1. Uma para uso do processador central 2. Outra para uso do processador de entrada ou sada. Para entrada, o processador central usa uma das duas reas enquanto a unidade de entrada est preenchendo a outra rea. Depois a utilizao das reas invertida entre o processador de entrada e o processador central. Para sada, a mesma tcnica utilizada.
108
Consideraes Prticas
Problemas com a tcnica: Apenas metade da memria disponvel utilizada. Isso pode levar a uma inecincia 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 -caminhos se esvaziando aproximadamente ao mesmo tempo.
109
Consideraes Prticas
Soluo para os problemas: Tcnica de previso: Requer a utilizao de uma nica rea extra de armazenamento durante a intercalao. Superpe a entrada da prxima rea que precisa ser preenchida com a parte de processamento interno do algoritmo. fcil saber qual rea car vazia primeiro. Basta olhar para o ltimo registro de cada rea. A rea cujo ltimo registro o menor, ser a primeira a se esvaziar.
110
Consideraes Prticas
Escolha da ordem de intercalao f : Para tas magnticas: f deve ser igual ao nmero de unidades de ta disponveis menos um. A fase de intercalao usa f tas de entrada e uma ta de sada. O nmero de tas de entrada deve ser no mnimo dois. Para discos magnticos: O mesmo raciocnio acima vlido. O acesso seqencial mais eciente. Sedegwick (1988) sugere considerar f grande o suciente para completar a ordenao em poucos passos. Porm, a melhor escolha para f depende de vrios parmetros relacionados com o sistema de computao disponvel.
111
Intercalao Polifsica
Problema com a intercalao balanceada de vrios caminhos: Necessita de um grande nmero de tas. Faz vrias leituras e escritas entre as tas envolvidas. Para uma intercalao balanceada de f caminhos so necessrias 2f tas. Alternativamente, pode-se copiar o arquivo quase todo de uma nica ta de sada para f tas de entrada. Isso reduz o nmero de tas para f + 1. Porm, h um custo de uma cpia adicional do arquivo. Soluo: Intercalao polifsica.
112
Os blocos ordenados so distribudos de forma desigual entre as tas disponveis. Uma ta deixada livre. Em seguida, a intercalao de blocos ordenados executada at que uma das tas esvazie. Neste ponto, uma das tas de sada troca de papel com a ta de entrada.
113
Exemplo: Blocos ordenados obtidos por meio de seleo por substituio:
ta 1: ta 2: ta 3: INRT AACEN ACEL AAD AABCLO
Congurao aps uma intercalao-de-2-caminhos das tas 1 e 2 para a ta 3:

ta 1: ta 2: ta 3: AACEINNRT AAACDEL AABCLO
114
Exemplo: Depois da intercalao-de-2-caminhos das tas 1 e 3 para a ta 2:
ta 1: ta 2: ta 3: AAAABCCEILNNORT AAACDEL
Finalmente:
ta 1: ta 2: ta 3: AAAAAAABCCCDEEILLNNORT
A intercalao realizada em muitas fases. As fases no envolvem todos os blocos. Nenhuma cpia direta entre tas realizada.
115
A implementao da intercalao polifsica simples. A parte mais delicada est na distribuio inicial dos blocos ordenados entre as tas. Distribuio dos blocos nas diversas etapas do exemplo:
ta 1 3 1 0 1 ta 2 2 0 1 0 ta 3 0 2 1 0 Total 5 3 2 1
116
Anlise: A anlise da intercalao polifsica complicada. O que se sabe que ela ligeiramente melhor do que a intercalao balanceada para valores pequenos de f . Para valores de f > 8, a intercalao balanceada pode ser mais rpida.
117
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 memria secundria de acesso randmico. O algoritmo utiliza somente O(log n) unidades de memria interna e no necessria nenhuma memria externa adicional.
118
Quicksort Externo
So necessrios quatro mtodos adicionais para a classe MeuItem (transparncia 6). O mtodo toString especica como o objeto formatado. Os mtodos leArq e gravaArq so utilizados para ler e gravar um objeto da classe MeuItem em um arquivo de acesso aleatrio. O mtodo tamanho retorna o tamanho em bytes de um objeto da classe MeuItem .
public String toString ( ) { return " " + this .chave ; } public void gravaArq (RandomAccessFile arq) throws IOException { arq . writeInt ( this .chave) ; } public void leArq (RandomAccessFile arq) throws IOException { this .chave = arq . readInt ( ) ; } public static int tamanho ( ) { return 4 ; / 4 bytes / }
119
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 . . . Rj 2 Rj 1 {Rj , . . . , Rn }, 2. chamar recursivamente o algoritmo em cada um dos subarquivos A1 = { R 1 , . . . , R i } e A2 = { R j , . . . , R n } .
120
Quicksort Externo
Para o partionamento utilizanda uma rea de armazenamento na memria 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 o processamento 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.
121
Quicksort Externo
i Li Ls j rea Linf Lsup i Li Ls j 4 rea Linf Lsup
a)
5 3 10 6 1 7 4 Ei i Li Ls Es j 4 5
b)
5 3 10 6 1 7 4 Ei i Li Ls Es j
c)
5 3 10 6 1 7 4 Ei i Li Ls Es j
d)
5 3 10 6 1 7 4 Ei i Li Ls Es j
4 5 7
e)
5 3 10 6 1 7 7 Ei i Li Ls Es j
4 5
f)
5 3 10 6 1 7 7 Ei i Li Ls 3 3 10 6 1 7 7 Ei Li Ls Es j Es j
3 4 5
g)
3 3 10 6 1 7 7 Ei i Li Ls Es j
4 5
h)
4 5
i 4 5 3 7
i)
3 1 10 6 1 7 7 Ei i Li Ls Es j
j)
3 1 10 6 1 7 7 Ei i Ls Li Es j
4 5
k)
3 1 10 6 1 10 7 Ei i Ls Li Es j
4 5
l)
3 1 10 6 1 10 7 Ei i Ls Li Es j
4 5 6
m) 3 1 10 6 6 10 7
Ei Es
4 5
n)
3 1 4 5 6 10 7 Es Ei
122
Quicksort Externo
O programa a seguir apresenta a classe QuicksortExterno , na qual so denidos as estruturas de dados e os mtodos utilizados pelo algoritmo Quicksort Externo.
package cap4.ordenacaoexterna; import cap3. arranjo .Area; import cap4.MeuItem; import java . io . ; public class QuicksortExterno { private static class LimiteParticoes { int i ; int j ; } private RandomAccessFile arqLi ; private RandomAccessFile arqEi ; private RandomAccessFile arqLEs; private boolean private MeuItem private Area private int ondeLer; ultLido ; area; tamArea;
/ / Mtodos utilizados pelo mtodo particao do quicksort externo private int leSup ( int ls ) throws IOException private int leInf ( int l i ) throws IOException private int inserirArea ( ) throws Exception / / Continua na prxima transparncia
123
Quicksort Externo
private int escreveMax ( int es) throws Exception private int escreveMin ( int ei ) throws IOException private int retiraMax ( ) throws Exception private int retiraMin ( ) throws Exception private LimiteParticoes particao ( int esq, int dir ) throws Exception public QuicksortExterno ( String nomeArq, int tamArea) throws FileNotFoundException { this . arqLi this . arqEi = new RandomAccessFile (nomeArq, "rws" ) ; = new RandomAccessFile (nomeArq, "rws" ) ;
this .arqLEs = new RandomAccessFile (nomeArq, "rws" ) ; this .tamArea = tamArea; } public void quicksortExterno ( int esq, int dir ) throws Exception public void fechaArquivos ( ) throws Exception { this . arqEi . close ( ) ; this . arqLi . close ( ) ; this .arqLEs. close ( ) ; } }
124
Quicksort Externo
public void quicksortExterno ( int esq, int dir ) throws Exception { i f ( dir esq < 1) return ; LimiteParticoes p = particao (esq, dir ) ; i f (p. i esq < dir p. j ) { / / ordene primeiro o subarquivo menor quicksortExterno (esq, p. i ) ; quicksortExterno (p. j , dir ) ; } else { quicksortExterno (p. j , dir ) ; quicksortExterno (esq, p. i ) ; } }
125
Quicksort Externo
Mtodos auxiliares utilizados pelo mtodo particao :
private int leSup ( int ls ) throws IOException { this . ultLido = new MeuItem ( 0 ) ; arqLEs.seek ( ( ls 1) MeuItem.tamanho ( ) ) ; this . ultLido . leArq (arqLEs ) ; ondeLer = false ; return ls ; } private int leInf ( int l i ) throws IOException { this . ultLido = new MeuItem ( 0 ) ; this . ultLido . leArq ( arqLi ) ; ondeLer = true ; return ++ l i ; } private int inserirArea ( ) throws Exception { area. insereItem ( this . ultLido ) ; return area.obterNumCelOcupadas ( ) ; }
126
Quicksort Externo
Mtodos auxiliares utilizados pelo mtodo particao :
private int escreveMax ( int es) throws Exception { arqLEs.seek ( ( es 1) MeuItem.tamanho ( ) ) ; this . ultLido .gravaArq (arqLEs) ; return es; } private int escreveMin ( int ei ) throws IOException { this . ultLido .gravaArq ( arqEi ) ; return ++ei ; } private int retiraMax ( ) throws Exception { this . ultLido = (MeuItem) area. retiraUltimo ( ) ; return area.obterNumCelOcupadas ( ) ; } private int retiraMin ( ) throws Exception { this . ultLido = (MeuItem) area. retiraPrimeiro ( ) ; return area.obterNumCelOcupadas ( ) ; }
127
Quicksort Externo
Mtodo Partio:
private LimiteParticoes particao ( int esq, int dir ) throws Exception { int ls = dir , es = dir , l i = esq, ei = esq, nrArea = 0; MeuItem l i n f = new MeuItem ( Integer .MIN_VALUE) ; / / MeuItem lsup = new MeuItem ( Integer .MAX_VALUE) ; / / this .ondeLer = true ; LimiteParticoes p = new LimiteParticoes ( ) ; this .area = new Area ( this .tamArea) ; arqLi .seek ( ( l i 1) MeuItem.tamanho ( ) ) ; arqEi .seek ( ( ei 1) MeuItem.tamanho ( ) ) ; p. i = esq 1; p. j = dir + 1; while ( ls >= l i ) { i f ( nrArea < this .tamArea 1) { i f (ondeLer) ls = this .leSup ( ls ) ; else l i = leInf ( l i ) ; nrArea = inserirArea ( ) ; } else { i f ( ls == es) ls = leSup ( ls ) ; else i f ( l i == ei ) l i = leInf ( l i ) ; else i f (ondeLer) ls = leSup ( ls ) ; else l i = leInf ( l i ) ; / / Continua na prxima transparncia
128
Quicksort Externo
Mtodo Partio:
i f ( ultLido .compara ( lsup ) > 0) { p. j = es ; es = escreveMax (es) ; } else i f ( ultLido .compara ( l i n f ) < 0) { p. i = ei ; ei = escreveMin ( ei ) ; } else { nrArea = inserirArea ( ) ; i f ( ei esq < dir es ) { nrArea = retiraMin ( ) ; l i n f = this . ultLido ; ei=escreveMin ( ei ) ; } else { nrArea = retiraMax ( ) ; lsup = this . ultLido ; es=escreveMax (es) ; } } } } while ( ei <= es ) { nrArea = retiraMin ( ) ; ei = escreveMin ( ei ) ; } return p; }
129
Quicksort Externo
Programa teste:
package cap4; import java . io .RandomAccessFile; import cap4.ordenacaoexterna. QuicksortExterno ; / / vide transparncia 122 public class TestaQuicksortExterno { public static void main ( String [ ] args ) { try { RandomAccessFile arq = new RandomAccessFile ( "qe. dat" , "rwd" ) ; MeuItem item = new MeuItem ( 5 ) ; item .gravaArq ( arq ) ; item = new MeuItem ( 3 ) ; item .gravaArq ( arq ) ; item = new MeuItem ( 1 0 ) ; item .gravaArq ( arq ) ; item = new MeuItem ( 6 ) ; item .gravaArq ( arq ) ; item = new MeuItem ( 1 ) ; item .gravaArq ( arq ) ; item = new MeuItem ( 7 ) ; item .gravaArq ( arq ) ; item = new MeuItem ( 4 ) ; item .gravaArq ( arq ) ; arq . close ( ) ; QuicksortExterno quicksortExterno=new QuicksortExterno( "qe. dat" ,3); quicksortExterno . quicksortExterno ( 1 , 7 ) ; quicksortExterno . fechaArquivos ( ) ; arq = new RandomAccessFile ( "qe. dat" , " r " ) ; item . leArq ( arq ) ; while ( arq . getFilePointer ( ) < arq . length ( ) ) { System. out . println ( "Registro=" + item . toString ( ) ) ; item . leArq ( arq ) ; } System. out . println ( "Registro=" + item . toString ( ) ) ; arq . close ( ) ; } catch ( Exception e ) { System. out . println (e.getMessage ( ) ) ; } } }
130
Quicksort Externo
Anlise: Seja n o nmero de registros a serem ordenados. Seja e b o tamanho do bloco de leitura ou gravao do Sistema operacional. ) Melhor caso: O( n b Por exemplo, ocorre quando o arquivo de entrada j est ordenado. Pior caso:
n2 O( TamArea )
ocorre quando um dos arquivos retornados pelo procedimento Particao tem o maior tamanho possvel e o outro vazio. A medida que n cresce, a probabilidade de ocorrncia do pior caso tende a zero.
n log ( )) Caso Mdio: O( n b TamArea
o que tem amaior probabilidade de ocorrer.

Cap 4

Enviado por

Dados do documento

Título original

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

Cap 4

Enviado por

Direitos autorais:

Formatos disponíveis

Ordenao

ltima alterao: 10 de Outubro de 2006

Projeto de Algoritmos Cap.4 Ordenao

Projeto de Algoritmos Cap.4 Ordenao

Introduo - Conceitos Bsicos

Projeto de Algoritmos Cap.4 Ordenao

Introduo - Conceitos Bsicos

Projeto de Algoritmos Cap.4 Ordenao

Introduo - Conceitos Bsicos

Projeto de Algoritmos Cap.4 Ordenao

Introduo - Conceitos Bsicos

Projeto de Algoritmos Cap.4 Ordenao

Introduo - Conceitos Bsicos

Projeto de Algoritmos Cap.4 Ordenao

Introduo - Conceitos Bsicos

Projeto de Algoritmos Cap.4 Ordenao

Introduo - Conceitos Bsicos

Projeto de Algoritmos Cap.4 Ordenao

Introduo - Conceitos Bsicos

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.1

Ordenao por Seleo

As chaves em negrito sofreram uma troca entre si.

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.1

Ordenao por Seleo

Anlise Comparaes entre chaves e movimentaes de registros: C (n) =

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.1

Ordenao por Seleo

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.2

Ordenao por Insero

As chaves em negrito representam a seqncia destino.

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.2

Ordenao por Insero

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.2

Ordenao por Insero

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.2

Ordenao por Insero

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.2

Ordenao por Insero

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.2

Ordenao por Insero

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.3

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.3

Quando h = 1 Shellsort corresponde ao algoritmo de insero.

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.3

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.3

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.3

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.3

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

O piv mostrado em negrito.

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.4

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.5

Projeto de Algoritmos Cap.4 Ordenao Seo 4.1.5