Projetos de Algoritmos Com Implementação em Pascal e C (Nivio Ziviani, 4ed)

Maria, esposa e companheira, Patricia e Paula, nossas filhas.
Dados Internacionais de Catalogao na Publicao (CIP) ( C i m a r a B r a s i l e i r a do L i v r o , S P, B r a s i l ) Ziviani, Nivio Projeto de algoritmos c o m
implementaes
Pascal C / Nivio Ziviani. -- 4. ad. -- So Paulo : Pioneira, 1999. -- (Pioneira Informtica)
Bibliografia.
ISBN 85-221-
1. Algoritmos 2. C (Linguagem de programao para computadores) 3. Dados - Estruturas (Cincia da computao). 4. PASCAL (Linguagem de programao para computadores) I. Titulo. II. Srie
98-5286
CDD-005.1
ndices para catlogo sistemtico: 1. Algoritmos : Computadores : Programao : Processamento de dados 005.1
Projeto de Algoritmos
Com Implementaes
em Pascal e C
PIONEIRA INFORMTICA
Coordenador:
Routo Terada
Conselho Diretor: Lvio Giosa Ulf Gregor Baranow
Projeto de Algoritmos
Com Implementaes em Pascal e C
Nivio Ziviani, Ph.D.

Professor Titular
Universidade Federal de Minas Gerais Departmento de Cincia d Computao
44 Edio
Este livro foi composto, revisado. paginado pelo autor. A Pioneira, a partir dos fotolitos, imprimiu-o.
Capa do Riccardo Fanucchi
Nenhuma parte deste livro poder ser reproduzida sejam quais forem os meios empregados sem a permisso, por escrito, da Editora. Aos infratores se aplicam as sanes previstas nos artigos 102, 104, 106 e 107 da Lei n 9.610 de 19 de fevereiro de 1998.
Copyright 1999 Todos os direitos reservados por ENIO MATHEUS GUAllELLI & CIA. LTDA. 02515-050 Praa Dirceu de Lima, 313 Telefone: (011) 858-3199 Fax: (011) 858-0443 So Paulo SP e-mail: pioneira@editorapioneira.com.br Impresso no Brasil Printed in
Brazil
Prefcio
Este livro apresenta uma introduo ao estudo de algoritmos computacionais. As principais tcnicas de projeto de algoritmos so ensinadas atravs da explicao detalhada de algoritmos e estruturas de dados para o uso eficiente do computador. Estas explicaes so mantidas o mais simples possvel, mas sem perder a profundidade e o rigor matemtico. O contedo dirigido principalmente para ser utilizado como livro-texto em cursos sobre algoritmos e estruturas de dados. Pelo fato de apresentar muitas implementaes de algoritmos prticos o texto igualmente til para profissionais engajados no desenvolvimento de sistemas de computao e de programas de aplicao. Os algoritmos so apresentados atravs de refinamentos sucessivos at o nvel de uma implementao na linguagem Pascal, o que permite que qualquer pessoa com um mnimo de experincia em programao possa ler o cdigo. Contedo O livro apresenta as principais tcnicas utilizadas para a implementao de estruturas de dados bsicas e de algoritmos para ordenao e pesquisa em memria primria e memria secundria. Os tpicos esto agrupados em cinco captulos, cada um com o seguinte contedo: (i) conceito de algoritmo, estrutura de dados e tipo abstrato de dados, tcnicas de anlise de desempenho de algoritmos, linguagem Pascal; (ii) estruturas de dados bsicas: listas lineares, pilhas e filas; (iii) mtodos de ordenao em memria primria: por insero, por seleo, shellsort, quicksort e heapsort, e em memria secundria: intercalao balanceada; (iv) mtodos de pesquisa em memria primria: pesquisa seqencial, pesquisa binria, rvores de pesquisa e hashing; (v) mtodos de pesquisa em memria secundria: seqencial indexado e rvores B. O estudo do comportamento dos algoritmos tem um papel decisivo no projeto de algoritmos eficientes. Por isso, so apresentadas informaes sobre as caractersticas de desempenho de cada algoritmo apresentado. Entretanto, a parte matemtica utilizada para apresentar os resultados analticos
autocontida e exige muito pouco conhecimento matemtico prvio para ser entendida. A linguagem de programao utilizada para apresentao do refinamento final dos algoritmos apresentados a linguagem Pascal. A vantagem de se usar a linguagem Pascal que os programas se tornam fceis de ser lidos e de ser traduzidos para outras linguagens. Alm disso, todos os algoritmos implementados na linguagem Pascal so tambm implementados na linguagem C. Todo programa Pascal de um captulo tem um programa C correspondente no apndice. Ao Leitor O material apresentado adequado para ser utilizado como livro texto em cursos de graduao em Cincia da Computao e em cursos de extenso para formao de Programadores na rea de Algoritmos e Estruturas de Dados. E recomendvel que o estudante j tenha tido um curso de programao (ou experincia equivalente) em uma linguagem de alto nvel, tal como Pascal ou C, assim como conhecimentos de utilizao de sistemas de computao. Verses anteriores deste livro foram utilizadas na Universidade Federal de Minas Gerais. A disciplina Algoritmos e Estruturas de Dados II do Curso de Bacharelado em Cincia da Computao, com carga horria de 60 horas e um semestre de durao, possui a seguinte ementa: tipos abstratos de dados; introduo a anlise de algoritmos; listas lineares, pilhas e filas; ordenao: seleo direta, insero direta, shellsort, quicksort, heapsort, mergesort e radixsort; pesquisa em tabelas: seqencial, binria e transformao de chave ( hashing); rvores de pesquisa: sem balanceamento, com balanceadamento, tries e patricia. Os tpicos ordenao externa, pesquisa em memria secundria e um estudo mais elaborado de anlise de algoritmos fazem parte da disciplina Algoritmos e Estruturas de Dados III, do mesmo Curso. Ao final de cada captulo so includos exerccios. Alguns exerccios so do tipo questes curtas, para testar os conhecimentos bsicos sobre o material apresentado. Outros exerccios so do tipo questes mais elaboradas, podendo exigir do leitor um trabalho de vrios dias, devendo ser realizado em casa ou em laboratrio. Assim, os exerccios propostos devem ser utilizados em testes e trabalhos prticos para avaliao da aprendizagem. Este texto pode tambm ser utilizado como manual para programadores que j tenham familiaridade com o assunto, pois so apresentadas implementaes de algoritmos de utilidade geral. Os algoritmos propostos so completamente implementados nas linguagens Pascal e C e as operaes envolvidas so descritas atravs da apresentao de exemplos de execuo.
Agradecimentos Uma verso inicial deste texto foi escrita para ser usada no Curso Estruturas de Dados e Algoritmos da I Escola Brasileiro-Argentina de Informtica em fevereiro de 1986, publicada pela Editora da Unicamp sob o ttulo Projeto de Algoritmos e Estruturas de Dados. Gostaria de agradecer a Carlos Jos Pereira de Lucena e Routo Terada por lembrarem do meu nome para participar da I Escola Brasileiro-Argentina de Informtica, o que motivou o desenvolvimento da semente deste texto. Gostaria de agradecer a Cilio Rosa Ziviani, Cleber Hostalcio de Melo, Jos Monteiro da Mata, Lilia Tavares Mascarenhas, Luiz Carlos de Abreu Albuquerque, Regina Helena Bastos Cabral e Rosngela Fernandes pelas contribuies para a primeira verso do texto. Muitos amigos e colegas me auxiliaram na. elaborao deste livro. Agradeo a todos pela ajuda e pelas crticas construtivas. O Departamento de Cincia da Computao da Universidade Federal de Minas Gerais tem proporcionado um excelente ambiente de trabalho. Os meus alunos de extenso, graduao, especializao e ps-graduao, especialmente os alunos das disciplinas Tcnicas de Programao, Algoritmos e Estruturas de Dados e Projeto e Anlise de Algoritmos contriburam significativamente. Vrios erros foram corrigidos como conseqncia da leitura cuidadosa de vrias pessoas, em especial Alberto Henrique Frade Laender, Eduardo Fernandes Barbosa, Jos Nagib Cotrim Arabe, Mrcio Luiz Bunte de Carvalho, Osvaldo Srgio Farhat de Carvalho, Roberto Mrcio Ferreira de Souza e Virglio Augusto Fernandes Almeida, aos quais gostaria de registrar meus agradecimentos. Gostaria de agradecer a Cristina Duarte Murta pela leitura crtica de todo o texto, pelos testes dos programas Pascal e pela execuo dos programas que permitiu o estudo comparativo dos algoritmos de ordenao. A verso C dos algoritmos existe graas ao trabalho paciente de traduo dos programas Pascal conduzido -por Maurcio Antnio de Castro Lima e Wagner Toledo Corra, realizado com o auxlio do programa p2c para traduo automtica de programas em Pascal para programas em C, desenvolvido por Dave Gillespie, do California Institute of Technology, EUA. O livro foi formatado com LATEX, um conjunto de macros para o TEX. Um agradecimento todo especial para Mrcio Luiz Bunte de Carvalho pela imensa ajuda durante todo o trabalho de formatao, incluindo a criao de ambientes especiais em LATEX para este texto, sendo que esta etapa contou tambm com a ajuda de Murilo Silva Monteiro.
Nivio Ziviani Belo Horizonte Dezembro de 1992 Endereo Internet: nivio@dcc.ufmg.br
Sumrio
Prefcio Lista de Figuras Lista de Tabelas Lista de Programas v xiii xv xvii
1 Introduo 1 1.1 Algoritmos, Estruturas de Dados e Programas ...................................... 1 1.2 Tipos de Dados e Tipos Abstratos de Dados ......................................... 2 1.3 Medida do Tempo de Execuo de um Programa ................................. 3 1.3.1 Comportamento Assinttico de Funes ................................. 11 1.3.2 Classes de Comportamento Assinttico ...................................14 1.4 Tcnicas de Anlise de Algoritmos ...................................................... 18 1.5 Pascal ...................................................................................................... 25 Notas Bibliogrficas .................................................................................... 30 Exerccios ..................................................................................................... 30 2 Estruturas de Dados Bsicas 35 2.1 Listas Lineares ....................................................................................... 35 2.1.1 Implementao de Listas Atravs de Arranjos ........................ 37 2.1.2 Implementao de Listas Atravs de Apontadores ................. 38 2.2 Pilhas .......................................................................................................47 2.2.1 Implementao de Pilhas Atravs de Arranjos ........................48 2.2.2 Implementao de Pilhas Atravs de Apontadores ................. 49 2.3 Filas .........................................................................................................55 2.3.1 Implementao de Filas Atravs de Arranjos .......................... 56 2.3.2 Implementao de Filas Atravs de Apontadores ................... 58 Notas Bibliogrficas .................................................................................... 58 Exerccios ..................................................................................................... 58
SUMRIO 3 Ordenao 69 3.1 Ordenao Interna ................................................................................ 71 3.1.1 Ordenao por Seleo ............................................................. 72 3.1.2 Ordenao por Insero ............................................................ 73 3.1.3 Shellsort ..................................................................................... 76 3.1.4 Quicksort .................................................................................... 78 3.1.5 Heapsort ..................................................................................... 81 3.1.6 Comparao Entre os Mtodos ................................................. 87 3.2 Ordenao Externa ............................................................................... 91 3.2.1 Intercalao Balanceada de Vrios Caminhos ........................ 92 3.2.2 Implementao Atravs de Seleo por Substituio ............. 94 3.2.3 Consideraes Prticas ............................................................. 97 Notas Bibliogrficas ................................................................................... 99 Exerccios .................................................................................................... 99 4 Pesquisa em Memria Primria 107 4.1 Pesquisa Seqencial ........................................................................... 108 4.2 Pesquisa Binria ................................................................................. 110 4.3 Arvores de Pesquisa ........................................................................... 111 4.3.1 Arvores Binrias de Pesquisa Sem Balanceamento .............. 112 4.3.2 Arvores Binrias de Pesquisa Com Balanceamento ............. 117 4.4 Pesquisa Digital ................................................................................... 127 4.5 Transformao de Chave (Hashing) ................................................... 135 4.5.1 Funes de Transformao ..................................................... 136 4.5.2 Listas Encadeadas ................................................................... 137 4.5.3 Open Addressing ..................................................................... 140 Notas Bibliogrficas ................................................................................. 143 Exerccios .................................................................................................. 144 5 Pesquisa em Memria Secundria 155 5.1 Modelo de Computao para Memria Secundria .......................... 157 5.2 Acesso Seqencial Indexado .............................................................. 163 5.3 Arvores de Pesquisa ............................................................................ 169 5.3.1 Arvores B ................................................................................. 170 5.3.2 rvores B* ............................................................................... 182 5.3.3 Acesso Concorrente em Arvores B* ...................................... 184 5.3.4 Consideraes Prticas ........................................................... 189 Notas Bibliogrficas .................................................................................. 192 Exerccios ................................................................................................... 193 A Programas C do Captulo 1 B Programas C do Captulo 2 197 203
SUMRIO C D E F G Programas C do Captulo 3 Programas C do Captulo 4 Programas C do Captulo 5 Caracteres ASCII Referncias Bibliogrficas 217 223 243 253 255 261
ndice
Lista de Figuras
1.1 Partio de A em dois subconjuntos ....................................................... 9 1.2 Dominao assinttica de (An) sobre g(n) ......................................... 12 1.3 Operaes com a notao O .................................................................. 13 1.4 Problema do caixeiro viajante ...............................................................18 1.5 Estrutura de um programa Pascal ......................................................... 25 1.6 Registro do tipo pessoa ......................................................................... 28 1.7 Lista encadeada ...................................................................................... 30 2.1 Implementao de uma lista atravs de arranjo ...................................37 2.2 Implementao de uma lista atravs de apontadores .......................... 40 2.3 Classificao dos alunos por NotaFinal ............................................... 43 2.4 Lista de aprovados por Curso ............................................................... 44 2.5 Implementao de uma pilha atravs de arranjo .............................. 48 ............................... 2.6 Implementao de uma pilha atravs de apontadores ......................... 51 2.7 Implementao circular para filas ........................................................ 56 2.8 Implementao de uma fila atravs de apontadores ............................ 58 2.9 Lista circular duplamente encadeada ................................................... 61 2.10 Exemplo de Matriz Esparsa ................................................................ 62 3.1 Exemplo de ordenao por seleo ...................................................... 72 3.2 Exemplo de ordenao por insero ..................................................... 74 3.3 Exemplo de ordenao usando Shellsort ..............................................76 3.4 Partio do vetor .................................................................................... 79 3.5 Exemplo de ordenao usando Quicksort ............................................ 80 3.6 Arvore binria completa ........................................................................ 84 3.7 Arvore binria completa representada por um arranjo . 84 3.8 Construo do heap ............................................................................... 85 3.9 Exemplo de ordenao usando Heapsort ............................................. 86 3.10 Arquivo exemplo com 22 registros .................................................... 93 3.11 Formao dos blocos ordenados iniciais ............................................ 93 3.12 Intercalao-de-3-caminhos ................................................................ 93 3.13 Resultado da primeira passada usando seleo por ubstituio....... 95
LISTA DE FIGURAS 3.14 Conjunto ordenado na primeira passada .............................................. 96 3.15 Intercalao usando seleo por substituio .......................................97 4.1 Exemplo de pesquisa binria para a chave G ......................................... 111 4.2 rvore binria de pesquisa ..................................................................... 113 4.3 Arvore binria de pesquisa completamente balanceada .........................118 4.4 Uma rvore 2-3 e a rvore B binria correspondente ............................ 119 4.5 Arvore SBB ............................................................................................ 119 4.6 Transformaes propostas por Bayer (1972) ........................................120 4.7 Crescimento de uma rvore SBB ........................................................... 123 4.8 Decomposio de uma rvore SBB ........................................................127 4.9 Trie binria ............................................................................................. 129 4.10 Insero das chaves W e K ...................................................................129 4.11 Arvore Patricia ......................................................................................130 4.12 Insero da chave K ............................................................................. 130 4.13 Insero da chave W .............................................................................131 4.14 Lista encadeada em separado ............................................................... 137 4.15 Open addressing ................................................................................140 4.16 Arvore AVL ..........................................................................................143 4.17 Transformaes propostas por Olivi (1980) .......................................146 4.18 Pat array .............................................................................................. 154 5.1 Mapeamento de endereos para paginao ............................................ 159 5.2 Fila de Molduras_de_Pginas .................................................................160 5.3 Endereamento no sistema de paginao ............................................... 163 5.4 Estrutura de um arquivo seqencial indexado ........................................164 5.5 Disco magntico ..................................................................................... 165 5.6 Organizao de um arquivo indexado seqencial para o CD, ROM ................................................................................................... 168 5.7 Arvore binria dividida em pginas ....................................................... 169 5.8 Arvore B de ordem 2 com 3 nveis .........................................................171 5.9 Nodo de uma rvore B de ordem m com 2m registros ........................... 171 5.10 Insero em uma rvore B de ordem 2 .................................................173 5.11 Crescimento de uma rvore B de ordem 2 ........................................... 177 5.12 Retirada da chave 3 na rvore B de ordem m = 1 ................................ 178 5.13 Decomposio de uma rvore B de ordem 2 ........................................181 5.14 Estrutura de uma rvore B* ..................................................................182 5.15 Exemplo de uma rvore B* .................................................................. 184 5.16 Retirada de registros em rvores B* .................................................... 185 5.17 Parte de uma rvore B* ........................................................................ 188
Lista de Tabelas
1.1 Comparao dos algoritmos para obter o mximo e o mnimo.......... 10 1.2 Comparao de vrias funes de complexidade ................................ 16 1.3 Influncia do aumento de velocidade dos computadores no tamanho t do problema ..........................................................................17 3.1 Ordem aleatria dos registros ............................................................... 88 3.2 Ordem ascendente dos registros ........................................................... 88 3.3 Ordem descendente dos registros ......................................................... 88 3.4 Influncia da ordem inicial ................................................................... 89 4.1 Nmero de comparaes em uma pesquisa com sucesso para hashing linear .................................................................................................... 141 5.1 Nmero de acessos a disco, no pior caso, para tamanhos variados de pginas e arquivos usando rvore B .................................. 190
Lista de Programas
1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 Funo para obter o mximo de um conjunto .......................................5 Implementao direta para obter o mximo e o mnimo . 7 Implementao melhorada para obter o mximo e o mnimo 8 Outra implementao para obter o mximo e o mnimo ..................... 9 Programa para ordenar .......................................................................... 20 Algoritmo recursivo .............................................................................. 21 Verso recursiva para obter o mximo e o mnimo ........................... 23 Programa para copiar arquivo .............................................................. 29
2.1 Estrutura da lista usando arranjo ......................................................... 38 2.2 Operaes sobre listas usando posies contguas de memria 39 2.3 Estrutura da lista usando apontadores ................................................. 40 2.4 Operaes sobre listas usando apontadores ........................................ 41 2.5 Campos do registro de um candidato .................................................. 42 2.6 Primeiro refinamento do programa Vestibular ................................... 43 2.7 Segundo refinamento do programa Vestibular ................................... 44 2.8 Estrutura da lista .................................................................................... 45 2.9 Refinamento final do programa Vestibular ........................................ 46 2.10 Estrutura da pilha usando arranjo ...................................................... 49 2.11 Operaes sobre pilhas usando arranjos ........................................... 50 2.12 Estrutura da pilha usando apontadores ..............................................51 2.13 Operaes sobre pilhas usando apontadores .................................... 52 2.14 Implementao do ET ......................................................................... 54 2.15 Procedimento Imprime utilizado no programa ET ........................... 55 2.16 Estrutura da fila usando arranjo ......................................................... 57 2.17 Operaes sobre filas usando posies contguas de memria ...... 57 2.18 Estrutura da fila usando apontadores ................................................ 59 2.19 Operaes sobre filas usando apontadores ....................................... 60 3.1 Estrutura de um item do arquivo ..........................................................70 3.2 Tipos utilizados na implementao dos algoritmos ........................... 72 3.3 Ordenao por seleo .......................................................................... 73
LISTA DE PROGRAMAS 3.4 Ordenao por insero ........................................................................ 75 3.5 Algoritmo Shellsort .............................................................................. 77 3.6 Procedimento Partio .......................................................................... 79 3.7 Procedimento Quicksort ..........................................................................80 3.8 Procedimento para construir o heap ....................................................... 85 3.9 Procedimento Heapsort ........................................................................... 87 4.1 Estrutura do tipo dicionrio implementado como arranjo .................109 4.2 Implementao das operaes usando arranjo ................................... 109 4.3 Pesquisa binria ..................................................................................... 111 4.4 Estrutura do dicionrio para rvores sem balanceamento ................. 113 4.5 Procedimento para pesquisar na rvore .............................................. 114 4.6 Procedimento para inserir na rvore ....................................................114 4.7 Procedimento para inicializar ...............................................................114 4.8 Programa para criar a rvore ................................................................ 115 4.9 Procedimento para retirar x da rvore ................................................. 116 4.10 Caminhamento central ........................................................................ 117 4.11 Estrutura do dicionrio para rvores SBB ........................................ 120 4.12 Procedimentos auxiliares para rvores SBB .....................................121 4.13 Procedimento para inserir na rvore SBB ........................................ 123 4.14 Procedimento para inicializar a rvore SBB ......................................................... '123 4.15 Procedimento para retirar da rvore SBB ......................................... 126 4.16 Estrutura de dados ............................................................................... 131 4.17 Funes auxiliares ............................................................................... 132 4.18 Procedimento CrieNodos .................................................................... 133 4.19 Algoritmo de pesquisa ........................................................................ 133 4.20 Inicializao da rvore ........................................................................ 133 4.21 Algoritmo de insero ......................................................................... 134 4.22 Implementao de funo de transformao .................................... 137 4.23 Estrutura do dicionrio para listas encadeadas ................................ 138 4.24 Operaes do Dicionrio usando listas encadeadas .........................139 4.25 Estrutura do dicionrio usando open addressing ........................... 141 4.26 Operaes do dicionrio usando open addressing ......................... 142 5.1 Estrutura de dados para o sistema de paginao ................................ 161 5.2 Diferentes tipos de pginas para o sistema de paginao . 162 5.3 Estrutura do dicionrio para rvore B ................................................. 172 5.4 Procedimento para inicializar uma rvore B ................................ 172 ..................................... 5.5 Procedimento para pesquisar na rvore B ........................................ ..173 5.6 Primeiro refinamento do algoritmo Insere na rvore B ................... 174 5.7 Procedimento Insere Na Pgina ..........................................................175 5.8 Refinamento final do algoritmo Insere .............................................. 176 5:9 Procedimento Retira ............................................................................181
LISTA DE PROGRAMAS
5.10 Estrutura do dicionrio para rvore B* ..........................................183 5.11 Procedimento para pesquisar na rvore B* ................................... 183 A.1 A.2 A.3 A.4 A.5 A.6 A.7 A.8 Funo para obter o maior elemento de um vetor ..........................197 Implementao direta para obter o mximo e o mnimo ............... 197 Implementao melhorada para obter o mximo e o mnimo ....... 198 Outra implementao para obter o mximo e o mnimo ................199 Programa para ordenar ...................................................................... 199 Algoritmo recursivo ...........................................................................199 Verso recursiva para obter o mximo e o mnimo ....................... 200 Programa para copiar arquivo .......................................................... 201
B.1 Estrutura da lista usando arranjo ......................................................203 B.2 Operaes sobre listas usando posies contguas de memria... 204 B.3 Estrutura da lista usando apontadores ... . .......................................205 B.4 Operaes sobre listas usando apontadores .................................... 206 B.5 Campos do registro de um candidato ...............................................206 B.6 Primeiro refinamento do programa Vestibular ............................... 206 B.7 Segundo refinamento do programa Vestibular ............................... 207 B.8 Estrutura da lista ................................................................................ 208 B.9 Refinamento final do programa Vestibular .....................................209 B.10 Estrutura da pilha usando arranjo ....................................................209 B.11 Operaes sobre pilhas usando arranjos .........................................210 B.12 Estrutura da pilha usando apontadores ............................................ 210 B.13 Operaes sobre pilhas usando apontadores .................................. 211 B.14 Implementao do ET ....................................................................... 212 B.15 Procedimento Imprime utilizado no programa ET ........................ 213 B.16 Estrutura da fila usando arranjo ...................................................... 213 B.17 Operaes sobre filas usando posies contguas de memria .... 214 B.18 Estrutura da fila usando apontadores .............................................. 214 B.19 Operaes sobre filas usando apontadores .....................................215 C;1 Estrutura de um item do arquivo ....................................................... 217 C.2 Tipos utilizados na implementao dos algoritmos ....................... 217 C.3 Ordenao por seleo .......................................................................217 C.4 Ordenao por insero .....................................................................218 C.5 Algoritmo Shellsort ........................................................................... 218 C.6 Funo Partio ..................................................................................219 C.7 Funo Quicksort ............................................................................... 219 C.8 Funo para construir o heap ............................................................. 220 C.9 Funo Heapsort ................................................................................ 221 D.1 Estrutura do tipo dicionrio implementado como arranjo .............223
LISTA DE PROGRAMAS
D.2 Implementao das operaes usando arranjo ................................ 224 D.3 Pesquisa binria .................................................................................. 224 D.4 Estrutura do dicionrio .......................................................................225 D.5 Funo para pesquisar na rvore .......................................................225 D.6 Funo para inserir na rvore ............................................................226 D.7 Funo para inicializar .......................................................................226 D.8 Programa para criar a rvore .............................................................226 D.9 Funes para retirar x da rvore ....................................................... 227 D.10 Caminhamento central ......................................................................227 D.11 Estrutura do dicionrio para rvores SBB ..................................... 228 D.12 Procedimentos auxiliares para rvores SBB .................................. 229 D.13 Procedimento para inserir na rvore SBB ......................................230 D.14 Procedimento para inicializa a rvore SBB ................................... 231 D.15 Procedimento para retirar da rvore SBB ...................................... 234 D.16 Estrutura de dados ............................................................................ 234 D.17 Funes auxiliares ............................................................................ 235 D,18 Funo CrieNodos ............................................................................ 235 D.19 Algoritmo de pesquisa ......................................................................236 D.20 Inicializao da rvore ..................................................................... 236 D.21 Algoritmo de insero ...................................................................... 237 D.22 Implementao de funo de transformao ..................................238 D.23 Estrutura do dicionrio para listas encadeadas ..............................238 D.24 Operaes do dicionrio usando listas encadeadas .......................239 D.25 Estrutura do dicionrio usando open addressing .........................240 D.26 Operaes do dicionrio usando open addressing .......................241 E.1 Estrutura de dados para o sistema de paginao ............................. 243 E.2 Diferentes tipos de pginas para o sistema de paginao ...............243 E.3 Estrutura do dicionrio para rvore B .............................................. 244 E.4 Funo para inicializar uma vore B ................................................ 244 E.5 Funo para pesquisar na vore B .....................................................245 E.6 Primeiro refinamento do algoritmo Insere na rvore B .................. 246 E.7 Funo Insere Na Pgina ....................................................................246 E.8 Refinamento final do algoritmo Insere ............................................. 248 E.9 Funo Retira ...................................................................................... 250 E.10 Estrutura do dicionrio para rvore B* ...........................................251 E.11 Funo para pesquisar na rvore B* ............................................... 252
Captulo 1
Introduo
1.1 Algoritmos, Estruturas de Dados e Programas
Os algoritmos fazem parte do dia-a-dia das pessoas. As instrues para o uso de medicamentos, as indicaes de como montar um aparelho qualquer, uma receita de culinria so alguns exemplos de algoritmos. Um algoritmo pode ser visto como uma seqncia de aes executveis para a obteno de uma soluo para um determinado tipo de problema. Segundo Dijkstra (1971) um algoritmo corresponde a uma descrio de um padro de comportamento, expresso em termos de um conjunto finito de aes. Ao executarmos a operao a + b percebemos um mesmo padro de comportamento, mesmo que a operao seja realizada para valores diferentes de a e b. Estruturas de dados e algoritmos esto intimamente ligados. No se pode estudar estruturas de dados sem considerar os algoritmos associados a elas, assim como a escolha dos algoritmos em geral depende da representao e da estrutura dos dados. Para resolver um problema necessrio escolher uma abstrao da realidade, em geral atravs da definio de um conjunto de dados que representa a situao real. A seguir deve ser escolhida a forma de representar estes dados. A escolha da representao dos dados determinada, entre outras, pelas operaes a serem realizadas sobre os dados. Considere a operao de adio. Para pequenos nmeros uma boa representao atravs de barras verticais, caso em que a operao de adio bastante simples. J a representao atravs de dgitos decimais requer regras relativamente complicadas, as quais devem ser memorizadas. Entretanto, a situao se inverte quando consideramos a adio de grandes nmeros, sendo mais fcil a representao por dgitos decimais por causa do princpio baseado no peso relativo da posio de cada dgito.
CAPTULO 1. INTRODUO
Programar basicamente estruturar dados e construir algoritmos. De acordo com Wirth (1976, p.XII), programas so formulaes concretas de algoritmos abstratos, baseados em representaes e estruturas especficas de dados. Em outras palavras, programas representam uma classe especial de algoritmos capazes de serem seguidos por computadores. Entretanto, um computador s capaz de seguir programas em linguagem de mquina, que correspondem a uma seqncia de instrues obscuras e desconfortveis. Para contornar tal problema necessrio construir linguagens mais adequadas para facilitar a tarefa de programar um computador. Segundo Dijkstra (1976), uma linguagem de programao uma tcnica de notao para programar, com a inteno de servir de veculo tanto para a expresso do raciocnio algortmico quanto para a execuo automtica de um algoritmo por um computador.
1.2 Tipos de Dados e Tipos Abstratos de Dados

Em linguagens de programao importante classificar constantes, variveis, expresses e funes de acordo com certas caractersticas, as quais indicam o seu tipo de dados. Este tipo deve caracterizar o conjunto de valores a que uma constante pertence, ou que podem ser assumidos por uma varivel ou expresso, ou que podem ser gerados por uma funo (Wirth, 1976, pp.440). Tipos simples de dados so grupos de valores indivisveis, como os tipos bsicos integer, boolean, char, e real do Pascal. Por exemplo, uma varivel do tipo boolean pode assumir ou o valor verdadeiro ou o valor falso, e nenhum outro valor. Os tipos estruturados em geral definem uma coleo de valores simples, ou um agregado de valores de tipos diferentes. A linguagem Pascal oferece uma grande variedade de tipos de dados, como ser mostrado na Seo 1.5. Um tipo abstrato de dados pode ser visto como um modelo matemtico, acompanhado das operaes definidas sobre o modelo. 0 conjunto dos inteiros acompanhado das operaes de adio, subtrao e multiplicao forma um exemplo de um tipo abstrato de dados. Aho, Hoperoft e Ullman ( 1983), utilizam extensivamente tipos abstratos de dados como base para o projeto de algoritmos. Nestes casos a implementao do algoritmo em uma linguagem de programao especfica exige que se encontre alguma forma de representar o tipo abstrato de dados, em termos dos tipos de dados e dos operadores suportados pela linguagem considerada. A representao do modelo matemtico por trs do tipo abstrato de dados realizada atravs de uma estrutura de dados. Tipos abstratos de dados podem ser considerados generalizaes de tipos primitivos de dados, da mesma forma que procedimentos so generalizaes de operaes. primitivas tais como adio, subtrao e multiplicao. Da
1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA
mesma forma que um procedimento usado para encapsular partes de um algoritmo, o tipo abstrato de dados pode ser usado para encapsular tipos de dados. Neste caso a definio do tipo e todas as operaes definidas sabre ele podem ser localizadas em uma nica seo do programa. Como exemplo, considere uma aplicao que utilize uma lista de inteiros. Poderamos definir um tipo abstrato de dados Lista, com as seguintes operaes sobre a lista: 1. faa a lista vazia, 2. obtenha o primeiro elemento da lista. Se a lista estiver vazia ento retorne nulo, 3. insira um elemento na lista. Existem vrias opes de estruturas de dados que permitem uma implementao eficiente para listas. Uma possvel implementao para o tipo abstrato de dados Lista atravs do tipo estruturado arranjo. A seguir cada operao do tipo abstrato de dados implementada como um procedimento na linguagem de programao escolhida. Se existe necessidade de alterar a implementao do tipo abstrato de dados, a alterao fica restrita parte encapsulada, sem causar impactos em outras partes do cdigo.. Cabe ressaltar que cada conjunto diferente de operaes define um tipo abstrato de dados diferente, mesmo que todos os conjuntos de operaes atuem sobre um mesmo modelo matemtico. Uma razo forte para isto que a escolha adequada de uma implementao depende fortemente das operaes a serem realizadas sobre o modelo.
1.3 Medida do Tempo de Execuo de um Programa

0 projeto de algoritmos fortemente influenciado pelo estudo de seus comportamentos. Depois que um problema analisado e decises de projeto so finalizadas, o algoritmo tem que ser implementado em um computador. Neste momento o projetista tem que estudar as vrias opes de algoritmos a serem utilizados, onde os aspectos de tempo de execuo e espao ocupado so consideraes importantes. Muitos destes algoritmos so encontrados em reas tais como pesquisa operacional, otimizao, teoria dos grafos, estatstica, probabilidades, entre outras. Na rea de anlise de algoritmos, existem dois tipos de problemas bem distintos, conforme apontou Knuth (1971): (i) Anlise de um algoritmo particular. Qual o custo de usar um dado algoritmo para resolver um problema especfico? Neste caso, caractersticas
CAPTULO 4. INTRODUO
importantes do algoritmo em questo devem ser investigadas, geralmente uma anlise do nmero de vezes que cada parte do algoritmo deve ser executada, seguida do estudo da quantidade de memria necessria. (ii) Anlise de uma classe de algoritmos. Qual o algoritmo de menor custo possvel para resolver um problema particular? Neste caso, toda uma famlia de algoritmos para resolver um problema especfico investigada com o objetivo de identificar um que seja o melhor possvel. Isto significa colocar limites para a complexidade computacional dos algoritmos pertencentes classe. Por exemplo, possvel estimar o nmero mnimo de comparaes necessrias para ordenar n nmeros atravs de comparaes sucessivas, conforme veremos mais adiante no Captulo 3. Quando conseguimos determinar o menor custo possvel para resolver problemas de uma determinada classe, como no caso de ordenao, temos a medida da dificuldade inerente para resolver tais problemas. Ainda mais, quando o custo de um algoritmo igual ao menor custo possvel, ento podemos concluir que o algoritmo timo para a medida de custo considerada. Em muitas situaes podem existir vrios algoritmos para resolver o mesmo problema, sendo pois necessrio escolher aquele que o melhor. Se uma mesma medida de custo aplicada a diferentes algoritmos ento possvel compar-los e escolher o mais adequado para resolver o problema em questo. O custo de utilizao de um algoritmo pode ser medido de vrias maneiras. Uma delas atravs da execuo do programa em um computador real, sendo o tempo de execuo medido diretamente. As medidas de tempo obtidas desta forma so bastante inadequadas e os resultados jamais devem ser generalizados. As principais objees so: (i) os resultados so dependentes do compilador que pode favorecer algumas construes em detrimento de outras; (ii) os resultados dependem do hardware; (iii) quando grandes quantidades de memria so utilizadas, as medidas de tempo podem depender deste aspecto. Apesar disso, Gonnet e Baeza-Yates (1991, p.7) apresentam argumentos a favor de se obter medidas reais de tempo para algumas situaes particulares como, por exemplo, quando existem vrios algoritmos distintos para resolver um mesmo tipo de problema, todos com um custo de execuo dentro de uma mesma ordem de grandeza. Assim os custos reais das operaes so todos considerados, assim como os custos no aparentes tais como alocao de memria, indexao, carga, etc. Uma forma mais adequada de se medir o custo de utilizao de um algoritmo atravs do uso de um modelo matemtico, baseado em um computador idealizado como, por exemplo, o computador MIX proposto por Knuth ( 1968). 0 conjunto de operaes a serem executadas deve ser especificado, assim como o custo associado com a execuo de cada operao. Mais usual ainda ignorar o custo de algumas das operaes envolvidas e considerar apenas as operaes mais significativas. Por exemplo, para algoritmos de
1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 5
CAPTULO 1. INTRODUO
A medida do custo de execuo de um algoritmo depende principalmente do tamanho da entrada dos dados. Por isso comum considerar-se o tempo de execuo de um programa como uma funo do tamanho da entrada. Entretanto, para alguns algoritmos, o custo de execuo uma funo da entrada particular dos dados, no apenas do tamanho da entrada. No caso da funo Max do Programa 1.1 o algoritmo possui a propriedade de que o custo uniforme sobre todos os problemas de tamanho n. J para um algoritmo de ordenao isto no ocorre: se os dados de entrada j estiverem quase ordenados ento o algoritmo pode ter que trabalhar menos. Temos ento que distinguir trs cenrios: melhor caso, pior caso e caso mdio. 0 melhor caso corresponde ao menor tempo de execuo sobre todas as possveis entradas de tamanho n. 0 pior caso corresponde ao maior tempo de execuo sobre todas as entradas de tamanho n . Se f uma funo de complexidade baseada na anlise de pior caso ento o custo de aplicar o algoritmo nunca. maior do que (n). 0 caso mdio (ou caso esperado) corresponde mdia dos tempos de execuo de todas as entradas de tamanho n. Na anlise do caso esperado, uma distribuio de probabilidades sobre o conjunto de entradas de tamanho n suposta, e o custo mdio obtido com base nesta distribuio. Por esta razo, a anlise do caso mdio geralmente muito mais difcil de obter do que as anlises do melhor e do pior caso. comum supor uma distribuio de probabilidades em que todas as entradas possveis so igualmente provveis. Entretanto, na prtica isto nem sempre verdade. Por isso a anlise do caso esperado dos algoritmos a serem estudados s ser apresentada quando esta fizer sentido. Para ilustrar estes conceitos considere o problema de acessar os registros de um arquivo. Cada registro contm uma chave nica que utilizada para recuperar registros do arquivo. Dada uma chave qualquer o problema consiste em localizar o registro que contenha esta chave. 0 algoritmo de pesquisa mais simples que existe o que faz uma pesquisa seqencial. Este algoritmo examina os registros na ordem em que eles aparecem no arquivo, at que o registro procurado seja encontrado ou fique determinado que o mesmo no se encontra no arquivo. Seja f uma funo de complexidade tal que (n) o nmero de registros consultados no arquivo, isto , o nmero de vezes que a chave de consulta comparada com a chave de cada registro. Os casos a considerar so: melhor caso : (n) = 1 pior caso : (n) = n caso mdio :(n) = (n + 1)/2 0 melhor caso ocorre quando o registro procurado o primeiro consultado. 0 pior caso ocorre quando o registro procurado o ltimo consultado,
CAPTULO 1. I N T R O D U O
10
CAPTULO 1. INTRODUO
A Tabela 1.1 apresenta uma comparao entre os algoritmos dos Programas 1.2, 1.3 e 1.4,. considerando o nmero de comparaes como medida de complexidade. Os algoritmos MaxMin2 e MaxMin3 so superiores ao algoritmo MaxMinl de forma geral. O algoritmo MaxMin3 superior ao algoritmo MaxMin2 com relao ao pior caso e bastante prximo quanto ao caso mdio.
Os Trs Algoritmos MaxMin1 MaxMin2 MaxMin3 f (n) Melhor caso 2(n-1) n1 3n/2-2 Pior caso 2(n-1) 2(n-1) 3n/2-2 Caso mdio 2(n-1) 3n/2-3/2 3n/2-2
Tabela 1.1:
Comparao dos algoritmos para obter o mximo e o mnimo
Considerando novamente o nmero de comparaes realizadas, existe possibilidade de obter um algoritmo mais eficiente para este problema? Para responder a esta questo necessrio conhecer o limite inferior para a classe de algoritmos para obter o maior e o menor elemento de um conjunto. Uma tcnica muito utilizada para obter o limite inferior para uma classe qualquer de algoritmos atravs da utilizao de um orculo.2 Dado um modelo de computao que expresse o comportamento do algoritmo o orculo informa o resultado de cada passo possvel, que no nosso caso seria o resultado de cada comparao. Para derivar o limite inferior o orculo procura sempre fazer com que o algoritmo trabalhe o mximo, escolhendo como resultado da prxima comparao aquele que cause o maior trabalho possvel que necessrio para determinar a resposta final. O teorema abaixo, apresentado por Horowitz e Sahni (1978, p.476), utiliza um orculo para derivar o limite inferior no nmero de comparaes necessrias para obter o mximo e o mnimo de um conjunto com n elementos. Teorema: Qualquer algoritmo para encontrar o maior elemento e o menor elemento de um conjunto com n elementos no ordenados, n 1, faz pelo menos [3n/2] 2 comparaes. Prova: A tcnica utilizada define um orculo que descreve o comportamento do algoritmo atravs de um conjunto de ntuplas, mais um conjunto de regras associadas que mostram as tuplas possveis (estados) que um algoritmo pode assumir a partir de uma dada tupla e uma nica comparao.
2De acordo com o Novo Dicionrio Aurlio da Lingua Portuguesa, um orculo : 1. Resposta de um deus a quem o consultava. 2. Divindade que responde consultas e orienta o crente: o orculo de Delfos. 3. Fig. Palavra, sentena ou deciso inspirada, infalvel ou que tem grande autoridade: os orculos dos profetas, os orculos da cincia.
1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 11 O comportamento do algoritmo pode ser descrito por uma 4-tupla, representada por (a, b, c, d), onde a representa o nmero de elementos que nunca foram comparados; b representa o nmero de elementos que foram vencedores e nunca perderam em comparaes realizadas; c representa o nmero de elementos que foram perdedores e nunca venceram em comparaes realizadas; d representa o nmero de elementos que foram vencedores e perdedores em comparaes realizadas. O algoritmo inicia no estado (n, 0, 0, 0) e termina com (0, 1,1, n 2). Desta forma, aps cada comparao a tupla (a, b, c, d) consegue progredir apenas se ela assume um dentre os cinco estados possveis, a saber:
1.3.1 Comportamento Assinttico de Funes

Como j foi observado anteriormente, o custo para obter uma soluo para um dado problema aumenta cem o tamanho n do problema. O nmero de comparaes para encontrar o maior elemento de um conjunto de n inteiros, ou para ordenar os elementos de um conjunto com n elementos, aumenta com n: 0 parmetro n fornece uma medida da dificuldade para se resolver
12
CAPITULO 1. INTRODUO
o problema, no sentido de que o tempo necessrio para resolver o problema cresce quando n cresce. Para valores suficientemente pequenos de n, qualquer algoritmo custa pouco para ser executado, mesmo os algoritmos ineficientes. Em outras palavras, a escolha do algoritmo no um problema crtico para problemas de tamanho pequeno. Logo, a anlise de algoritmos realizada para valores grandes de n. Para tal considera-se o comportamento de suas funes de custo para valores grandes de n, isto , estuda-se o comportamento assinttico das funes de custo. O comportamento assinttico de(n) representa o limite do comportamento do custo quando n cresce. A anlise de um algoritmo geralmente conta apenas algumas operaes elementares e, em muitos casos, apenas uma operao elementar. A medida de custo ou medida de complexidade relata o crescimento assinttico da operao considerada. A definio seguinte relaciona o comportamento assinttico de duas funes distintas.
14
CAPTULO 1. INTRODUO
1.3.2 Classes de Comportamento Assinttico

Se f uma funo de complexidade para um algoritmo F , ento 0 ( f ) considerada a complexidade assinttica ou o comportamento assinttico do algoritmo F . Igualmente, se g uma funo para um algoritmo G, ento 0 ( g ) considerada a complexidade assinttica do algoritmo G. A relao de dominao assinttica permite comparar funes de complexidade. Entretanto, se as funes f e g dominam assintoticamente uma a outra ento os algoritmos associados so equivalentes. Nestes casos, o comportamento assinttico no serve para comparar os algoritmos. Por exemplo, dois algoritmos F e G aplicados mesma classe de problemas, sendo que F leva trs vezes o tempo de G ao serem executados, isto (n ) = 3 g ( n ) , sendo que 0 ( f ( n ) ) = 0 ( g ( n ) ) . Logo o comportamento assinttico no serve para comparar os algoritmos F e G porque eles diferem apenas por uma constante. Programas podem ser avaliados atravs da comparao de suas funes de complexidade, negligenciando as constantes de proporcionalidade. Um programa com tempo de execuo 0 ( n ) melhor que um programa com tempo de execuo 0 ( n 2) . Entretanto, as constantes de proporcionalidade em cada caso podem alterar esta considerao. Por exemplo, possvel que um programa leve 100n unidades de tempo para ser executado enquanto um outro leve 2 n 2 unidades de tempo. Qual dos dois programas melhor? A resposta a esta pergunta depende do tamanho do problema a ser executado. Para problemas de tamanho n < 50, o programa com tempo de execuo 2 n 2 melhor do que o programa com tempo de execuo 100n. Para problemas com entrada de dados pequena prefervel usar o programa cujo tempo de execuo 0 ( n 2) . Entretanto, quando n cresce, o programa com tempo 0 ( n 2) leva muito mais tempo que o programa 0(n).
1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 15 A maioria dos algoritmos possui um parmetro que afeta o tempo de execuo de forma mais significativa, usualmente o nmero de itens a ser processado. Este parmetro pode ser o nmero de registros de um arquivo a ser ordenado, ou o nmero de ns de um grafo. As principais classes de problemas possuem as funes de complexidade descritas abaixo. 1 . f (n) = 0(1). Algoritmos de complexidade 0(1) so ditos de complexidade constante. O uso do algoritmo independe do tamanho de n. Neste caso as instrues do algoritmo so executadas um nmero fixo de vezes. 2 . ( n ) = O(log n). Um algoritmo de complexidade O( logn) dito ter complexidade logartmica. Este tempo de execuo ocorre tipicamente em algoritmos que resolvem um problema transformando-o em problemas menores. Nestes casos, o tempo de execuo pode ser considerado como sendo menor do que uma constante grande. Quando n mil e a base do logaritmo 2, log2n 10, quando n um milho, log2n 20. Para dobrar o valor de log n temos que considerar o quadrado de n. A base do logaritmo muda pouco estes valores: quando n um milho, o log2n 20 e o log10n 6. 3. f (n) = 0(n). Um algoritmo de complexidade 0(n) dito ter complexidade linear. Em geral um pequeno trabalho realizado sobre cada elemento de entrada. Esta a melhor situao possvel para um algoritmo que tem que processar n elementos de entrada ou produzir n elementos de sada. Cada vez que n dobra de tamanho o tempo de execuo dobra. 4 . f ( n ) = O ( n log n ) . Este tempo de execuo ocorre tipicamente em algoritmos que resolvem um problema quebrando-o em problemas menores, resolvendo cada um deles independentemente e depois ajuntando as solues. Quando n um milho e a base do logaritmo 2, nlog2n cerca de 20 milhes. Quando n dois milhes, nlog2n cerca de 42 milhes, pouco mais do que o dobro. 5 . f (n) = 0(n2). Um algoritmo de complexidade 0(n2) dito ter complexidade quadrtica. Algoritmos desta ordem de complexidade ocorrem quando os itens de dados so processados aos pares, muitas vezes em um anel dentro de outro. Quando n mil, o nmero de operaes da ordem de 1 milho. Sempre que n dobra o tempo de execuo multiplicado por 4. Algoritmos deste tipo so teis para resolver problemas de tamanhos relativamente pequenos. 6 . f (n) = 0(n3). Um algoritmo de complexidade 0(n3) dito ter complexidade cbica. Algoritmos desta ordem de complexidade so teis
16
apenas para resolver pequenos problemas. Quando n cem, o nmero de operaes da ordem de 1 milho. Sempre que n dobra o tempo de execuo fica multiplicado por 8.
7. (n) = 0(2n). Um algoritmo de complexidade 0(2n) dito ter complexidade exponencial. Algoritmos desta ordem de complexidade geralmente no so teis sob o ponto de vista prtico. Eles ocorrem na soluo de problemas quando se usa fora bruta para resolv-los. Quando n vinte, o tempo de execuo cerca de um milho. Quando n dobra, o tempo de execuo fica elevado ao quadrado. Para ilustrar melhor a diferena entre as classes de comportamento assinttico Garey e Johnson (1979, p.7) apresentam o quadro mostrado na Ta-bela 1.2. Este quadro mostra a razo de crescimento de vrias funes de complexidade para tamanhos diferentes de n, onde cada funo expressa o tempo de execuo em microsegundos. Um algoritmo linear executa em um segundo um milho de operaes.
T a b e l a 1.2: Comparao de virias funes de complexidade
Um outro aspecto interessante o efeito causado pelo aumento da velocidade dos computadores sobre os algoritmos com as funes de complexidade citadas acima. A Tabela 1.3 mostra como um aumento de 100 ou de 1000 vezes na velocidade de computao de um computador atual influi na soluo do maior problema possvel de ser resolvido em uma hora. Note que um aumento de 1000 vezes na velocidade de computao resolve um problema dez vezes maior para um algoritmo de complexidade 0(n3 ), enquanto um algoritmo de complexidade 0(2n) apenas adiciona dez ao tamanho do maior problema possvel de ser resolvido em uma hora.

Funo de custo de de tempo n n2 n3 2n Computador atual tl t2 t3 t4 Computador 100 vezes mais rpido 100t 1 10t 2 4,6t 3 t 4+ 6 , 6 Computador 1000 vezes mais rpido 1000t 1 31, 6t 2 10t 3 t4+10
Tabela 1.3: Influncia do aumento de velocidade dos computadores no tamanho t do problema
Um algoritmo cuja funo de complexidade O(c n), c > 1, chamado de algoritmo exponencial no tempo de execuo. Um algoritmo cuja funo de complexidade O(p(n)), onde p(n) um polinmio, chamado de algoritmo polinomial no tempo de execuo. A distino entre estes dois tipos de algoritmos torna-se significativa quando o tamanho do problema a ser resolvido cresce, conforme ilustra a Tabela 1.2. Esta a razo por que algoritmos polinomiais so muito mais teis na prtica do que algoritmos exponenciais. Os algoritmos exponenciais so geralmente simples variaes de pesquisa exaustiva, enquanto algoritmos polinomiais so geralmente obtidos atravs de um entendimento mais profundo da estrutura do problema. Um problema considerado intratvel se ele to difcil que no existe um algoritmo polinomial para resolv-lo, enquanto um problema considerado bem resolvido quando existe um algoritmo polinomial para resolv-lo. Entretanto, a distino entre algoritmos polinomiais eficientes e algoritmos exponenciais ineficientes possui vrias excees. Por exemplo, um algoritmo com funo de complexidade n) = 2n mais rpido que um algoritmo g(n) = n 5 para valores de n menores ou iguais a 20. Da mesma forma, existem algoritmos exponenciais que so muito teis na prtica. Por exemplo, o algoritmo Simplex para programao linear possui complexidade de tempo exponencial para o pior caso (Garey e Johnson, 1979), mas executa muito rpido na prtica. Infelizmente, exemplos como o do algoritmo Simplex no ocorrem com freqncia na prtica, e muitos algoritmos exponenciais conhecidos no so muito teis. Considere, como exemplo, o seguinte problema: um caixeiro viajante deseja visitar n cidades de tal forma que sua viagem inicie e ter-mine em uma mesma cidade, e cada cidade deve ser visitada uma nica vez. Supondo que sempre exista uma estrada entre duas cidades quaisquer, o problema encontrar a menor rota que o caixeiro viajante possa utilizar na sua viagem. A Figura 1.4 ilustra o exemplo acima para quatro cidades cl, c2, c3,c4, onde os nmeros nos arcos indicam a distncia entre duas cidades. O per-
18
CAPT ULO 1. INTRODUO
curso < c1, c3, c4, c2, c1 > uma soluo para o problema, cujo percurso total tem distncia 24. Um algoritmo simples para o problema acima seria verificar todas as rotas e escolher a menor delas. Como existem ( n 1)! rotas possveis e a distncia total percorrida em cada rota envolve n adies, ento o nmero total de adies n ! . Para o exemplo da Figura 1.4 teriamos 24 adies. Suponha agora 50 cidades: o nmero de adies seria igual ao fatorial de 50, que aproximadamente 1064. Considerando um computador capaz de executar 109 adies por segundo, o tempo total para resolver o problema com 50 cidades seria maior do que 1045 sculos somente para executar as adies.
Figura 1.4: Problema do caixeiro viajante
1.4 Tcnicas de Anlise de Algoritmos

A determinao do tempo de execuo de um programa qualquer pode se tornar um problema matemtico complexo quando se deseja determinar o valor exato da funo de complexidade. Entretanto, a determinao da ordem do tempo de execuo de um programa, sem haver preocupao com o valor da constante envolvida, pode ser uma tarefa mais simples. E mais fcil determinar que o nmero esperado de comparaes para recuperar um registro de um arquivo utilizando pesquisa seqencial 0 ( n ) do que efetivamente determinar que este nmero ( n + 1)/2, quando cada registro tem a mesma probabilidade de ser procurado. A anlise de algoritmos ou programas utiliza tcnicas de matemtica discreta, envolvendo contagem ou enumerao dos elementos de um conjunto que possuam uma propriedade comum. Estas tcnicas envolvem a manipulao de somas, produtos, permutaes, fatoriais, coeficientes binomiais, soluo de equaes de recorrncia, entre outras. Algumas destas tcnicas sero ilustradas informalmente atravs de exemplos.
1.4. TCNICAS DE ANLISE DE ALGORITMOS
19
Infelizmente no existe um conjunto completo de regras para analisar programas. Aho, Hoperoft e Ullman (1983) enumeram alguns princpios a serem seguidos. Muitos destes princpios utilizam as propriedades sobre a notao O apresentadas na Figura 1.3. So eles: 1. 0 tempo de execuo de um comando de atribuio, de leitura ou de escrita pode ser considerado como 0(1). Existem excees para as linguagens que permitem a chamada de funes em comandos de atribuio, ou quando atribuies envolvem vetores de tamanho arbitrariamente grandes. 2. 0 tempo de execuo de uma seqncia de comandos determinado pelo maior tempo de execuo de qualquer comando da seqncia. 3. 0 tempo de execuo de um comando de deciso composto pelo tempo de execuo dos comandos executados dentro do comando condicional, mais o tempo para avaliar a condio, que 0(1). 4. 0 tempo para executar um anel a soma do tempo de execuo do corpo do anel mais o tempo de avaliar a condio para terminao, multiplicado pelo nmero de iteraes do anel. Geralmente o tempo para avaliar a condio para terminao 0(1). 5. Quando o programa possui procedimentos no recursivos, o tempo de execuo de cada procedimento deve ser computado separadamente um a um, iniciando com os procedimentos que no chamam outros procedimentos. A seguir devem ser avaliados os procedimentos que chamam os procedimentos que no chamam outros procedimentos, utilizando os tempos dos procedimentos j avaliados. Este processo repetido at chegar no programa principal. 6. Quando o programa possui procedimentos recursivos, para cada procedimento associada uma funo de complexidade f (n) desconhecida, onde n mede o tamanho dos argumentos para o procedimento, conforme ser mostrado mais adiante. Com o propsito de ilustrar os vrios conceitos apresentados acima, vamos apresentar alguns programas e, para cada um deles, mostrar com detalhes os passos envolvidos em sua anlise. Exemplo: Considere o algoritmo para ordenar os n elementos de um conjunto A, cujo princpio o seguinte: 1. Selecione o menor elemento do conjunto 2. Troque este elemento com o primeiro elemento A[1].
20
CAPTULO 1. INTRODUO
1.4. T C N I C A S D E A N L I S E D E A L G O R I T M O S
21
22
1.4. TCNICAS DE ANLISE DE ALGORITMOS
23
24
CAPTULO 1. INTRODUO
1.5. PASCAL
25
1.5 Pascal
Os programas apresentados neste livro usam apenas as caractersticas bsicas do Pascal, de acordo com a definio apresentada por Jensen e Wirth (1974). Sempre que possvel so evitadas as facilidades mais avanadas disponveis em algumas implementaes do Pascal. 0 objetivo desta seo no apresentar a linguagem Pascal na sua totalidade, mas apenas examinar algumas de suas caractersticas, facilitando assim a leitura deste livro para as pessoas pouco familiarizadas com a lingua -gem. Uma descrio clara e- concisa da linguagem apresentada por Cooper (1983). Um bom texto introdutrio sobre a linguagem apresentado por Clancy e Cooper (1982). As vrias partes componentes de um programa Pascal podem ser vistas na Figura 1.5. Um programa Pascal comea com um cabealho que d nome ao programa. Rtulos, constantes, tipos, variveis, procedimentos, e funes so declaradas sempre na ordem indicada pela Figura 1.5. A parte ativa do programa descrita como uma seqncia de comandos, os quais incluem chamadas de procedimentos e funes.
program label const type var procedure ou function begin . . . end
cabealho do programa declarao de rtulo para goto definio de constantes definio de tipos de dados declarao de variveis declarao de subprogramas
comandos do programa
F i g u r a 1.5: Estrutura de um programa Pascal
A regra geral para a linguagem Pascal tornar explcito o tipo associado quando se declara uma constante, varivel ou funo, o que. permite testes de consistncia durante o tempo de compilao. A definio de tipos permite ao programador alterar o nome de tipos existentes, como tambm criar um nmero ilimitado de outros tipos. No caso do Pascal os tipos podem ser colocados em trs categorias: simples, estruturados, e apontadores. Tipos simples so grupos de valores indivisveis, estando dentro desta categoria os tipos bsicos integer, boolean, char, e real. Tipos simples adicionais podem ser enumerados atravs de uma listagem de novos grupos de
26
CAPTULO 1. INTRODUO
valores, ou atravs da indicao de subintervalos que restringem tipos a uma subseqncia dos valores de um outro tipo simples previamente definido. Exemplos de tipos enumerados type cor type sexo type boolean = (vermelho, azul, rosa); = (mas, fern); = (false, true);
Se as variveis c, s, e d so declaradas var c cor; var s sexo; var b boolean; : : :
ento so possveis as seguintes atribuies c : =rosa; s : =fern; b : =true; Exemplos de tipos com subintervalos type ano = 1999; type letra 'A'..'Z'; Dadas as variveis vara : ano; var b : letra; 1900.. =
1.5. PASCAL
onde a constante n deve ser previamente declarada const n = 20; Dada a varivel var x : coluna;
27
as atribuies x[1]:=0.75, x[2]:=0.85 e x[3]:=1.5 so possveis. Um tipo estruturado registro uma unio de valores de tipos quaisquer, cujos campos podem ser acessados pelos seus nomes. Exemplos: type data = record dia : 1..31; ms : 1..12; end; type pessoa = record sobrenome alfa; primeironome alfa; aniversrio data; sexo end; Declarada a varivel var p: pessoa; valores particulares podem ser atribuidos como se segue p.sobrenome p.primeironome p.aniversrio.dia p.aniversrio.ms p.sexo := := := := :=
'Ziviani';
: : : : (mas, ferm);
'Patricia'; 21; 10; fern;
A Figura 1.6 ilustra este exemplo. Um tipo estruturado conjunto define a coleo de todos os subconjuntos de algum tipo simples, com operadores especiais * (interseo), + (unio), (diferena) e in (pertence a) definidos para todos os tipos conjuntos. Exemplos: type conjint = set of 1..9; type conjcor = set of cor; type conjchar = set of char;
28
CAPTULO 1. INTRODUO
1.5. PASCAL
29
Programa 1.8: Programa para copiar arquivo
O Programa 1.8 copia o contedo arquivo Velho no arquivo Novo. Observe que os nomes dos arquivos aparecem como parmetros do programa. E importante observar que a atribuio de nomes de arquivos externos, ao programa varia de compilador para compilador. Por exempla, no caso do Turbo Pascal3 a atribuio do nome externo de um arquivo a uma varivel interna ao programa realizada atravs do comando assign e no como parmetros do programa. Os tipos apontadores so teis para criar estruturas de dados encadeadas, do tipo listas, rvores, e grafos. Um apontador uma varivel que referencia uma outra varivel alocada dinamicamente. Em geral a varivel referenciada definida como um registro que inclui tambm um apontador para outro elemento do mesmo tipo. Exemplo: type Apontador = ^Nodo; type Nodo = record Chave : integer Apont : Apontador; end; Dada uma varivel
3 Turbo
Pascal marca registrada da Borland International
30 var Lista: Apontador;
CAPTULO 1. INTRODUO
possvel criar uma lista como ilustrada na Figura 1.7.
Figura 1.7: Lista encadeada
Notas Bibliogrficas
Estudos bsicos sobre os conceitos de algoritmos, estruturas de dados e programas podem ser encontrados em Dahl, Dijkstra e Hoare (1972), Dijkstra ( 1971), Dijkstra (1976), Hoare (1969), Wirth (1971), Wirth (1974), Wirth ( 1976). Mais recentemente Manber (1988) e Manber (1989) tratam da utilizao de induo matemtica para o projeto de algoritmos. A anlise assinttica de algoritmos hoje a principal medida de eficincia para algoritmos. Existem muitos livros que apresentam tcnicas para analisar algoritmos, tais como somatrios, equaes de recorrncia, rvores de deciso, orculos, dentre outras. Knuth (1968), Knuth (1973), Knuth (1981), Graham, Knuth e Patashnik (1989), Aho, Hoperoft e Ullman (1974), Stanat e McAllister (1977), Cormem, Leiserson e Rivest (1990), Manber (1989), Horowitz e Sahni (1978), Greene e Knuth (1982), so alguns exemplos. Artigos gerais sobre o tpico incluem Knuth (1971), Knuth (1976), Weide (1977), Lueker (1980), Flajolet e Vitter (1987). Tarjan (1985) apresenta custo amortizado: se certa parte de um algoritmo executada muitas vezes, cada vez com um tempo de execuo diferente, ao invs de considerar o pior caso em cada execuo, os diferentes custos so amortizados. Existe uma enorme quantidade de livros sobre a linguagem Pascal. O Pascal padro foi definido originalmente em Jensen e Wirth (1974). O livro de Cooper (1983) apresenta uma descrio precisa e ao mesmo tempo didtica do Pascal padro. Exerccios 1) D o conceito de algoritmo
EXERCCIOS
31
32
CAPTULO 1. INTRODUO
EXERCCIOS
33
34
12) Apresente um algoritmo para obter o maior e o segundo maior elemento de um conjunto. Apresente tambm uma anlise do algoritmo. Voc acha o seu algoritmo eficiente? Por qu? Procure comprovar suas respostas. 13) So dados 2n nmeros distintos distribuidos em dois arranjos com n elementos A e B ordenados de maneira tal que (Carvalho, 1992): A[1] > A[2] > A[3] > > A[n] e B[1] > B[2] > B[3] > > B[n]. O problema achar o n-simo maior nmero dentre estes 2n elementos. a) Obtenha um limite inferior para o nmero de comparaes necessrias para resolver este problema. b) Apresente um algoritmo cuja complexidade no pior caso seja iqual ao valor obtido na letra a), ou seja, um algoritmo timo.
Captulo 2
Estruturas de Dados Bsicas

2.1 Listas Lineares
Uma das formas mais simples de interligar os elementos de um conjunto atravs de uma lista. Lista uma estrutura onde as operaes inserir, retirar e localizar so definidas. Listas so estruturas muito flexveis porque podem crescer ou diminuir de tamanho durante a execuo de um programa, de acordo com a demanda. Itens podem ser acessados, inseridos ou retirados de uma lista. Duas listas podem ser concatenadas para formar uma lista nica, assim como uma lista pode ser partida em duas ou mais listas. Listas so adequadas para aplicaes onde no possvel prever a demanda por memria, permitindo a manipulao de quantidades imprevisveis de dados, de formato tambm imprevisvel. Listas so teis em aplicaes tais como manipulao simblica, gerncia de memria, simulao e compiladores. Na manipulao simblica os termos de uma frmula podem crescer sem limites. Em simulao dirigida por relgio pode ser criado um nmero imprevisvel de processos, os quais tm que ser escalonados para execuo de acordo com alguma ordem predefinida. Uma lista linear uma seqncia de zero ou mais itens x1, x2,,xn, onde xi de um determinado tipo e n representa o tamanho da lista linear. Sua principal propriedade estrutural envolve as posies relativas dos itens em uma dimenso. Assumindo n 1, xy1 o primeiro item da lista e xn o ltimo item da lista. Em geral xi precede xi+1 para i = 1, 2, ,n 1, e xi sucede xa_1 para i = 2, 3, , n. Em outras palavras, o elemento xi dito estar na i-sima posio da lista. Para criar um tipo abstrato de dados Lista, necessrio definir um conjunto de operaes sobre os objetos do tipo Lista. 0 conjunto de operaes a ser definido depende de cada aplicao, no existindo um conjunto de operaes que seja adequado a todas as aplicaes. Um conjunto 35
36
CAPTULO 36. ESTRUTURAS DE DADOS BSICAS
de operaes necessrio a uma maioria de aplicaes apresentado a seguir. Outras sugestes para o conjunto de operaes podem ser encontradas em Knuth (1968, p.235) e Aho, Hoperoft e Ullman (1983, pp.38-39). 1. Criar uma lista linear vazia. 2. Inserir um novo item imediatamente aps o i-simo item. 3. Retirar o i-simo item. 4. Localizar o i-simo item para examinar e/ou alterar o contedo de seus componentes. 5. Combinar duas ou mais listas lineares em uma lista nica. 6. Partir uma lista linear em duas ou mais listas. 7. Fazer uma cpia da lista linear. 8. Ordenar os itens da lista em ordem ascendente ou descendente, de acordo com alguns de seus componentes. 9. Pesquisar a ocorrncia de um item com um valor particular em algum componente. 0 item 8 acima objeto de um estudo cuidadoso no Captulo 3, e o item 9 ser tratado nos Captulos 4 e 5. Um conjunto de operaes necessrio para uma aplicao exemplo a ser apresentada mais adiante apresentado a seguir. 1. FLVazia(Lista). Faz a lista ficar vazia. 2. Insere(x, Lista). Insere x aps o ltimo item da lista. 3. Retira(p, Lista, x). Retorna o item x que est na posio p da lista, retirando-o da lista e deslocando os itens a partir da posio p+l para as posies anteriores. 4. Vazia(Lista). Esta funo retorna true se a lista est vazia; seno retorna false. 5. Imprime(Lista). Imprime os itens da lista na ordem de ocorrncia. Existem vrias estruturas de dados que podem ser usadas para representar listas lineares, cada uma com vantagens e desvantagens particulares. As duas representaes mais utilizadas so as implementaes atravs de arranjos e de apontadores. A implementao atravs de cursores (Aho, Hoperoft e Ullman, 1983, pp. 48) pode ser til em algumas aplicaes.
2.37. LISTAS LINEARES
37
2.1.1 Implementao de Listas A t r a v s de Arranjos

Em um tipo estruturado arranjo, os itens da lista so armazenados em posies contguas de memria, conforme ilustra a Figura 2.1. Neste caso a lista pode ser percorrida em qualquer direo. A insero de um novo item pode ser realizada aps o ltimo item com custo constante. A insero de um novo item no meio da lista requer um deslocamento de todos os itens localizados aps o ponto de insero. Da mesma forma, retirar um item do incio da lista requer um deslocamento de itens para preencher o espao deixado vazio.
Figura 2.1: Implementao de uma lista atravs de arranjo
O campo Item o principal componente do registro TipoLista mostrado no Programa 2.1. Os itens so armazenados em um array de tamanho suficiente para armazenar a lista. 0 campo Ultimo do registro TipoLista contm um apontador para a posio seguinte a do ltimo elemento da lista. 0 i-simo item da lista est armazenado na i-sima posio do array, 1 < i <Ultimo. A constante MaxTam define o tamanho mximo permitido para a lista. Uma possvel implementao para as cinco operaes definidas anteriormente mostrada no Programa 2.2. Observe que Lista passada como var ( por referncia), mesmo nos procedimentos em que Lista no modificada ( como, por exemplo, a funo Vazia) por razes de eficincia, porque desta forma a estrutura Lista no copiada a cada chamada do procedimento. A implementao de listas atravs de arranjos tem como vantagem a economia de memria, pois os apontadores so implcitos nesta estrutura. Como desvantagens citamos: (i) o custo para inserir ou retirar itens da lista, que pode causar um deslocamento de todos os itens, no pior caso; (ii) em aplicaes em que no existe previso sobre o crescimento da lista, a utilizao de arranjos em linguagens como o Pascal pode ser problemtica porque neste caso o tamanho mximo da lista tem que ser definido em tempo de compilao.
38
Programa 2.1: Estrutura da lista usando arranjo
2.1.2 Implementao de Listas Atravs de Apontadores

Em uma implementao de listas atravs de apontadores, cada item da lista encadeado com o seguinte atravs de uma varivel do tipo Apontador. Este tipo de implementao permite utilizar posies no contguas de memria, sendo possvel inserir e retirar elementos sem haver necessidade de deslocar os itens seguintes da lista. A Figura 2.2 ilustra uma lista representada desta forma. Observe que existe uma clula cabea que aponta para a clula que contm x1. Apesar da clula cabea no conter informao conveniente faz-la com a mesma estrutura que uma outra clula qualquer para simplificar as operaes sobre a lista. A lista constituda de clulas, onde cada clula contm um item da lista e um apontador para a clula seguinte, de acordo com o registro Clula mostrado no Programa 2.3. O registro TipoLista contm um apontador para a clula cabea e um apontador para a ltima clula da lista. Uma possvel implementao para as cinco operaes definidas anteriormente mostrada no Programa 2.4. A implementao atravs de apontadores permite inserir ou retirar itens do meio da lista a um custo constante, aspecto importante quando a lista tem que ser mantida em ordem. Em aplicaes em que no existe previso sobre o crescimento da lista conveniente usar listas encadeadas por apontadores, porque neste caso o tamanho mximo da lista no precisa ser definido a priori. A maior desvantagem deste tipo de implementao a utilizao de memria extra para armazenar os apontadores.
39
Programa 2.2: Operaes sobre listas usando posies contguas de memria
40
Programa 2.3: Estrutura da lista usando apontadores
41
Programa 2.4: Operaes sobre listas usando apontadores
42
Chave
: 1..999; NotaFinal : 0..10; Opo : array [1..3] of 1..7;

Programa 2.5: Campos do registro de um candidato
Exemplo: Considere o exemplo proposto por Furtado (1984), apresentado a seguir. Durante o exame vestibular de uma universidade, cada candidato tem direito a 3 opes para tentar uma vaga em um dos 7 cursos oferecidos. Para cada candidato lido um registro contendo os campos mostrados no Programa 2.5. O campo Chave contm o nmero de inscrio do candidato (este campo identifica de forma nica cada registro de entrada). O campo NotaFinal contm a mdia das notas do candidato. O campo Opo um vetor contendo a primeira, a segunda e a terceira opes de curso do candidato (os cursos so numerados de 1 a 7). O problema consiste em distribuir os candidatos entre os cursos, de acordo com a nota final e as opes apresentadas por cada candidato. No caso de empate sero atendidos primeiro os candidatos que se inscreveram mais cedo, isto , os candidatos com mesma nota final sero atendidos na ordem de inscrio para os exames. Um possvel caminho para resolver o problema de distribuir os alunos entre os cursos contm duas etapas, a saber: 1. ordenar os registros pelo campo NotaFinal, respeitando-se a ordem de inscrio dos candidatos; 2. percorrer cada conjunto de registros com mesma NotaFinal, iniciandose pelo conjunto de NotaFinal 10, seguido do conjunto da NotaFinal 9, e assim por diante. Para um conjunto de mesma NotaFinal tenta-se encaixar cada registro desse conjunto em um dos cursos, na primeira das trs opes em que houver vaga (se houver). Um primeiro refinamento do algoritmo pode ser visto no Programa 2.6. Para prosseguirmos na descrio do algoritmo, ns somos forados a tomar algumas decises sobre representao de dados. Uma boa maneira de representar um conjunto de registros atravs de listas. O tipo a b s t r a t o de dados Lista definido anteriormente, acompanhado do conjunto de operaes definido sobre os objetos do tipo lista, mostra-se bastante adequado ao nosso problema. O refinamento do comando "ordena os registros pelo campo NotaFinal" do Programa 2.6 pode ser realizado da seguinte forma: os registros ao se-rem lidos so armazenados em listas para cada nota, conforme ilustra a
43
Programa 2.6: Primeiro refinamento do programa Vestibular
Figura 2.3. Aps a leitura do ltimo registro os candidatos esto automaticamente ordenados por NotaFinal. Dentro de cada lista os registros esto ordenados por ordem de inscrio, desde que os registros sejam lidos na ordem de inscrio de cada candidato e inseridos nesta ordem.
Figura 2.3: Classificao dos alunos por NotaFinal Dessa estrutura passa-se para a estrutura apresentada na Figura 2.4. As listas de registros da Figura 2.3 so percorridas, inicialmente com a lista de NotaFinal 10, seguida da lista de NotaFinal 9, e assim sucessivamente. Ao percorrer uma lista, cada registro retirado e colocado em uma das listas da Figura 2.4, na primeira das trs opes em que houver vaga. Se no houver vaga o registro colocado em uma lista de reprovados. Ao final a estrutura da Figura 2.4 conter uma relao de candidatos aprovados em cada curso.
44
Programa 2.7: Segundo refinamento do programa Vestibular
Neste momento ns somos forados a tomar decises sobre a implementao do tipo abstrato de dados Lista. Considerando-se que o tamanho das listas varia de forma totalmente imprevisvel, a escolha deve cair
45
Programa 2.8: Estrutura da lista
sobre a implementao atravs de apontadores. O Programa 2.8 apresenta a definio dos tipos de dados a utilizar no ltimo refinamento do algoritmo. O refinamento final de algoritmo, descrito em Pascal, pode ser visto no Programa 2.9. Observe que o programa completamente independente da implementao do tipo abstrato de dados Lista. Isto significa que podemos trocar a implementao do tipo abstrato de dados Lista de apontador para arranjo, bastando trocar a definio dos tipos apresentada no Programa 2.8 para uma definio similar definio mostrada no Programa 2.1, acompanhada da troca dos operadores apresentados no Programa 2.4 pelos operadores apresentados no Programa 2.2. Esta substituio pode ser realizada sem causar impacto em nenhuma outra parte do cdigo.
46
CAPITULO 2. ESTRUTURAS DE DADOS BSICAS
2.2. PILHAS
47
Este exemplo mostra a importncia de se escrever programas em funo das operaes para manipular tipos abstratos de dados, ao invs de utilizar detalhes particulares de implementao. Desta forma possvel alterar a implementao das operaes rapidamente, sem haver necessidade de procurar por toda parte do cdigo onde existe referncia direta s estruturas de dados. Este aspecto particularmente importante em programas de grande porte.
2.2 Pilhas
Existem aplicaes para listas lineares nas quais inseres, retiradas e acessos a itens ocorrem sempre em um dos extremos da lista. Uma pilha uma lista linear em que todas as inseres, retiradas e geralmente todos os acessos so feitos em apenas um extremo da lista.. Os itens em uma pilha esto colocados um sobre o outro, com o item inserido mais recentemente no topo e o item inserido menos recentemente no fundo. 0 modelo intuitivo de uma pilha o de um monte de pratos em uma prateleira, sendo conveniente retirar pratos ou adicionar novos pratos na parte superior. Esta imagem est freqentemente associada com a teoria de autmato, onde o topo de uma pilha considerado como o receptculo de uma cabea de leitura/gravao que pode empilhar e desempilhar itens da pilha (Hoperoft e Ullman, 1969). As pilhas possuem a seguinte propriedade: o ltimo item 'inserido o primeiro item que pode ser retirado da lista. Por esta razo as pilhas so chamadas de listas lifo, termo formado a partir de "last-in, first-out". Existe uma ordem linear para pilhas, que a ordem do "mais recente para o menos recente". Esta propriedade torna a pilha uma ferramenta ideal para processamento de estruturas aninhadas de profundidade imprevisvel, situao em que necessrio garantir que subestruturas mais internas sejam processadas antes da estrutura que as contenham. A qualquer instante uma pilha contm uma seqncia de obrigaes adiadas, cuja ordem de remoo da pilha garante que as estruturas mais internas sero processadas antes das estruturas mais externas. Estruturas aninhadas ocorrem freqentemente na prtica. Um exemplo simples a situao em que necessrio caminhar em um conjunto de dados e guardar uma lista de coisas a fazer posteriormente (mais adi-ante veremos uma situao semelhante a esta em um programa editor de textos). 0 controle de seqncias de chamadas de subprogramas e sintaxe de expresses aritmticas so exemplos de estruturas aninhadas. As pilhas ocorrem tambm em conexo com algoritmos recursivos e estruturas de natureza recursiva, tais como as rvores.
48
Um tipo abstrato de dados Pilha, acompanhado de um conjunto de operaes, apresentado a seguir. 1. FPVazia(Pilha). Faz a pilha ficar vazia. 2. Vazia(Pilha). Esta funo retorna true se a pilha est vazia; seno retorna false. 3. Empilha(x, Pilha). Insere o item x no topo da pilha. 4. Desempilha(Pilha, x). Retorna o item x no topo da pilha, retirando-o da pilha. 5. Tamanho(Pilha). Esta funo retorna o nmero de itens da pilha. Como no caso do tipo abstrato de dados Lista apresentado na Seo 2.1, existem vrias opes de estruturas de dados que podem ser usadas para representar pilhas. As duas representaes mais utilizadas so as implementaes atravs de arranjos e de apontadores.
2.2.1 I m p l e m e n t a o de P i l h a s A t r a v s de A r r a n j o s
Em uma implementao atravs de arranjos os itens da pilha so armazenados em posies contguas de memria, conforme ilustra a Figura 2.5. Devido s caractersticas da pilha as operaes de insero e de retirada de itens devem ser implementadas de forma diferente das implementaes usadas anteriormente para listas. Como as inseres e as retiradas ocorrem no topo da pilha, um cursor chamado topo utilizado para controlar a posio do item no topo da pilha.
Figura 2.5: Implementao de uma pilha atravs de arranjo O campo Item o principal componente do registro TipoPilha mostrado no Programa 2.10. Os itens so armazenados em um array de tamanho
2.2. PILHAS
49
Programa 2.10: Estrutura da pilha usando arranjo
suficiente para armazenar a pilha. 0 outro campo do mesmo registro contm um apontador para o item no topo da pilha. A constante MaxTam define o tamanho mximo permitido para a pilha. As cinco operaes definidas sobre o TipoPilha podem ser implementadas conforme ilustra o Programa 2.11. Observe que Pilha passada como var ( por referncia), mesmo nos procedimentos em que Pilha no modificada ( como, por exemplo, a funo Vazia) por razes de eficincia, pois desta forma a estrutura Pilha no copiada a cada chamada do procedimento ou funo. 2.2.2 Implementao de Pilhas Atravs de Apontadores Assim como na implementao de listas lineares atravs de apontadores, uma clula cabea mantida no topo da pilha para facilitar a implementao das operaes empilha e desempilha quando a pilha est vazia, conforme ilustra a Figura 2.6. Para desempilhar o item xn da Figura 2.6 basta desligar a clula cabea da lista e a clula que contm xn passa a ser a clula cabea. Para empilhar um novo item basta fazer a operao contrria, criando uma nova clula cabea e colocando o novo item na antiga clula cabea. 0 campo Tamanho existe no registro TipoPilha por questo de eficincia, para evitar a contagem do nmero de itens da pilha na funo Tamanho. Cada clula de uma pilha contm um item da pilha e um apontador para outra clula, conforme ilustra o Programa 2.12. 0 registro TipoPilha contm um apontador para o topo da pilha (clula cabea) e um apontador para o fundo da pilha. As cinco operaes definidas anteriormente podem ser implementadas atravs de apontadores, conforme ilustra o Programa 2.13.
50
2.2. PILHAS
51
52
Programa 2.13: Operaes sobre pilhas usando apontadores
2.2. PILHAS
53
Exemplo: Editor de Textos. Alguns editores de texto permitem que algum caractere funcione como um " cancela-caractere", cujo efeito o de cancelar o caractere anterior na linha que est sendo editada. Por exemplo, se o cancela-caractere, ento a seqncia de caracteres UEM##FMB#G corresponde seqncia UFMG. Outro comando encontrado em editores de texto o "cancela-linha", cujo efeito o de cancelar todos os caracteres anteriores na linha que est sendo editada. Neste exemplo vamos considerar como o caractere cancela-linha. Finalmente, outro comando encontrado em editores de texto o "salta-linha" , cujo efeito o de causar a impresso dos caracteres que pertencem linha que est sendo editada, iniciando uma nova linha de impresso a partir do caractere imediatamente seguinte ao caractere salta-linha. Por exemplo, se ` @' o salta-linha, ento a seqncia de caracteres DCC@UFMG.@ corresponde s duas linhas abaixo: DCC UFMG. Vamos escrever um Editor de Texto (ET) que aceite os trs comandos descritos acima. O ET dever ler um caractere de cada vez do texto de entrada e produzir a impresso linha a linha, cada linha contendo no mximo 70 caracteres de impresso. O ET dever utilizar o tipo abstrato de dados Pilha definido anteriormente, implementado atravs de arranjo. A implementao do programa ET apresentada no Programa 2.14. Da mesma forma que o programa Vestibular, apresentado na Seo 2.1, este programa utiliza um tipo abstrato de dados sem conhecer detalhes de sua implementao. Isto significa que a implementao do tipo abstrato de dados Pilha que utiliza arranjo pode ser substituda pela implementao que utiliza apontadores mostrada no Programa 2.13, sem causar impacto no programa. O procedimento Imprime, mostrado no Programa 2.15, utilizado pelo programa ET. A seguir sugerido um texto para testar o programa ET, cujas caractersticas permite exercitar todas as partes importantes do programa.
54
CAPITULO 4. ESTRUTURAS DE DADOS BSICAS
Programa 2.14: Implementao do ET
2.5. FILAS
55
Programa 2.15: Procedimento Imprime utilizado no programa ET
2.3 Filas
Uma fila uma lista linear em que todas as inseres so realizadas em um extremo da lista, e todas as retiradas e geralmente os acessos so realizados no outro extremo da lista. 0 modelo intuitivo de uma fila o de uma fila de espera em que as pessoas no incio da fila so servidas primeiro e as pessoas que chegam entram no fim da fila. Por esta razo as filas so chamadas de listas fifo, termo formado a partir de "first-in", "first-out". Existe uma ordem linear para filas que a "ordem de chegada". Filas so utilizadas quando desejamos processar itens de acordo com a ordem "primeiro-quechega, primeiro-atendido". Sistemas operacionais utilizam filas para regular a ordem na qual tarefas devem receber processamento e recursos devem ser alocados a processos. Um possvel conjunto de operaes, definido sobre um tipo abstrato de dados Fila, definido a seguir. 1. FFVazia(Fila). Faz a fila ficar vazia. 2. Enfileira(x, Fila). Insere o item x no final da fila. 3. Desenfileira(Fila, x). Retorna o item x no incio da fila, retirando-o da fila. 4. Vazia(Fila). Esta funo retorna true se a fila est vazia; seno retorna false.
56
Figura 2.7: Implementao circular para filas
2.3.1 Implementao de Filas Atravs de Arranjos

Em uma implementao atravs de arranjos os itens so armazenados em posies contguas de memria. Devido s caractersticas da fila, a operao enfileira faz a parte de trs da fila expandir-se, e a operao Desenfileira faz a parte da frente da fila contrair-se. Conseqentemente, a fila tende a caminhar pela memria do computador, ocupando espao na parte de trs e descartando espao na parte da frente. Com poucas inseres e retiradas de itens a fila vai de encontro ao limite do espao da memria alocado para ela. A soluo para o problema de caminhar pelo espao alocado para uma fila imaginar o array como um crculo, onde a primeira posio segue a ltima, conforme ilustra a Figura 2.7. A fila se encontra em posies contguas de memria, em alguma posio do crculo, delimitada pelos apontadores Frente e Trs. Para enfileirar um item basta mover o apontador Trs uma posio no sentido horrio; para desenfileirar um item basta mover o apontador Frente uma posio no sentido horrio. O campo Item o principal componente do registro TipoFila mostrado no Programa 2.16. 0 tamanho mximo do array circular definido pela constante MaxTam. Os outros campos do registro TipoPilha contm apontadores para a parte da frente e de trs da fila. As quatro operaes definidas sobre o TipoFila podem ser implementadas conforme ilustra o Programa 2.17. Observe que para a representao circular da Figura 2.7 existe um pequeno problema: no h uma forma de distinguir uma fila vazia de uma fila cheia, pois nos dois casos os apontadores Frente e trs apontam para a mesma posio do crculo. Uma possvel sada para este problema, utilizada por Aho, Hoperoft e Ullman (1983, p.58), no utilizar todo o espao do array, deixando uma posio vazia. Neste caso a fila est cheia quando Trs+1 for igual a Frente, o que significa que existe uma clula vazia entre o fim e o incio da fila. Observe que a implementao do vetor circular realizada atravs de aritmtica modular. A aritmtica modular utilizada nos procedimentos Enfileira e Desenfileira do Programa 2.17, atravs da funo mod do Pascal.
2.7. FILAS
57
58
2.3.2 Implementao de Filas Atravs de Apontadores

Assim como em todas as outras implementaes deste captulo, uma clula cabea mantida para facilitar a implementao das operaes Enfileira e Desenfileira quando a fila est vazia, conforme ilustra a Figura 2.8. Quando a fila est vazia os apontadores Frente e trs apontam para a clula cabea. Para enfileirar um novo item basta criar uma clula nova, lig-la aps a clula que contm xn e colocar nela o novo item. Para desenfileirar o item x1 basta desligar a clula cabea da lista e a clula que contm x1 passa a ser a clula cabea.
Figura 2.8: Implementao de uma fila atravs de apontadores
A fila implementada atravs de clulas, onde cada clula contm um item da fila e um apontador para outra clula, conforme ilustra o Pro-grama 2.18. 0 registro TipoFila contm um apontador para a frente da fila (clula cabea) e um apontador para a parte de trs da fila. As quatro operaes definidas sobre o TipoFila podem ser implementadas conforme ilustra o programa 2.19.
Notas Bibliogrficas
Knuth (1968) apresenta um bom tratamento sobre listas lineares. Outras referncias relevantes sobre estruturas de dados bsicas so Aho, Hoperoft e Ullman (1983), Cormem, Leiserson e Rivest (1990) e Sedgewick (1988).
Exerccios
1) Considere a implementao de listas lineares utilizando apontadores e com clula-cabea. Considere que um dos campos do TipoItem uma Chave: TipoChave. Escreva uma funo em Pascal function EstaNaLista (Ch: TipoChave; var L: TipoLista): boolean; que retorna true se Ch estiver na lista e retorna false se Ch no estiver na lista. Considere que no h ocorrncias de chaves repetidas na lista. Determine a complexidade do seu algoritmo.
EXERCCIOS
59
Programa 2.18: Estrutura da fila usando apontadores
2) Um problema que pode surgir na manipulao de listas lineares simples o de "voltar" atrs na lista, ou seja, percorr-la no sentido inverso ao dos apontadores. A soluo geralmente adotada a incorporao clula de um apontador para o seu antecessor. Listas deste tipo so chamadas de duplamente encadeadas. A Figura 2.9 mostra uma lista deste tipo com estrutura circular e a presena de uma clula cabea. a) Declare os tipos necessrios para a manipulao da lista. b) Escreva um procedimento em Pascal para retirar da lista a clula apontada por p: procedure Retira (p: Apontador; var L: TipoLista); No deixe de considerar eventuais casos especiais. 3) Matrizes Esparsas Utilizao de Listas Atravs de Apontadores (rabe, 1992) Matrizes esparsas so matrizes nas quais a maioria das posies so preenchidas por zeros. Para estas matrizes, podemos economizar um espao significativo de memria se apenas os termos diferentes de zero forem armazenados. As operaes usuais sobre estas matrizes (somar, multiplicar, inverter, pivotar) tambm podem ser feitas em tempo muito menor se no armazenarmos as posies que contm zeros. Uma maneira eficiente de representar estruturas com tamanho varivel e/ou desconhecido atravs de alocao encadeada, utilizando listas. Vamos usar esta representao para armazenar as matrizes esparsas.
60
Programa 2.19: Operaes sobre filas usando apontadores
EXERCCIOS
61
Figura 2.9: Lista circular duplamente encadeada
Cada coluna da matriz ser representada por uma lista linear circularListas!circulares com uma clula cabea. Da mesma maneira, cada linha da matriz tambm ser representada por uma lista linear circular com uma clula cabea. Cada clula da estrutura, alm das clulascabea, representar os termos diferentes de zero da matriz e devem ter o seguinte tipo:
62
Figura 2.10: Exemplo de Matriz Esparsa
A representao da matriz A pode 'ser vista na Figura 2.10. Com esta representao, uma matrix esparsa m x n com r elementos diferentes de zero gastar (m+n+r) clulas. E bem verdade que cada clula ocupa vrios bytes na memria; no entanto, o total de memria usado ser menor do que as m x n posies necessrias para representar a matriz toda, desde que r seja suficientemente pequeno. Dada a representao acima, o trabalho consiste em desenvolver cinco procedimentos em Pascal, conforme especificao abaixo: a) procedure LeMatriz (var A: Matriz); Este procedimento l de algum arquivo de entrada os elementos diferentes de zero de uma matriz e monta a estrutura especificada acima. Considere que a entrada consiste dos valores de m e n ( nmero de linhas e de colunas da matriz) seguidos de triplas (i, j, valor) para os elementos diferentes de zero da matriz. Por
EXERCCIOS exemplo, para a matriz acima, a entrada seria: 4, 1, 2, 2, 4, 4, 4, 4 1, 1, 3, 1, 3, 4, 50.0 10.0 20.0 -30.0 -60.0 5.0
63
b) procedure ApagaMatriz (var A: Matriz); Este procedimento devolve todas as clulas da matriz A para a rea de memria disponvel (use a procedure dispose). c) procedure SomaMatriz (var A, B, C: Matriz); Este procedimento recebe como parmetros as matrizes A e B, devolvendo em C a soma de A com B. d) procedure MultiplicaMatriz (var A, B, C: Matriz); Este procedimento recebe como parmetros as matrizes A e B, devolvendo em C o produto de A por B. e) procedure ImprimeMatriz (var A: Matriz); Este procedimento imprime (uma linha da matriz por linha da sada) a matriz A, inclusive os elementos iguais a zero. Para inserir e retirar clulas das listas que formam a matriz, crie procedimentos especiais para este fim. Por exemplo, um procedimento
procedure Insere (i, j: integer; v: real; var A: Matriz); para inserir o valor v na linha i, coluna j da matriz A ser til tanto na procedure LeMatriz quanto na procedure SomaMatriz. As matrizes a serem lidas para testar os procedimentos so: a) A mesma da Figura 2.10 deste enunciado;
64
CAPTULO 2. ESTRUTURAS DE DADOS BSICAS Os procedimentos devero ser testados com o seguinte programa:
program TestaMatrizesEsparsas; ... ... begin ... LeMatriz (A); ImprimeMatriz (A); LeMatriz (B); ImprimeMatriz (B); SomaMatriz (A, B, C); ImprimeMatriz (C); ApagaMatriz (C); MultiplicaMatriz (A, B, C); ImprimeMatriz (C); ApagaMatriz (B); ApagaMatriz (C); LeMatriz (B); ImprimeMatriz (A); ImprimeMatriz (B); SomaMatriz (A, B, C); ImprimeMatriz (C); MultiplicaMatriz (A, B, C); ImprimeMatriz (C); MultiplicaMatriz (B, B, C); ImprimeMatriz (B); ImprimeMatriz (B); ImprimeMatriz (C); ApagaMatriz (A); ApagaMatriz (B); ApagaMatriz (C); ... end. { TestaMatrizesEsparsas } O que deve ser apresentado: a) Listagem do programa em Pascal. b) Listagem dos testes executados. c) Descrio sucinta (por exemplo, desenho), das estruturas de da-dos e as decises tomadas relativas aos casos e detalhes de especificao que porventura estejam omissos no enunciado. d) Estudo da complexidade do tempo de execuo dos procedimentos implementados e do programa como um todo (notao 0 ) . obrigatrio o uso de alocao dinmica de memria para implementar as listas de adjacncia que representam as matrizes. A anlise de complexidade deve ser feita em funo de m, n (dimenses da matriz) e r (nmero de elementos diferente de zero). 4) Considere F uma fila no vazia e P uma pilha vazia. Usando apenas a varivel temporria x, e as quatro operaes
e os dois testes P=vazio e F=vazio, escreva um algoritmo para reverter a ordem dos elementos em F.
EXERCCIOS
65
5) Duas pilhas podem coexistir em um mesmo vetor, uma crescendo em um sentido, e a outra no outro. Duas filas, ou uma pilha e uma fila podem tambm ser alocadas no mesmo vetor com o mesmo grau de eficincia ? Por qu ? 6) Como resolver o problema da representao por alocao seqencial (usando uma regio fixa de memria) para mais de duas pilhas ? 7) Alterao do ET Alterar a especificao do programa ET, apresentado na seo 2.2.2, para aceitar o comando cancela palavra, cujo efeito cancelar a palavra anterior na linha que est sendo editada. Por exemplo, se `$' o CancelaPalavra, ento a seqncia de caracteres NO CANCELA$$ CANCELA LINHA$ PALAVRA corresponde seqncia CANCELA PALAVRA. Altere o programa de acordo com a nova especificao proposta. Para testar o programa utilize o texto da pgina 53, com as seguintes alteraes: a) insira o caractere $ aps a palavra "extras" na terceira linha, b) insira dois caracteres $$ aps as palavras "Ser que" na penltima linha do texto. 8) Existem partes de sistemas operacionais que cuidam da ordem em que os programas devem ser executados. Por exemplo, em um sistema de computao de tempo-compartilhado ("time-shared") existe a necessidade de manter um conjunto de processos em uma fila, esperando para serem executados. Escreva um programa em Pascal que seja capaz de ler uma srie de solicitaes para: (i) incluir novos processos na fila de processos; (ii) retirar da fila o processo com o maior tempo de espera; (iii) imprimir o contedo da lista de processos em um determinado momento. Assuma que cada processo representado por um registro composto por um nmero identificador do processo. Utilize o tipo abstrato de dados Fila apresentado na Seo 2.3. 9) Se voc tem que escolher entre uma representao por lista encadeada ou uma representao usando posies contguas de memria para um vetor, quais informaes so necessrias para voc selecionar uma representao apropriada? Como estes fatores influenciam a escolha da representao?
66
10) Filas, Simulao (rabe, 1992) O objetivo deste exerccio simular os padres de aterrissagem e decolagem em um aeroporto. Suponha um aeroporto que possui 3 pistas, numeradas 1, 2 e 3. Existem 4 (quatro) "prateleiras" de espera para aterrissagem, duas para cada uma das pistas 1 e 2. Aeronaves que se aproximam do aeroporto devem se integrar a uma das prateleiras (filas) de espera, sendo que estas filas devem procurar manter o mesmo tamanho. Assim que um avio entra em uma fila de aterrissagem, ele recebe um nmero de identificao ID e um outro nmero inteiro que indica o nmero de unidades de tempo que o avio pode permanecer na fila antes que ele tenha que descer (do contrrio seu combustvel termina e ele cai). Existem tambm filas para decolagem, uma para cada pista. Os avies que chegam nestas filas tambm recebem uma identificao ID. Estas filas tambm devem procurar manter o mesmo tamanho. A cada unidade de tempo, de 0 a 3 aeronaves podem chegar nas filas de decolagem e de 0 a 3 aeronaves podem chegar nas prateleiras. A cada unidade de tempo, cada pista pode ser usada para um pouso ou uma decolagem. A pista 3 em geral s usada para decolagens, a no ser que um dos avies nas prateleiras fique sem combustvel, quando ento ela deve ser imediatamente usada para pouso. Se apenas uma aeronave est com falta de combustvel, ela pousar na pista 3; se mais de um avio estiver nesta situao, as outras pistas podero ser utilizadas (a cada unidade de tempo no mximo 3 avies podero estar nesta desagradvel situao). Utilize inteiros pares (mpares) sucessivos para a ID dos avies chegando nas filas de decolagem (aterrissagem). A cada unidade de tempo, assuma que os avies entram nas filas antes que aterrissagem ou decolagens ocorram. Tente projetar um algoritmo que no permita o crescimento excessivo das filas de aterrissagem ou decolagem. Coloque os avies sempre no final das filas, que no devem ser reordenadas. A sada do programa dever indicar o que ocorre a cada unidade de tempo. Periodicamente imprima: a) o contedo de cada fila; b) o tempo mdio de espera para decolagem; c) o tempo mdio de espera para aterrissagem; e d) o nmero de avies que aterrissam sem reserva de combustvel. Os itens b e c acima devem ser calculados para os avies que j decolaram ou pousaram, respectivamente. A sada do programa deve ser auto-explicativa e fcil de entender.
EXERCCIOS
67
A entrada poderia ser criada manualmente, mas o melhor utilizar um gerador de nmeros aleatrios. Para cada unidade de tempo, a entrada deve ter as seguintes informaes: a) nmero de avies (0-3) chegando nas filas de aterrissagem com respectivas reservas de combustvel (de 1 a 20 em unidades de tempo); b) nmero de avies (0-3) chegando nas filas de decolagem. 0 que deve ser apresentado: a) Listagem dos programas em Pascal. b) Listagem dos testes executados. c) Descrio sucinta (por exemplo, desenho), das estruturas de da-dos e as decises tomadas relativas aos casos e detalhes de especificao que porventura estejam omissos no enunciado. d) Estudo da complexidade do tempo de execuo dos procedimentos implementados e dos programas como um todo (notao O).
Captulo 3
Ordenao
Os algoritmos de ordenao constituem bons exemplos de como resolver problemas utilizando computadores. As tcnicas de ordenao permitem apresentar um conjunto amplo de algoritmos distintos para resolver uma mesma tarefa. Dependendo da aplicao, cada algoritmo considerado possui uma vantagem particular sobre os outros. Alm disso, os algoritmos ilustram muitas regras bsicas para manipulao de estruturas de dados. Ordenar corresponde ao processo de rearranjar um conjunto de objetos em uma ordem ascendente ou descendente. O objetivo principal da ordenao facilitar a recuperao posterior de itens do conjunto ordenado. Imagine como seria difcil utilizar um catlogo telefnico se os nomes das pessoas no estivessem listados em ordem alfabtica. A atividade de colocar as coisas em ordem est presente na maioria das aplicaes onde os objetos armazenados tm que ser pesquisados e recuperados, tais como dicionrios, ndices de livros, tabelas e arquivos. Antes de considerarmos os algoritmos propriamente ditos, necessrio apresentar alguma notao. Os algoritmos trabalham sobre os registros de um arquivo. Apenas uma parte do registro, chamada chave, utilizada para controlar a ordenao. Alm da chave podem existir outros componentes em um registro, os quais no tm influncia no processo de ordenar, a no ser pelo fato de que permanecem com a mesma chave. A estrutura de dados registro a indicada para representar os itens componentes de um arquivo, conforme ilustra o Programa 3.1. A escolha do tipo para a chave arbitrria. Qualquer tipo sobre o qual exista uma regra de ordenao bem-definida pode ser utilizado. As ordens numrica e alfabtica so as usuais. Um mtodo de ordenao dito estvel se a ordem relativa dos itens com chaves iguais mantm-se inalterada pelo processo de ordenao. Por exemplo, se uma lista alfabtica de nomes de funcionrios de uma empresa ordenada pelo campo salrio, ento um mtodo estvel produz uma lista 69
70
CAPITULO 20. ORDENAO
Programa 3.1: Estrutura de um item do arquivo
em que os funcionrios com mesmo salrio aparecem em ordem alfabtica. Alguns dos mtodos de ordenao mais eficientes no so estveis. Se a estabilidade importante ela 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. Os mtodos de ordenao so classificados em dois grandes grupos. Se o arquivo a ser ordenado cabe todo na memria principal, ento o mtodo de ordenao chamado de ordenao interna. Neste caso o nmero de registros a ser ordenado pequeno o bastante para caber em um array do Pascal. Se o arquivo a ser ordenado no cabe na memria principal e, por isso, tem que ser armazenado em fita ou disco, ento o mtodo de ordenao chamado de ordenao externa. A principal diferena entre os dois mtodos que, em um mtodo de ordenao interna, qualquer registro pode ser imediatamente acessado, enquanto, em um mtodo de ordenao externa, os registros so acessados seqencialmente ou em grandes blocos. A grande maioria dos mtodos de ordenao so baseados em comparaes das chaves. Os mtodos a serem apresentados a seguir so deste tipo. Entretanto, existem mtodos de ordenao que utilizam o princpio da distribuio. Por exemplo, considere o problema de ordenar um baralho com 52 cartas no ordenadas. Suponha que ordenar o baralho implica em colocar as cartas de acordo com a ordem
Para ordenar por distribuio, basta seguir os passos abaixo: 1. Distribuir as cartas abertas em 13 montes, colocando em cada monte todos os ases, todos os dois, todos os trs, ..., todos os reis. 2. Colete os montes na ordem acima (s no fundo, depois os dois, etc.), at o rei ficar no topo). 3. Distribua novamente as cartas abertas em 4 montes, colocando em cada monte todas as cartas de paus, todas as cartas de ouros, todas as cartas de copas e todas as cartas de espadas.
3.21. ORDENAO INTERNA
71
4. Colete os montes na ordem indicada acima (paus, ouros, copas e espadas). Mtodos como o ilustrado acima so tambm conhecidos como ordenao digital, radixsort ou bucketsort. Neste caso no existe comparao entre chaves. As antigas classificadoras de cartes perfurados tambm utilizam o princpio da distribuio para ordenar uma massa de cartes. Uma das dificuldades 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 se tornar proibitiva. 0 custo para ordenar um arquivo com n elementos da ordem de 0(n), pois cada elemento manipulado algumas vezes. 0 principal objetivo deste captulo apresentar os mtodos de ordenao mais importantes sob o ponto de vista prtico. Cada mtodo ser apresentado atravs de um exemplo, e o algoritmo associado ser refinado at o nvel de um procedimento Pascal executvel. A seguir vamos estudar os principais mtodos de ordenao atravs de comparaes de chaves.
3.1 Ordenao Interna

0 aspecto predominante na escolha de um algoritmo de ordenao o tempo gasto para ordenar um arquivo. Para algoritmos de ordenao interna as medidas de complexidade relevantes contam o nmero de comparaes entre chaves e o nmero de movimentaes (ou trocas) de itens do arquivo. Seja C uma funo de complexidade tal que C(n) o nmero de comparaes entre chaves, e seja M uma funo de complexidade tal que M(n) o nmero de movimentaes de itens no arquivo, onde n o nmero de itens do arquivo. A quantidade extra de memria auxiliar utilizada pelo algoritmo tambm um aspecto importante. 0 uso econmico da memria disponvel um requisito primordial na ordenao interna. Os mtodos que utilizam a estrutura vetor e que executam a permutao dos itens no prprio vetor, exceto para a utilizao de uma pequena tabela ou -pilha, so os preferidos. Os mtodos que utilizam listas encadeadas necessitam n palavras extras de memria para os apontadores, e so utilizados apenas em algumas situaes especiais. Os mtodos que necessitam de uma quantidade extra de memria para armazenar uma outra cpia dos itens a serem ordenados possuem menor importncia. Os mtodos de ordenao interna so classificados em mtodos simples e mtodos eficientes. Os mtodos simples so adequados para pequenos arquivos e requerem 0(n2) comparaes, enquanto os mtodos eficientes so adequados para arquivos maiores e requerem 0 ( n log n) comparaes. Os mtodos simples produzem programas pequenos, fceis de entender, ilustrando com simplicidade os princpios de ordenao por comparao. Alm
72
C A P T U L O 2 2 . ORDENAO
Programa 3.2: Tipos utilizados na implementao dos algoritmos
do mais, existe um grande nmero de situaes em que melhor usar os mtodos simples do que usar os mtodos mais sofisticados. Apesar de os mtodos mais sofisticados usarem menos comparaes, estas comparaes so mais complexas nos detalhes, o que torna os mtodos simples mais eficientes para pequenos arquivos. Na implementao dos algoritmos de ordenao interna, sero utilizados o tipo de dados ndice, o tipo de dados Vetor e a varivel A apresentados no Programa 3.2. 0 tipo Vetor do tipo estruturado arranjo, composto por uma repetio do tipo de dados Item apresentado anteriormente no Programa 3.1. Repare que o ndice do vetor vai de 0 at n , para poder armazenar chaves especiais chamadas sentinelas.
3.1.1 Ordenao por Seleo

Um dos algoritmos mais simples de ordenao o mtodo j apresentado na Seo 1.4, cujo princpio de funcionamento o seguinte: selecione o menor item do vetor e a seguir troque-o com o item que est na primeira posio do vetor. Repita estas duas operaes com os n 1 itens restantes, depois com os n 2 itens, at que reste apenas um elemento. 0 mtodo ilustrado para o conjunto de seis chaves apresentado na Figura 3.1. As chaves em negrito sofreram uma troca entre si. 1 Chaves iniciais: O i= 2 A i=3 A i=4 A i=5 A i=6 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
Figura 3.1: Exemplo de ordenao por seleo
O Programa 3.3 mostra a implementao do algoritmo, para um conjunto de itens implementado como um tipo Vetor.
73
O comando de atribuio Min := j executado em mdia cerca de n log n vezes, conforme pode ser verificado em Knuth (1973, exerccios 5.2.3.3-6) . Este valor difcil de obter exatamente: ele depende do nmero de vezes que c, menor do que todas as chaves anteriores cl, c2, ..., quando estamos percorrendo as chaves c1, c2, ... , c, . 0 algoritmo de ordenao por seleo um dos mtodos de ordenao mais simples que existem. Alm disso, o mtodo possui um comportamento espetacular quanto ao nmero de movimentos de registros, cujo tempo de execuo linear no tamanho da entrada, o que muito difcil de ser batido por qualquer outro mtodo. Conseqentemente, este o algoritmo a ser utilizado para arquivos com registros muito grandes. Em condies normais, com chaves do tamanho de uma palavra, este mtodo bastante interessante para arquivos com at 1000 registros. Como aspectos negativos cabe registrar que: (i) o fato do arquivo j estar ordenado no ajuda em nada pois o custo continua quadrtico; (ii) o algoritmo no estvel, pois ele nem sempre deixa os registros com chaves iguais na mesma posio relativa.
3.1.2 O r d e n a o por I n s e r o
Este o mtodo preferido dos jogadores de cartas. Em cada passo, a partir de i=2, o i-simo item da seqncia fonte apanhado e transferido para a seqncia destino, sendo inserido no seu lugar apropriado. O mtodo
74
CAPTULO 3. ORDENAO
ilustrado para as mesmas seis chaves utilizadas anteriormente, conforme apresentado na Figura 3.2. As chaves em negrito representam a seqncia destino.
Figura 3.2: Exemplo de ordenao por insero 0 Programa 3.4 mostra a implementao do algoritmo, para um conjunto de itens implementado como um tipo Vetor. 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. Neste processo de alternar comparaes e movimentos de registros existem duas condies distintas que podem causar a terminao do processo: (i) um item com chave menor que o item em considerao encontrado; (ii) o final da seqncia destino atingido esquerda. A melhor soluo para a situao de um anel com duas condies de terminao a utilizao de um registro sentinela: na posio zero do vetor colocamos o prprio registro em considerao. Para tal o ndice do vetor tem que ser estendido para 0..n. Anlise No anel mais interno, na i-sima iterao o valor de Ci :
75
O nmero mnimo de comparaes e movimentos ocorre quando os itens esto originalmente em ordem, e o nmero mximo ocorre quando os itens esto originalmente na ordem reversa, o que indica um comportamento natural para o algoritmo. Para arquivos j ordenados o algoritmo descobre a um custo 0(n) que cada item j est no seu lugar. Logo, o mtodo da insero o mtodo a ser utilizado quando o arquivo est "quase" ordenado. E tambm um bom mtodo quando se deseja adicionar uns poucos itens a um arquivo j ordenado e depois obter um outro arquivo ordenado: neste caso o custo linear. O algoritmo de ordenao por insero quase to simples quanto o algoritmo de ordenao por seleo. Alm disso, o mtodo de ordenao por insero estvel, pois ele deixa os registros com chaves iguais na mesma posio relativa.
76
CAPTULO 3. ORDENAO
3.1.3 Shellsort
Shell (1959) props uma extenso do algoritmo de ordenao por insero. O mtodo da insero troca itens adjacentes quando est procurando o ponto de insero na seqncia destino. Se o menor item estiver na posio mais a direita no vetor ento o nmero de comparaes e movimentaes igual a n 1 para encontrar o seu ponto de insero. O mtodo de Shell contorna este problema permitindo trocas de registros que esto distantes um do outro. Os itens que esto separados h posies so rearranjados de tal forma que todo h-simo item leva a uma seqncia ordenada. Tal seqncia dita estar h-ordenada. A Figura 3.3 mostra como um arquivo de seis itens ordenado usando os incrementos 4, 2, e 1 para h.
Figura 3.3: Exemplo de ordenao usando Shellsort
Na primeira passada (h = 4), o O comparado com o N (posies 1 e 5) e trocados; a seguir o R comparado com o A (posies 2 e 6) e trocados. Na segunda passada (h = 2), N, D e O, nas posies 1, 3 e 5, so rearranjados para resultar em D, N e O nestas mesmas posies; da mesma forma A, E e R, nas posies 2, 4 e 6, so comparados e mantidos nos seus lugares. A ltima passada (h = 1) corresponde ao algoritmo de insero: entretanto, nenhum item tem que se mover para posies muito distantes. Vrias seqncias para h tm sido experimentadas. Knuth (1973, p.95) mostrou experimentalmente que a escolha do incremento para h, mostrada abaixo, difcil de ser batida por mais de 20% em eficincia no tempo de execuo:
A seqncia para h corresponde a 1, 4, 13, 40, 121, 364, 1093, 3280, .... O Programa 3.5 mostra a implementao do algoritmo, para a seqncia mostrada acima. Observe que no foram utilizados registros sentinelas porque teramos que utilizar h sentinelas, uma para cada h-ordenaes.
Anlise
A razo pela qual este mtodo eficiente ainda no conhecida, porque ningum ainda foi capaz de analisar o algoritmo. A sua anlise contm al-
77
guns problemas matemticos muito difceis, a comear pela prpria seqncia de incrementos: o pouco que se sabe que cada incremento no deve ser mltiplo do anterior. Para a seqncia de incrementos utilizada no Programa 3.5 existem duas conjeturas para o nmero de comparaes, a saber:
Shellsort uma tima opo para arquivos de tamanho moderado (da ordem de 5000 registros), mesmo porque sua implementao simples e requer uma quantidade de cdigo pequena. Existem mtodos de ordenao mais eficientes, mas so tambm muito mais complicados para implementar. O tempo de execuo do algoritmo sensvel ordem inicial do arquivo. Alm disso o mtodo no estvel, pois ele nem sempre deixa registros com chaves iguais na mesma posio relativa.
78
CAPTULO 3. ORDENAO
3.1.4 Quicksort
Quicksort o algoritmo de ordenao interna mais rpido que se conhece para uma ampla variedade de situaes, sendo provavelmente mais utilizado do que qualquer outro algoritmo. O algoritmo foi inventado por C. A. R. Hoare em 1960, quando visitava a Universidade de Moscou como estudante. O algoritmo foi publicado mais tarde por Hoare (1962), aps uma srie de refinamentos. A idia bsica a de partir o problema de ordenar um conjunto com n itens em dois problemas menores. A seguir, os problemas menores so ordenados independentemente e depois os resultados so combinados para produzir a soluo do problema maior. A parte mais delicada deste mtodo relativa ao procedimento partio, o qual tem que rearranjar o vetor A[Esq..Dir] atravs da escolha arbitrria de um item x do vetor chamado piv, de tal forma que ao final o vetor A est particionado em uma parte esquerda com chaves menores ou iguais a x e uma parte direita com chaves maiores ou iguais a x. Este comportamento pode ser descrito pelo seguinte algoritmo:
79
80
CAPITULO 30. ORDENAO
Anlise
Uma caracterstica interessante do Quicksort a sua ineficincia para arquivos j ordenados quando a escolha do piv inadequada. Por exemplo, a escolha sistemtica dos extremos de um arquivo j ordenado leva ao seu pior caso. Neste caso, as parties sero extremamente desiguais, e o procedimento Ordena ser chamado recursivamente n vezes, eliminando apenas um item em cada chamada. Esta situao desastrosa pois o nmero de comparaes passa a cerca de n2/2, e o tamanho da pilha necessria para as chamadas recursivas cerca de n. Entretanto, o pior caso pode ser evitado atravs de pequenas modificaes no programa, conforme veremos mais adiante.
81
A melhor situao possvel ocorre quando cada partio divide o arquivo em duas partes iguais. Logo, C(n) = 2C(n/2) + n onde C ( n / 2 ) representa o custo de ordenar uma das metades e n o custo de examinar cada item. A soluo para esta recorrncia C ( n ) 1 , 4 n logn o que significa que em mdia o tempo de execuo do Quicksort O ( n log n ) . Quicksort extremamente eficiente para ordenar arquivos de dados. O mtodo necessita de apenas uma pequena pilha como memria auxiliar, e requer cerca de n log n operaes em mdia para ordenar n itens. Como aspectos negativos cabe ressaltar que: (i) a verso recursiva do algoritmo tem um pior caso que 0(n2) operaes; (ii) a implementao do algoritmo muito delicada e :difcil: um pequeno engano pode levar a efeitos inesperados para algumas entradas de dados; (iii) o mtodo no estvel. Uma vez que se consiga uma implementao robusta para o Quicksort, este deve ser o algoritmo preferido para a maioria das aplicaes. No caso de se necessitar de um programa utilitrio para uso freqente, ento vale a pena investir na obteno de uma implementao do algoritmo. Por exemplo, como evitar o pior caso do algoritmo? A melhor soluo para este caso escolher trs itens quaisquer do arquivo e usar a mediana dos trs como o item divisor na partio.
3.1.5 Heapsort
Heapsort um mtodo de ordenao cujo princpio de funcionamento o mesmo princpio utilizado para a ordenao por seleo, a saber: selecione o menor item do vetor e a seguir troque-o com o item que est na primeira posio do vetor; repita estas duas operaes com os n 1 itens restantes, depois com os n 2 itens, e assim sucessivamente. 0 custo para encontrar o menor (ou o maior) item entre n itens custa n 1 comparaes. Este custo pode ser reduzido atravs da utilizao de uma estrutura de dados chamada fila de prioridades. Devido a enorme importncia das filas de prioridades para muitas aplicaes (inclusive ordenao), a prxima seo ser dedicada ao seu estudo. Filas de Prioridades No estudo de listas lineares, no Captulo 2, vimos que a operao de desempilhar um item de uma pilha retira o ltimo item inserido (o mais novo), e a operao de desenfileirar um item de uma fila retira o primeiro item inserido
82
CAPTULO 32. ORDENAO
(o mais velho). Em muitas situaes necessrio uma estrutura de dados que suporte as operaes de inserir um novo item e retirar o item com a maior chave. Tal estrutura de dados chamada fila de prioridades, porque a chave de cada item reflete sua habilidade relativa de abandonar o conjunto de itens rapidamente. Filas de prioridades so utilizadas em um grande nmero de aplicaes. Sistemas operacionais usam filas de prioridades, onde as chaves representam o tempo em que eventos devem ocorrer. Alguns 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 do computador por uma nova pgina. As operaes mais comuns sobre o tipo fila de prioridades so: adicionar um novo item ao conjunto e extrair o item do conjunto que contenha o maior (menor) valor. Entretanto, filas de prioridades permitem a execuo de um grande nmero de operaes de forma eficiente. Um tipo abstrato de dados Fila de Prioridades, contendo registros com chaves numricas (prioridades), deve suportar algumas das seguintes operaes: 1. Constri uma fila de prioridades a partir de um conjunto com n itens. 2. Insere um novo item. 3. Retira o item com maior chave. 4. Substitui o maior item por um novo item, a no ser que o novo item seja maior. 5. Altera a prioridade de um item. 6. Remove um item qualquer. 7. Ajunta duas filas de prioridades em uma nica. A nica diferena entre a operao substitui e as operaes encadeadas insere/retira que as operaes encadeadas fazem com que a fila de prioridades aumente temporariamente de tamanho. A operao constri equivalente ao uso repetido da operao insere, e a operao altera equivalente a operao remove seguida de insere. Uma representao bvia para uma fila de prioridades uma lista linear ordenada. Neste caso Constri leva tempo O(n log n), insere 0(n) e retira 0( 1). Outra representao atravs de uma lista linear no ordenada, na qual a operao constri tem custo linear, insere 0(1), retira 0(n) e ajunta 0(1) para implementaes atravs de apontadores e 0(n) para implementaes atravs de arranjos, onde n representa o tamanho da menor fila de prioridades.
83
Filas de prioridades podem ser melhor representadas por estruturas de dados chamadas heaps. A operao constri tem custo linear, e insere, retira, substitui e altera tem custo logartmico. Para implementar a operao ajunta de forma eficiente e ainda preservar um custo logartmico para as operaes insere, retira, substitui e altera necessrio utilizar estruturas de dados mais sofisticados, tais como rvores binomiais (Vuillemin, 1978). Qualquer algoritmo para filas de prioridades pode ser transformado em um algoritmo de ordenao, atravs do uso repetido da operao insere para construir a fila de prioridades, seguido do uso repetido da operao retira para receber os itens na ordem reversa. Neste esquema, 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. Heaps Uma estrutura de dados eficiente para suportar as operaes constri, insere, retira, substitui e altera o heap, proposta por Williams (1964). Um heap definido como 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 . Esta ordem pode ser facilmente visualizada se a seqncia de chaves for desenhada em uma rvore binria, onde as linhas que saem de uma chave levam a duas chaves menores no nvel inferior, conforme ilustra a Figura. 3.6. Esta estrutura conhecida como uma rvore binria completa1: o primeiro nodo chamado raiz, os nodos abaixo de cada nodo so chamados nodos filhos, e o nodo acima de cada nodo chamado nodo pai. Um estudo mais detalhado de rvores ser apresentado no Captulo 4. Observe que as chaves na rvore da Figura 3.6 satisfazem a condio do heap: a chave em cada nodo maior do que as chaves em seus filhos, se eles existirem. Conseqentemente, a chave no nodo raiz a maior chave do conjunto.
' Uma rvore binria completa uma rvore binria com os nodos numerados de 1 a n, onde o nodo Lk/2 j o pai do nodo k, para 1 < k < n. Em outras palavras, em uma rvore binria completa os nodos externos aparecem em dois nveis adjacentes e os nodos no nvel mais baixo esto posicionados mais esquerda.
84
CAPITULO 3. ORDENAO
Figura 3.6: rvore binria completa
Uma rvore binria completa pode ser representada por um array, conforme ilustra a Figura 3.7. Esta representao extremamente compacta e, alm disso, permite caminhar pelos nodos da rvore facilmente: os filhos de um nodo i esto nas posies 2i e 2i + 1 (caso existam), e o pai de um nodo i est na posio i div 2.
Figura 3.7: rvore binria completa representada por um arranjo Um heap uma rvore binria completa na qual cada nodo satisfaz a condio do heap apresentada acima. No caso da representao do heap por 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, a partir da raiz at o nvel inferior da rvore.
85
86
CAPTULO 3. ORDENAO
A partir do heap obtido pelo procedimento Constri, pega-se o item na posio 1 do vetor (raiz do heap) e troca-se com o item que est na posio n do vetor. A seguir, basta usar o procedimento Refaz para reconstituir o heap para os itens A[1], A[2], ..., A[n -1]. Repita estas duas operaes com os n 1 itens restantes, depois com os n 2 itens, at que reste apenas um item. Este mtodo exatamente o que o Heapsort faz, conforme ilustra a Figura 3. 9. 0 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 3.9, o item D volta para a posio 5 aps passar pelas posies 1 e 2.
Figura 3.9: Exemplo de ordenao usando Heapsort
O Programa 3.9 mostra a implementao do algoritmo, para um conjunto de itens implementado como um tipo Vetor.
Anlise
A primeira vista o algoritmo no parece eficiente, pois as chaves so movimentadas vrias vezes. Entretanto, 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! Heapsort no recomendado para arquivos com poucos registros, por causa do tempo necessrio para construir o heap, bem como porque o anel interno do algoritmo bastante complexo, se comparado com o anel interno do Quicksort. De fato, Quicksort , em mdia, cerca de duas vezes mais rpido que o Heapsort. Entretanto, Heapsort melhor que o Shellsort para grandes arquivos. Um aspecto importante a favor do Heapsort que o seu comportamento O(n log n), qualquer que seja a entrada. Aplicaes que no podem tolerar eventualmente um caso desfavorvel devem usar o Heapsort. Um aspecto negativo sobre o Heapsort que o mtodo no estvel.
87
P r o g r a m a 3 . 9 : P r o c ed i m en to H ea p s o r t
3.1 . 6 C o m p a r a o Ent re o s Mt o d o s
A ordenao interna utilizada quando todos os registros do arquivo ca-bem na memria principal. Neste captulo apresentamos cinco mtodos de ordenao interna atravs de comparao de chaves. Foram estudados dois mtodos simples (Seleo e Insero) que requerem 0(n2) comparaes e trs mtodos eficientes (Shellsort, Quicksort e Heapsort) que requerem 0(n log n) comparaes (apesar de no se conhecer analiticamente o comportamento do Shellsort, ele considerado um mtodo eficiente). As Tabelas 3.1, 3.2 e 3.3 apresentam quadros comparativos do tempo total real para ordenar arranjos com 500, 5.000, 10.000 e 30.000 registros na ordem aleatria, na ordem ascendente e na ordem descendente, respectivamente. Em cada tabela, o mtodo que levou menos tempo real para executar recebeu o valor 1 e os outros receberam valores relativos a ele. Assim, na Tabela 3.1, o Shellsort levou o dobro do tempo do Quicksort para ordenar 30.000 registros.
88
500 Insero Seleo Shellsort Quicksort Heapsort 11.3 16.2 1.2 1 1.5 5000 87 124 1.6 1 1.6
CAPTULO 38. ORDENAO

10000 161 228 1.7 1 1.6 30000 2 1 1.6
Tabela 3.1: Ordem aleatria dos registros
Insero Seleo Shellsort Quicksort Heapsort
500 1 128 3.9 4.1 12.2
1 5000 110000 1 1 1524 3066 6.8 7.3 6.3 6.8 20.8 22.4
30000 1 8.1 7.1 24.6
Tabela 3.2: Ordem ascendente dos registros

500 40.3 29.3 1.5 1 2.5 5000 305 221 1.5 1 2.7 10000 575 417 1.6 1 2.7 30000 1.6 1 2.9
Insero Seleo Shellsort Quicksort Heapsort
Tabela 3.3: Ordem descendente dos registros
A seguir, apresentamos algumas observaes sobre cada um dos 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, esta relao se inverte. 5. O Insero o mais rpido para qualquer tamanho se os elementos esto ordenados; este seu melhor caso, que 0(n). Ele o mais lento para qualquer tamanho se os elementos esto em ordem descendente; este o seu pior caso.
89
6. Entre os algoritmos de custo 0(n2) o Insero melhor para todos os tamanhos aleatrios experimentados. A Tabela 3.4 mostra a influncia da ordem inicial do arquivo sobre cada um dos trs mtodos mais eficientes. Ao observar a tabela podemos notar que:
Shellsort Asc Des Ale 5000 1 1.5 2.9 10000 1 1.6 3.1 30000 1 1.5 3.7 5000 1 1.1 1.9 Quicksort 10000 1 1.1 2.0 30000 1 1.1 2.0 5000 1.1 1 1.1 Heapsort 10000 1.1 1 1 30000 1.1 1 1
T a b e l a 3.4: Influncia da ordem inicial
1. O Shellsort bastante sensvel ordenao ascendente ou descendente da entrada; para arquivos do mesmo tamanho executa mais rpido se o arquivo estiver ordenado do que se os elementos forem aleatrios. 2. O Quicksort sensvel ordenao ascendente ou descendente da entrada; para arquivos do mesmo tamanho executa mais rpido se o arquivo estiver ordenado do que se os elementos forem aleatrios. Ele o mais rpido para qualquer tamanho se os elementos esto em ordem ascendente. 3. O Heapsort praticamente no sensvel ordenao da entrada; para arquivos do mesmo tamanho executa 10% mais rpido se o arquivo estiver ordenado do que se os elementos forem aleatrios. O mtodo da Insero o mais interessante para arquivos com menos do que 20 elementos, podendo ser mais eficiente do que algoritmos que tenham comportamento assinttico mais eficiente. O mtodo estvel e seu comportamento melhor do que outro mtodo estvel muito citado na literatura, o Bubblesort ou mtodo da bolha. Alm disso, sua implemento to simples quanto 'as implementaes do Bubblesort e Seleo. Para arquivos j ordenados o mtodo 0(n): quando se deseja adicionar alguns elementos a um arquivo j ordenado e depois obter um outro arquivo ordenado o custo linear. O mtodo da Seleo somente vantajoso quanto ao nmero de movimentos de registros, que 0(n). Logo, ele deve ser usado para arquivos com registros muito grandes, desde que o tamanho do arquivo no seja maior do que 1.000 elementos. O Shellsort o mtodo a ser escolhido para a maioria das aplicaes por ser muito eficiente para arquivos de at 10.000 elementos. Mesmo para
90
CAPTULO 3. ORDENAO
arquivos grandes o mtodo cerca de apenas duas vezes mais lento do que o Quicksort. Sua implementao simples e fcil de colocar funcionando corretamente e geralmente resulta em um programa pequeno. Ele no possui um pior caso ruim e quando encontra um arquivo parcialmente ordenado trabalha menos. O Quicksort o algoritmo mais eficiente que existe para uma grande variedade de situaes. Entretanto, 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. Alm disso, seu desempenho da ordem de O ( n 2) operaes no pior caso. Uma vez que se consiga uma implementao robusta, o Quicksort deve ser o mtodo a ser utilizado. 0 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, e o pior caso nestas condies tem uma probabilidade muito remota de ocorrer quando os elementos forem aleatrios. A melhor soluo para tornar o pior caso mais improvvel ainda escolher ao acaso uma pequena amostra do arranjo e usar a mediana da amostra como piv na partio. Geralmente se usa a mediana de uma amostra de trs elementos. Alm de tornar o pior caso muito mais improvvel esta soluo melhora o caso mdio ligeiramente. Outra importante melhoria para o desempenho do Quicksort evitar chamadas recursivas para pequenos subarquivos, atravs da chamada de um mtodo de ordenao simples, como o mtodo da Insero. Para tal, basta colocar um teste no incio do procedimento recursivo Ordena do Pro-grama 3.7 para verificar o tamanho do subarquivo a ser ordenado: para arquivos com menos do que 25 elementos o algoritmo da Insero deve ser chamado ( a implementao do algoritmo da Insero deve ser alterada para aceitar parmetros indicando os limites do subarquivo a ser ordenado). A melhoria no desempenho significativa, podendo chegar a 20% para a maio-ria das aplicaes (Sedgewick, 1988). O Heapsort um mtodo de ordenao elegante e eficiente. Apesar de possuir um anel interno relativamente complexo, que o torna cerca de duas vezes mais lento do que o Quicksort, ele no necessita nenhuma memria adicional. Alm disso, ele executa sempre em tempo proporcional a n log n, qualquer que seja a ordem inicial dos elementos do arquivo de entrada. Aplicaes que no podem tolerar eventuais variaes no tempo esperado de execuo devem usar o Heapsort. Finalmente, quando os registros do arquivo A[1], A[2], ..., A[n] so muito grandes desejvel que o mtodo de ordenao realize apenas n movimentos dos registros, atravs do uso de uma ordenao indireta. Isto pode ser realizado atravs da utilizao de um arranjo P[1], P[2], ..., P[n] de apontadores, um apontador para cada registro: os registros somente so acessados
3.41. ORDENAO EXTERNA
91
para fins de comparaes e toda movimentao realizada apenas sobre os apontadores. Ao final P[1] contm o ndice do menor elemento de A, P[2] contm o ndice do segundo menor elemento de A, e assim sucessivamente. Esta estratgia pode ser utilizada para qualquer dos mtodos de ordenao interna vistos anteriormente. Sedgewick (1988) mostra como implementar esta estratgia para o mtodo da Insero e para aplicaes de filas de prioridades usando Heaps.
3.2 Ordenao Externa

A ordenao externa envolve arquivos compostos por um nmero de registros que maior do que a memria interna do computador pode armazenar. Os mtodos de ordenao externa so muito diferentes dos mtodos de ordenao interna. Em ambos os casos o problema o mesmo: rearranjar os registros de um arquivo em ordem ascendente ou descendente. Entre-tanto, na ordenao externa as estruturas de dados tm que levar em conta o fato de que os dados esto armazenados em unidades de memria externa, relativamente muito mais lentas do que a memria principal. Nas memrias externas, tais como fitas, discos e tambores magnticos, os dados so armazenados como um arquivo seqencial, onde apenas um registro pode ser acessado em um dado momento. Esta uma restrio forte se comparada com as possibilidades de acesso da estrutura de dados do tipo vetor. Conseqentemente, os mtodos de ordenao interna apresentados na Seo 3.1 so inadequados para ordenao externa, e ento tnicas de ordenao completamente diferentes tm que ser usadas. Existem trs importantes fatores que fazem os algoritmos para ordenao externa diferentes dos algoritmos para ordenao interna, a saber: 1. O custo para acessar um item algumas ordens de grandeza maior do que os custos de processamento na memria interna. 0 custo principal na ordenao externa est relacionado com o custo de transferir dados entre a memria interna e a memria externa. 2. Existem restries severas de acesso aos dados. Por exemplo, os itens armazenados em fita magntica s podem ser acessados de forma seq uencial. Os itens armazenados em disco magntico podem ser acessados diretamente, mas a um custo maior do que o custo para acessar seqencialmente, o que contra-indica o uso do acesso direto. 3. O desenvolvimento de mtodos de ordenao externa muito dependente do estado atual da tecnologia. A grande variedade de tipos de unidades de memria externa pode tornar os mtodos de ordenao externa dependentes de vrios parmetros que afetam seus desempenhos.
92
CAPTULO 3. ORDENAO
Por esta razo, apenas mtodos gerais sero apresentados nesta seo, ao invs de apresentarmos refinamentos de algoritmos at o nvel de um programa Pascal executvel. Para desenvolver um mtodo de ordenao externa eficiente o aspecto sistema de computao deve ser considerado no mesmo nvel do aspecto algortmico. A grande nfase deve ser na minimizao do nmero de vezes que cada item transferido entre a memria interna e a memria externa. Mais ainda, cada transferncia deve ser realizada de forma to eficiente quanto as caractersticas dos equipamentos disponveis permitam. O mtodo de ordenao externa mais importante o mtodo de ordenao por intercalao. Intercalar significa combinar dois ou mais blocos ordenados em um nico bloco ordenado atravs de selees repetidas entre os itens disponveis em cada momento. A intercalao utilizada como uma operao auxiliar no processo de ordenar. A maioria dos mtodos de ordenao externa utilizam a seguinte estratgia geral: 1. realizada uma primeira passada sobre o arquivo, quebrando-o em blocos do tamanho da memria interna disponvel. Cada bloco ento ordenado na memria interna. 2. Os blocos ordenados so intercalados, fazendo vrias passadas sobre o arquivo. A cada passada so criados blocos ordenados cada vez maiores, at que todo o arquivo esteja ordenado. Os algoritmos para ordenao externa devem procurar reduzir o nmero de passadas sobre o arquivo. Como a maior parte do custo para as operaes de entrada e sada de dados da memria interna, 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 10 passadas sobre o arquivo. 3.2.1 I n t e r c a l a o B a l a n c e a d a de Vrios C a m i n h o s Vamos considerar o processo de ordenao externa quando o arquivo est armazenado em fita magntica. Para apresentar os vrios passos envolvidos em um algoritmo de ordenao por intercalao balanceada vamos utilizar um arquivo exemplo. Considere um arquivo armazenado em uma fita de entrada, composto pelos registros com as chaves mostradas na Figura 3.10. Os 2 2 registros devem ser ordenados de acordo com as chaves e colocados em uma fita de sada. Neste caso os registros so lidos um aps o outro.
93
Figura 3.10: Arquivo exemplo com 22 registros
Assuma que a memria interna do computador a ser utilizado s tem espao para trs registros, e o nmero de unidades de fita magntica seis. Na primeira etapa o arquivo lido de trs em trs registros. Cada bloco de trs registros ordenado e escrito em uma das fitas de sada. No exemplo da Figura 3.10 so lidos os registros INT e escrito o bloco INT na fita 1, a seguir so lidos os registros ERC e escrito o bloco CER na fita 2, e assim por diante, conforme ilustra a Figura 3.11. Trs fitas so utilizadas em uma intercalao-de-3-caminhos.
Figura 3.11: Formao dos blocos ordenados iniciais
Na segunda etapa os blocos ordenados devem ser intercalados. 0 primeiro registro de cada uma das trs fitas lido para a memria interna, ocupando toda a memria interna. A seguir o registro contendo a menor chave dentre as trs retirado e o prximo registro da mesma fita lido para a memria interna, repetindo-se o processo. Quando o terceiro registro de um dos blocos lido aquela fita fica inativa at que o terceiro registro das outras fitas tambm sejam lidos e escritos na fita de sada, formando um bloco de 9 registros ordenados. A seguir o segundo bloco de 3 registros de cada fita lido para formar outro bloco ordenado de nove registros, o qual escrito em uma outra fita. Ao final trs novos blocos ordenados so obtidos, conforme mostra a Figura 3.12.
Figura 3.12: Intercalao-de-3-caminhos
A seguir mais uma intercalao-de-3-caminhos das fitas 4, 5 e 6 para as fitas 1, 2 e 3 completa a ordenao. Se o arquivo exemplo tivesse um nmero maior de registros, ento vrios blocos ordenados de 9 registros seriam formados nas fitas 4, 5 e 6. Neste caso, a segunda passada produziria blocos ordenados de 27 registros nas fitas 1, 2 e 3; a terceira passada produziria blocos ordenados de 81 registros nas fitas 4, 5 e 6, e assim sucessivamente, at obter-se um nico bloco ordenado. Neste ponto cabe a seguinte pergunta:
94
CAPTULO 3. ORDENAO
quantas passadas so necessrias para ordenar um arquivo de tamanho arbitrrio? Considere um arquivo contendo n registros (neste caso cada registro contm apenas uma palavra) e uma memria interna de m palavras. A passada inicial sobre o arquivo produz n/m blocos ordenados (se cada registro contiver k palavras, k > 1, ento teramos n/m/k blocos ordenados.) Seja P uma funo de complexidade tal que P(n) o nmero de passadas para a fase de intercalao dos blocos ordenados, e seja f o nmero de fitas utilizadas em cada passada. Para uma intercalao-de- f -caminhos o nmero de passadas
Considere um exemplo de um arquivo de tamanho muito grande, tal como 1 bilho de palavras. Considere uma memria interna disponvel de 2 milhes de palavras e 4 unidades de fitas magnticas. Neste caso P(n) = 5, e o nmero total de passadas, incluindo a primeira passada para obter os n/m blocos ordenados, 6. Uma estimativa do tempo total gasto para ordenar este arquivo pode ser obtido multiplicando-se por 6 o tempo gasto para transferir o arquivo de uma fita para outra. Para uma intercalao-de- f -caminhos foram utilizadas 2f fitas nos exem plos acima. Para usar apenas f + 1 fitas basta encaminhar todos os blocos para uma nica fita e, com mais uma passada, redistribuir estes blocos entre as fitas de onde eles foram lidos. No caso do exemplo de 22 registros apenas 4 fitas seriam suficientes: a intercalao dos blocos a partir das fitas 1, 2 e 3 seria toda dirigida para a fita 4; ao final, o segundo e o terceiro blocos ordenados de 9 registros seriam transferidos, de volta para as fitas 1 e 2, e assim por diante. O custo envolvido uma passada a mais em cada intercalao.
3.2.2 Implementao Atravs de Seleo por Substituio

A implementao do mtodo de intercalao balanceada pode ser realizada utilizando-se filas de prioridades. Tanto a passada inicial para quebrar o arquivo em blocos ordenados quanto a fase de intercalao podem ser implementadas de forma eficiente e elegante utilizando-se filas de prioridades. A operao bsica necessria para formar os blocos ordenados iniciais corresponde a obter o menor dentre os registros presentes na memria interna, o qual deve ser substitudo pelo prximo registro da fita de entrada. A operao de substituio do menor item de uma fila de prioridades implementada atravs de um h e a p a operao ideal para resolver o problema.
95
A operao de substituio corresponde a retirar o menor item da fila de prioridades, colocando no seu lugar um novo item, seguido da reconstituio da propriedade do heap. Para cumprir esta primeira passada ns iniciamos o processo fazendo m inseres na fila de prioridades inicialmente vazia. A seguir o menor item da fila de prioridades substitudo pelo prximo item do arquivo de entrada, com o seguinte passo adicional: se o prximo item menor que o que est saindo (o que significa que este item no pode fazer parte do bloco ordenado corrente), ento ele deve ser marcado como membro do prximo bloco e tratado como maior do que todos os itens do bloco corrente. Quando um item marcado vai para o topo da fila de prioridades, o bloco corrente encerrado e um novo bloco ordenado iniciado. A Figura 3.13 mostra o resultado da primeira passada sobre o arquivo da Figura 3.10. Os asteriscos indicam quais chaves na fila de prioridades pertencem a blocos diferentes.
Figura 3.13: Resultado da primeira passada usando seleo por substituio Cada linha da Figura 3.13 representa o contedo de um heap de tamanho trs. A condio do heap que a primeira chave tem que ser menor do que a segunda e a terceira chaves. Ns iniciamos com as trs primeiras chaves do arquivo, as quais j formam um heap. A seguir, o registro I sai e substitudo
96
CAPTULO 46. ORDENAO
pelo registro E, que menor do que a chave I. Neste caso, o registro E no pode ser includo no bloco corrente: ele marcado e considerado maior do que os outros registros do heap. Isto viola a condio do heap, e o registro E* trocado com o registro N para reconstituir o heap. A seguir, o registro N sai e substitudo pelo registro R, o que no viola a condio do heap. Ao final do processo vrios blocos ordenados so obtidos. Esta forma de utilizar filas de prioridades chamada seleo por substituio (vide Knuth, 1973, Seo 5.4.1; Sedgewick, 1988, p.180). Para uma memria interna capaz de reter apenas 3 registros possvel produzir os blocos ordenados INRT, ACEL, AABCLO, AACEN e AAD, de tamanhos 4, 4, 6, 5 e 3, respectivamente. Knuth (1973, pp. 254-256) mostra que, se as chaves so randmicas, os blocos ordenados produzidos so cerca de duas vezes o tamanho dos blocos produzidos por ordenao interna. Assim, a fase de intercalao inicia com blocos ordenados em mdia duas vezes maiores do que o tamanho da memria interna, o que pode salvar uma passada na fase de intercalao. Se houver alguma ordem nas chaves ento os blocos ordenados podem ser ainda maiores. Ainda mais, se nenhuma chave possui mais do que m chaves maiores do que ela, antes dela, ento o arquivo ordenado j na primeira passada. Por exemplo, o conjunto de registros RAPAZ ordenado pela primeira passada, conforme ilustra a Figura 3.14.
Figura 3.14: Conjunto ordenado na primeira passada A fase de intercalao dos blocos ordenados obtidos na primeira fase tambm pode ser implementada utilizando-se uma fila de prioridades. A operao bsica para fazer a intercalao-de- f -caminhos obter o menor item dentre os itens ainda no retirados dos f blocos a serem intercalados. Para tal basta montar uma fila de prioridades de tamanho f a partir de cada uma das f entradas. Repetidamente, substitua o item no topo da fila de prioridades (no caso o menor item) pelo prximo item do mesmo bloco do item que est sendo substitudo, e imprima em outra fita o elemento substitudo. A Figura 3.15 mostra o resultado da intercalao de INT com CER com AAL, os quais correspondem aos blocos iniciais das fitas 1, 2 e 3 mostrados na Figura 3.11. Quando f no muito grande no h vantagem em utilizar seleo por substituio para intercalar os blocos, pois possvel obter o menor item
97
Figura 3.15: Intercalao usando seleo por substituio
fazendo f 1 comparaes. Quando f 8 ou mais, possvel ganhar tempo usando um heap como mostrado acima. Neste caso cerca de log 2 f comparaes so necessrias para obter o menor item.
3.2.3 C o n s i d e r a e s P r t i c a s
Para implementar o mtodo de ordenao externa descrito anteriormente muito importante implementar de forma eficiente as operaes de entrada sada de dados. Estas operaes compreendem a transferncia dos dados entre a memria interna e as unidades externas onde esto armazenadas os registros a serem ordenados. Deve-se procurar realizar a leitura, a escrita o processamento interno dos dados de forma simultnea. Os computa-dores de maior porte possuem uma ou mais unidades independentes para processamento de entrada e sada que permitem realizar simultaneamente as operaes de entrada, sada e processamento interno. Knuth (1973) discute vrias tcnicas para obter superposio de entrada sada com processamento interno. Uma tcnica comum a de utilizar 2 f reas de entrada e 2 f reas de sada. Para cada unidade de entrada ou sada so mantidas duas reas de armazenamento: uma para uso do processador central e 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. No momento que o processador central termina a leitura de uma rea, ele espera que a unidade de entrada acabe de preencher a outra rea e ento passa a ler dela, enquanto a unidade de entrada passa a preencher a outra. Para sada, a mesma tcnica utilizada. Existem dois problemas relacionados com a tcnica de utilizao de duas reas de. armazenamento. Primeiro, apenas metade da memria disponvel utilizada, o que pode levar a uma ineficincia se o nmero de reas for grande, como no caso de uma intercalao-de- f -caminhos para f grande. Segundo,
98
CAPTULO 48. ORDENAO
em uma intercalao-de- f -caminhos existem f reas correntes de entrada; se todas as reas se tornarem vazias aproximadamente ao mesmo tempo, muita leitura ser necessria antes de podermos continuar o processamento, a no ser que haja uma previso de que esta eventualidade possa ocorrer. Os dois problemas podem ser resolvidos com a utilizao de uma tcnica chamada previso, a qual requer a utilizao de apenas uma rea extra de armazenamento (e no f reas) durante o processo de intercalao. A melhor forma de superpor a entrada com processamento interno durante o processo de seleo por substituio superpor a entrada da prxima rea que precisa ser preenchida a seguir com a parte de processamento interno do algoritmo. Felizmente, fcil saber qual rea ficar vazia primeiro, simplesmente olhando para o ltimo registro de cada rea. A rea cujo ltimo registro o menor, ser a primeira a se esvaziar; assim ns sempre sabemos qual conjunto de registros deve ser o prximo a ser transferido para a rea. Por exemplo, na intercalao de INT com CER com AAL ns sabemos que a terceira rea ser a primeira a se esvaziar. Uma forma simples de superpor processamento com entrada na intercalao de vrios caminhos manter uma rea extra de armazenamento, a qual preenchida de acordo com a regra descrita acima. Enquanto os blocos INT, CER e AAL da Figura 3.11 esto sendo intercalados o processador de entrada est preenchendo a rea extra com o bloco ACN. Quando o processador central encontrar uma rea vazia, ele espera at que a rea de entrada seja preenchida caso isto ainda no tenha ocorrido, e ento aciona o processador de entrada para comear a preencher a rea vazia com o prximo bloco, no caso ABL. Outra considerao prtica importante est na escolha do valor de f , que a ordem da intercalao. No caso de fita magntica a escolha do valor de f deve ser igual ao nmero de unidades de fita disponveis menos um. A fase de intercalao usa f fitas de entrada e uma fita de sada. 0 nmero de fitas de entrada deve ser no mnimo dois pois no faz sentido fazer intercalao com menos de duas fitas de entrada. No caso de disco magntico o mesmo raciocnio acima vlido. Apesar do disco magntico permitir acesso direto a posies arbitrrias do arquivo, o acesso seqencial mais eficiente. Logo, o valor de f deve ser igual ao nmero de unidades de disco disponveis menos um, para evitar o maior custo envolvido se dois arquivos diferentes estiverem em um mesmo disco. Sedegwick (1983) apresenta outra alternativa: considerar f grande o suficiente para completar a ordenao em um nmero pequeno de passadas. Uma intercalao de duas passadas em geral pode ser realizada com um nmero razovel para f . A primeira passada no arquivo utilizando seleo por substituio produz cerca de n / 2 m blocos ordenados. Na fase de intercalao cada etapa divide o nmero de passadas por f . Logo, f deve ser escolhido tal que
EXERCCIOS
99
Para n igual a 200 milhes e m igual a 1 milho ento f = 11 suficiente para garantir a ordenao em duas passadas. Entretanto, a melhor escolha para f entre estas duas alternativas muito dependente de vrios parmetros relacionados com o sistema de computao disponvel.
Notas Bibliogrficas
Knuth (1973) a referncia mais completa que existe sobre ordenao em geral. Outros livros interessantes sobre o assunto so Sedgewick (1988), Wirth (1976), Cormem, Leiserson e Rivest (1990), Aho, Hoperoft e Ullman ( 1983). 0 livro de Gonnet e Baeza-Yates (1991) apresenta uma relao bibliogrfica extensa e atualizada sobre o assunto. Shellsort foi proposto por Shell (1959). Quicksort foi proposto por Hoare ( 1962). Um estudo analtico detalhado, bem como um estudo exaustivo dos efeitos prticos de muitas modificaes e melhorias sugeridas para o Quicksort pode ser encontrado em Sedgewick (1975) e Sedgewick (1978a). Heapsort foi proposto por Williams (1964) e melhorado por Floyd (1964).
Exerccios
1) Dado que existe necessidade de ordenar arquivos de tamanhos diversos, podendo tambm variar o tamanho dos registros de um arquivo para outro, apresente uma discusso sobre quais algoritmos de ordenao voc escolheria diante das diversas situaes colocadas acima. Que observaes adicionais voc apresentaria caso haja a) restries de estabilidade ou b) de intolerncia para o pior caso (isto , a aplicao exige um algoritmo eficiente mas no permite que o mesmo eventualmente leve muito tempo para executar). 2) Invente um vetor-exemplo de entrada para demonstrar que Ordenao por Seleo um mtodo instvel. Mostre os passos da execuo do algoritmo at que a estabilidade violada. Note que quanto menor for o vetor que voc inventar, mais rpido voc vai resolver a questo. 3) Considere uma matriz retangular. Ordene em ordem crescente os elementos de cada linha. A seguir ordene em ordem crescente os elementos de cada coluna. Prove que os elementos de cada linha continuam em ordem.
100
CAPTULO 3. ORDENAO
4) Ordenao Ps-Catstrofe (rabe, 1992) Imagine que voc estava trabalhando na Universidade da California, em Berkeley. Logo depois que voc tinha acabado de ordenar um conjunto muito grande de n nmeros inteiros, cada nmero de grande magnitude (com muitos dgitos), usando o seu mtodo O(n log n) favorito, aconteceu um terremoto de grandes propores. Milagrosamente, o computador no destrudo (nem voc), mas, por algum motivo, cada um dos 4 bits menos significativos de cada nmero inteiro aleatriamente alterado. Voc quer, agora, ordenar os novos nmeros inteiros. Escolha um algoritmo capaz de ordenar os novos nmeros em 0(n). Justifique. 5) Algoritmos de Ordenao: Estudos Comparativos Considere os seguintes algoritmos de ordenao interna: Insero, Seleo, Shellsort, Quicksort, Heapsort. a) Determine experimentalmente o nmero esperado de (i) comparaes e (ii) movimento-de-registros para cada um dos cinco mtodos de ordenao indicados acima. Use um gerador de nmeros aleatrios para gerar as chaves. Utilize arquivos de diferentes tamanhos com chaves geradas randomicamente. Repita cada experimento algumas vezes e obtenha a mdia para cada medida de complexidade. Utilize o tipo de da-dos array do Pascal. D a sua interpretao dos dados obtidos, comparando-os com resultados analticos. b) Uma opo alternativa, para o caso do uso de mquinas que permitem medir o tempo de execuo de um programa, considerar os mesmos algoritmos propostos e determinar experimentalmente o tempo de execuo de cada um dos cinco mtodos de ordenao indicados acima. Use um gerador de nmeros aleatrios para gerar arquivos de tamanhos 500, 2000 e 10.000 registros. Para cada tamanho de arquivo utilize dois tamanhos de registros, a saber: um registro contendo apenas a chave e outro registro de tamanho 11 vezes o tamanho da chave (isto , a chave acompanhada de "outros componentes" cujo tamanho seja equivalente a 10 chaves). Repita cada experimento algumas vezes e obtenha a mdia dos tempos de execuo. Utilize o tipo de dados array do Pascal. D a sua interpretao dos dados obtidos. 6) Considere a estrutura de dados heap. Determine empiricamente o nmero esperado de trocas para:
EXERCCIOS
101
a) construir um heap atravs de n inseres sucessivas a partir de um heap vazio; b) inserir um novo elemento em um heap contendo n elementos; c) extrair o elemento maior de um heap contendo n + 1 elementos. Use um gerador de nmeros aleatrios para gerar as chaves. Repita o experimento para diferentes tamanhos de n. A estrutura de dados utilizada deve usar o mnimo possvel de memria para armazenar o heap. Utilize o Pascal para implementar o algoritmo. Finalmente, d a sua interpretao dos resultados obtidos. Como estes resultados se comparam com os resultados analticos? 7) Quicksort a) Mostre como o vetor A B A B A B A particionado quando se escolhe o elemento do meio, A[(esq + dir) div 2], como piv. b) Mostre as etapas de funcionamento do Quicksort para ordenar as chaves Q U I C K S O R T . Considere que o piv escolhido o elemento do meio, A[(esq + dir) div 2]. 8) Quicksort a) Descreva uma maneira para manter o tamanho da pilha de recurso o menor possvel na implementao do Quicksort. b) Se voc no se preocupasse com o uso deste artifcio, at que tamanho a pilha poderia crescer, no pior caso? Por qu? 9) O objetivo deste trabalho fazer um estudo comparativo de diversas implementaes do algoritmo Quicksort. Para tanto, voc dever implementar as seguintes verses do algoritmo: a) Quicksort recursivo; b) Quicksort recursivo com interrupo da partio para a ordenao de sub-vetores menores que M elementos. Determine empiricamente o melhor valor de M para um arquivo gerado aleatoriamente com 1000 (mil) elementos; c) Melhore a verso 2 utilizando a tcnica de mediana-de-trs elementos para escolha do piv. Gere massas de testes para testar e comparar cada uma das implementaes. Use sua criatividade para criar arquivos de teste interessantes. Faa tabelas e/ou grficos para mostrar e explicar os resultados obtidos. . O que deve ser apresentado:
102
CAPTULO 3. ORDENAO
a) Listagem dos programas em Pascal. Vo valer pontos clareza, indentao e comentrios no programa. b) Listagem dos testes executados. c) Descrio sucinta dos arquivos de teste utilizados, relatrio comparativo dos testes executados e as decises tomadas relativas aos casos e detalhes de especificao que porventura estejam omissos no enunciado. d) Estudo da complexidade do tempo de execuo de cada uma das implementaes para diversos cenrios de teste. Algumas sugestes: a) determine o tempo de processamento necessrio na fase de classificao utilizando o relgio da mquina; b) mantenha contadores (que devem ser atualizados pelos procedimentos de ordenao) para armazenar o nmero de comparaes e de trocas de elementos executados pelos algoritmos; c) execute o programa algumas vezes, com cada algoritmo, com massas de dados diferentes, para obter a mdia dos tempos de execuo e dos nmeros de comparaes e trocas; d) outro experimento interessante executar o programa uma vez com uma massa de dados que force o pior caso do algoritmo. 10) Considere o seguinte vetor de entrada: H E A P S O R T a) Utilizando o algoritmo Heapsort rearranje os elementos do vetor para formar a representao de um heap utilizando o prprio vetor de entrada. 0 heap deve conter o mximo do conjunto na raiz. b) A partir do heap criado execute trs iteraes do anel principal do Heapsort para extrair os trs maiores elementos. Mostre os desenhos heap-vetor. 11) Suponha que voc tenha que ordenar vrios arquivos de 100, 5.000 e 2 0 . 0 0 0 nmeros inteiros. Para todos os trs tamanhos de arquivos necessrio realizar a ordenao no menor tempo possvel. a) Que algoritmo de ordenao voc usaria para cada tamanho de arquivo? Justifique. b) Se for necessrio manter a ordem relativa dos itens com chaves iguais (isto , manter estabilidade), que algoritmo voc usaria para cada tamanho de arquivo? Justifique.
EXERCCIOS
103
c) Suponha que as ordenaes tenham que ser realizadas em um ambiente em que uma configurao dos dados de entrada que leve a um pior caso no possa ser tolerada, mesmo que este pior caso possa acontecer muito raramente (em outras palavras, voc no quer que o pior tempo de execuo seja muito maior que o caso mdio). Ainda assim, continua sendo importante realizar a ordenao no menor tempo possvel. Que algoritmo de ordenao voc usaria em cada tamanho de arquivo? Justifique. 12) 0 objetivo deste problema projetar uma estrutura de dados para um conjunto S (Arabe, 1992). S conter elementos retirados de algum universo U; S pode conter elementos duplicados. A estrutura de dados projetada deve implementar eficientemente as seguintes operaes: a) Insere (b, S): Insere o elemento b em S (isto vai adicionar uma nova cpia de b em S se j existia alguma). b) RetiraMin (x, S): retira de S o menor elemento (pode haver mais de um), retornando seu valor em x. Descreva uma estrutura de dados e como implementar as operaes Insere e RetiraMin de modo que estas operaes sejam executadas, no pior caso, em O(log n). 13) A operao de unir dois arquivos ordenados gerando um terceiro arquivo ordenado denominada intercalao (merge). Esta operao consiste em colocar no terceiro arquivo a cada passo sempre o menor elemento entre os menores dos dois arquivos iniciais, desconsiderando este mesmo elemento nos passos posteriores. Este processo deve ser repetido at que todos os elementos dos arquivos de entrada sejam escolhidos. Esta idia pode ser utilizada para construir um algoritmo de ordenao. 0 processo o seguinte: dividir recursivamente o vetor a ser ordenado em dois vetores at obter n vetores de 1 nico elemento. Aplicar o algoritmo de merge tendo como entrada 2 vetores de um elemento e formando um vetor ordenado de dois elementos. Repetir este processo formando vetores ordenados cada vez maiores at que todo o vetor esteja ordenado. Escrever um algoritmo para implementar este mtodo, conhecido na literatura como mergesort. 14) Considere o arquivo de 10 registros: B A L A N C E A D A a) Vamos considerar o mtodo de ordenao externa usando intercalao-balanceada-de-2-caminhos, utilizando apenas 3 fitas magnticas e uma memria interna com capacidade para armazenar
104
CAPTULO 3. ORDENAO trs registros. Mostre todas as etapas para ordenar o arquivo exemplo acima utilizando intercalao balanceada simples (sem utilizar seleo por substituio). b) Quantas passadas foram realizadas?
15) Ordenao Externa O objetivo deste trabalho projetar e implementar um sistema de programas para ordenar arquivos que no cabem na memria primria, o que nos obriga a utilizar um algoritmo de ordenao externa. Existem muitos mtodos para ordenao externa. Entretanto, a gran-de maioria utiliza a seguinte estratgia geral: blocos de entrada to grandes quanto possvel so ordenados internamente e copiados em arquivos intermedirios de trabalho. A seguir os arquivos intermedirios so intercalados e copiados em outros arquivos de trabalho, at que todos os registros so intercalados em um nico bloco final representando o arquivo ordenado. Um procedimento simples e eficiente para realizar esta tarefa o de colocar cada bloco ordenado em um arquivo separado at que a entrada toda lida. A seguir os N primeiros arquivos so intercalados em um novo arquivo e esses N arquivos removidos. N uma constante que pode ter valores entre 2 e 10, chamada Ordem de Intercalao. Este processo repetido at que fique apenas um arquivo, o arquivo final ordenado. A cada passo o procedimento de intercalao nunca tem que lidar com mais do que N arquivos de intercalao mais um nico arquivo de sada. Para tornar mais claro o que cada aluno tem que realizar apresentamos abaixo um primeiro refinamento do procedimento que permite implementar a estratgia descrita acima. Pode-se observar que grande parte do procedimento lida com criao, abertura, fechamento e remoo de arquivos em momentos adequados. A fase de intercalao utiliza dois ndices, Low e High, para indicar o intervalo de arquivos ativos. 0 ndice High incrementado de 1, OrdemIntercalConst arquivos so intercalados a partir de Low e armazenados no arquivo High e, finalmente, Low incrementado de OrdemIntercalConst. Quando Low fica igual ou maior do que High a intercalao termina com o ltimo bloco resultante High totalmente ordenado. importante observar que as interfaces dos vrios procedimentos presentes no cdigo abaixo no esto completamente especificadas.
EXERCCIOS
105
10 6
CAPITULO 6. ORDENAO
Captulo 4
Pesquisa em Memria Primria

Este captulo dedicado ao estudo de como recuperar informao a partir de uma massa grande de informao previamente armazenada. A informao dividida em registros, onde cada registro possui uma chave para ser usada na pesquisa. 0 objetivo da pesquisa encontrar uma ou mais ocorrncias de registros com chaves iguais chave de pesquisa. Neste caso ocorreu uma pesquisa com sucesso; caso contrrio a pesquisa sem sucesso. Um conjunto de registros chamado de tabela ou arquivo. Geralmente o termo tabela associado a entidades de vida curta, criadas na memria interna durante a execuo de um programa. J o termo arquivo geralmente associado a entidades de vida mais longa, armazenadas em memria externa. Entretanto, esta distino no precisa: um arquivo de ndices pode ser tratado como uma tabela, enquanto uma tabela de valores de funes pode ser tratada mais como um arquivo. Existe uma variedade enorme de mtodos de pesquisa. A escolha do mtodo de pesquisa mais adequado a uma determinada aplicao depende principalmente: (i) da quantidade dos dados envolvidos, (ii) do arquivo estar sujeito a inseres e retiradas freqentes, ou do contedo do arquivo ser praticamente estvel (neste caso importante minimizar o tempo de pesquisa, sem preocupao com o tempo necessrio para estruturar o arquivo). E importante considerar os algoritmos de pesquisa como tipos abstratos de dados, com um conjunto de operaes associado a uma estrutura de dados, de tal forma que haja uma independncia de implementao para as operaes. Algumas das operaes mais comuns incluem: 1. Inicializar a estrutura de dados. 2. Pesquisar um ou mais registros com determinada chave. 107
108
CAPTULO 8. PESQUISA EM MEMRIA PRIMRIA
3. Inserir um novo registro. 4. Retirar um registro especfico. 5. Ordenar um arquivo para obter todos os registros em ordem de acordo com a chave. 6. Ajuntar dois arquivos para formar um arquivo maior. A operao 5 foi objeto de estudo no Captulo 3. A operao 6 demanda a utilizao de tcnicas sofisticadas e no ser tratada neste texto. Um nome comumente utilizado para descrever uma estrutura de dados para pesquisa dicionrio. Um dicionrio um tipo abstrato de dados com as operaes Inicializa, Pesquisa, Insere e Retira. Em uma analogia com um dicionrio da lngua portuguesa, as chaves so as palavras e os registros so as entradas associadas com cada palavra, onde cada entrada contm a pronncia, definio, sinnimos e outras informaes associadas com a palavra. Para alguns dos mtodos de pesquisa a serem estudados a seguir, vamos implementar o mtodo como um dicionrio, como o caso das Arvores de Pesquisa (Seo 4.3) e Hashing (Seo 4.5). Para os mtodos Pesquisa Seqencial e Pesquisa Digital vamos implementar as operaes Inicializa, Pesquisa e Insere e para o mtodo Pesquisa Binria vamos implementar apenas a operao Pesquisa.
4.1 Pesquisa Seqencial

O mtodo de pesquisa mais simples que existe funciona da seguinte forma: a partir do primeiro registro, pesquise seqencialmente at encontrar a chave procurada; ento pare. Apesar de sua simplicidade, a pesquisa seqencial envolve algumas idias interessantes, servindo para ilustrar vrios aspectos e convenes a serem utilizadas nos outros mtodos de pesquisa a serem apresentados. Uma forma possvel de armazenar um conjunto de registros atravs do tipo estruturado arranjo, conforme ilustra o Programa 4.1. Cada registro contm um campo chave que identifica o registro. Alm da chave, podem existir outros componentes em um registro, os quais no tm influncia muito grande nos algoritmos. Por exemplo, os outros componentes de um registro podem ser substitudos por um apontador contendo o endereo de um outro local que os contenha. Uma possvel implementao para as operaes Inicializa, Pesquisa e Insere mostrada no Programa 4.2. A funo Pesquisa retorna o ndice do registro que contm a chave x; caso no esteja presente o valor retornado zero. Observe que esta implementao
4.1. PESQUISA SEQENCIAL
109
110
no suporta mais de um registro com uma mesma chave. Para aplicaes com esta caracterstica necessrio incluir um argumento a mais na funo Pesquisa para conter o ndice a partir do qual se quer pesquisar, e alterar a implementao de acordo. Um registro sentinela contendo a chave de pesquisa colocado na posio zero do array. Esta tcnica garante que a pesquisa sempre termina. Aps a chamada da funo Pesquisa, se o ndice zero, significa que a pesquisa foi sem sucesso.
Anlise
Para uma pesquisa com sucesso, conforme mostrado no final da Seo 1.3, temos melhor caso : C(n) = 1 pior caso : C(n) = n caso mdio : C(n) = (n + 1 ) / 2 Para uma pesquisa sem sucesso temos C'(n)=n+1. Observe que o anel interno da funo Pesquisa, no Programa 4.2, extremamente simples: o ndice i decrementado e a chave de pesquisa comparada com a chave que est no registro. Por esta razo, esta tcnica usando sentinela conhecida por pesquisa seqencial rpida. Este algoritmo a melhor soluo para o problema de pesquisa em tabelas com 25 registros ou menos.
4.2 Pesquisa Binria

A pesquisa em uma tabela pode ser muito mais eficiente se os registros forem mantidos em ordem. Para saber se uma chave est presente na tabela, compare a chave com o registro que est na posio do meio da tabela. Se a chave menor, ento o registro procurado est na primeira metade da tabela; se a chave maior, ento o registro procurado est na segunda metade da tabela. Repita o processo at que a chave seja encontrada, ou fique apenas um registro cuja chave diferente da procurada, significando uma pesquisa sem sucesso. A Figura 4.1 mostra os subconjuntos pesquisados para. recuperar o ndice da chave G . O Programa 4.3 mostra a implementao do algoritmo para um conjunto de registros implementado como uma tabela.
4.3. RVORES DE PESQUISA
111
P r o g r a m a 4.3: Pesquisa binria
Anlise
A cada iterao do algoritmo, o tamanho da tabela dividido ao meio. Logo, o nmero de vezes que o tamanho da' tabela dividido ao meio cerca de log n. Entretanto, o custo para manter a tabela ordenada alto: a cada insero na posio p da tabela implica no deslocamento dos registros a partir da posio p para as posies seguintes. Conseqentemente, a pesquisa binria no deve ser usada em aplicaes muito dinmicas.
4.3 rvores de Pesquisa

A rvore de pesquisa uma estrutura de dados muito eficiente para armazenar informao. Ela particularmente adequada quando existe necessidade de considerar todos ou alguma combinao de requisitos tais como: (i) acesso direto e seqencial eficientes; (ii) facilidade de insero e retirada de registros; (iii) boa taxa de utilizao de memria; (iv) utilizao de memria primria e secundria.
112
Se algum considerar separadamente qualquer um dos requisitos acima, possvel encontrar uma estrutura de dados que seja superior rvore de pesquisa. Por exemplo, tabelas hashing possuem tempos mdios de pesquisa melhores e tabelas usando posies contguas de memria possuem melhores taxas de utilizao de memria. Entretanto, uma tabela usando hashing precisa ser ordenada se existir necessidade de processar os registros seqencialmente em ordem lexicogrfica, e a insero/retirada de registros em tabelas usando posies contguas de memria tem custo alto. As rvores de pesquisa representam um compromisso entre estes requisitos conflitantes.
4.3.1
rvores
Binrias
de
Pesquisa
Sem
Balanceamento
De acordo com Knuth (1968, p. 315), uma rvore binria formada a partir de um conjunto finito de nodos, consistindo de um nodo chamado raiz mais 0 ou 2 subrvores binrias distintas. Em outras palavras, uma rvore binria um conjunto de nodos onde cada nodo tem exatamente 0 ou 2 filhos; quando um nodo tem 2 filhos, eles so Chamadas filhos esquerda e direita do nodo. Cada nodo contm apontadores para subrvores esquerda e direita. 0 nmero de subrvores de um . nodo chamado grau daquele nodo. Um nodo de grau zero chamado de nodo externo ou folha (de agora em diante no haver distino entre estes dois termos). Os outros nodos so chamados nodos internos. Uma rvore binria de pesquisa uma rvore binria em que todo nodo interno contm um registro, e, para cada nodo, a seguinte propriedade verdadeira: todos os registros com chaves menores esto na subrvore esquerda e todos os registros com chaves maiores esto na subrvore direita. O nvel do nodo raiz 0; se um nodo est no nvel i ento a raiz de suas subrvores esto no nvel i + 1. A altura de um nodo o comprimento do caminho mais longo deste nodo at um nodo folha. A altura de uma rvore a altura do nodo raiz. A Figura 4.2 mostra uma rvore binria de pesquisa de altura 4. A estrutura de dados rvore binria de pesquisa ser utilizada para implementar o tipo abstrato de dados Dicionrio (lembre-se que o tipo abstrato Dicionrio contm as operaes Inicializa, Pesquisa, Insere e Retira). A estrutura e a representao do Dicionrio apresentada no Programa 4.4. Um procedimento Pesquisa para uma rvore binria de pesquisa bas tante simples, conforme ilustra a implementao do Programa 4.5. Para encontrar um registro com uma chave x, primeiro compare-a com a chave que est na raiz. Se menor, v para a subrvore esquerda; se x maior, v para a subrvore direita. Repita o processo recursivamente, at que a chave procurada seja encontrada ou ento um nodo folha atingido. Se a pesquisa for com sucesso ento o contedo do registro retorna no prprio registro x.
113
Programa 4.4: Estrutura do dicionrio para rvores sem balanceamento
Atingir um apontador nulo em um processo de pesquisa significa uma pesquisa sem sucesso (o registro procurado no est na rvore). Caso se queira inseri-lo na rvore, o apontador nulo atingido justamente o ponto de insero, conforme ilustra a implementao do procedimento Insere do Programa 4.6. 0 procedimento Inicializa extremamente simples, conforme ilustra o Programa 4.7. A rvore de pesquisa mostrada na Figura 4.2 pode ser obtida quando as chaves so lidas pelo Programa 4.8, na ordem 5, 3, 2, 7, 6, 4, 1, 0, sendo 0 a marca de fim de arquivo. A ltima operao a ser estudada Retira. Se o nodo que contm o registro a ser retirado possui no mximo um descendente ento a operao simples. No caso do nodo conter dois descendentes, o registro a ser retirado deve ser primeiro substitudo pelo registro mais direita na subrvore esquerda, ou pelo registro mais esquerda na subrvore direita. Assim, para retirar o registro com chave 5 na rvore da Figura 4.2, basta troc-lo pelo registro com chave 4 ou pelo registro com chave 6, e ento retirar o nodo que recebeu o registro com chave 5.
114
CAPITULO 14. PESQUISA EM MEMRIA PRIMRIA
115
Programa
4.8:
Programa para criar a rvore
O Programa 4.9 mostra a implementao da operao Retira. 0 procedimento recursivo Antecessor somente ativado quando o nodo que contm o registro a ser retirado possui dois descendentes. Esta soluo elegante utilizada por Wirth(1976, p.211). Aps construda a rvore pode ser necessrio percorrer todos os registros que compem tabela ou arquivo. Existe mais de uma ordem de caminhamento em rvores, mas a mais til a chamada ordem de caminhamento central. Assim como a estrutura da rvore, o caminhamento central melhor expresso em termos recursivos, a saber: 1. caminha na subrvore esquerda na ordem central; 2. visita a raiz; 3. caminha na subrvore direita na ordem central. Uma caracterstica importante do caminhamento central que os nodos so visitados em ordem lexicogrfica das chaves. Percorrer a rvore da Figura 4.2 usando caminhamento central recupera as chaves na ordem 1, 2, 3, 4, 5, 6 e 7. ' 0 procedimento. Central, mostrado no Programa 4.10, faz exatamente isto. Observe que este procedimento representa um mtodo de ordenao similar ao Quicksort, onde a chave na raiz faz o papel do item que particiona o vetor.
116
Programa 4.9: Procedimento para retirar x da rvore
117
Anlise
O nmero de comparaes em uma pesquisa com sucesso : melhor caso : C(n) = 0(1) pior caso : C(n) = 0(n) caso mdio : C(n) = 0(log n) O tempo de execuo dos algoritmos para rvores binrias de pesquisa dependem muito do formato das rvores. Para obter o pior caso basta que as chaves sejam inseridas em ordem crescente (ou decrescente). Neste caso a rvore resultante uma lista linear, cujo nmero mdio de comparaes (n + 1)/2. Para uma rvore de pesquisa randmica 1 possvel mostrar que o nmero esperado de comparaes para recuperar um registro qualquer cerca de 1, 39 log n, apenas 39% pior que a rvore completamente balanceada (vide seo seguinte).
4.3.2 rvores B i n r i a s de P e s q u i s a Com Balanceamento

Para uma distribuio uniforme das chaves, onde cada chave igualmente provvel de ser usada em uma pesquisa, a rvore completamente balanceada 2 minimiza o tempo mdio de pesquisa. Entretanto, o custo para manter a rvore completamente balanceada aps cada insero tem um custo muito alto. Por exemplo, para inserir a chave 1 na rvore esquerda na
1 Uma rvore A com n chaves possui n + 1 nodos externos e estas n chaves dividem todos os valores possveis em n+1 intervalos. Uma insero em A considerada randmica se ela tem probabilidade igual de acontecer em qualquer um dos n + 1 intervalos. Uma rvore de pesquisa randmica com n chaves uma rvore construda atravs de n inseres randmicas sucessivas em uma rvore inicialmente vazia 2 Em uma rvore completamente balanceada os nodos externos aparecem em no mximo dois nveis adjacentes.
118
Figura 4.3 e obter a rvore direita na mesma figura necessrio movimentar todos os nodos
da rvore original.
Figura 4.3: Arvore binria de pesquisa completamente balanceada
Uma forma de contornar este problema procurar uma soluo intermediria que possa manter a rvore "quase-balanceada", ao invs de tentar manter a rvore completamente balanceada. 0 objetivo procurar obter bons tempos de pesquisa, prximos do tempo timo da rvore completa-mente balanceada, mas sem pagar muito para inserir ou retirar da rvore. Existem inmeras heursticas baseadas no princpio acima. Gonnet e Baeza-Yates (1991) apresentam algoritmos que utilizam vrios critrios de balanceamento para rvores de pesquisa, tais como restries impostas na diferena das alturas de subrvores de cada nodo da rvore, na reduo do comprimento do caminho interno3 da rvore, ou que todos os nodos externos apaream no mesmo nvel. Na seo seguinte vamos apresentar uma rvore binria de pesquisa com balanceamento em que todos os nodos externos aparecem no mesmo nvel. r v o r e s SBB As rvores B foram introduzidas por Bayer e McCreight (1972) como uma estrutura para memria secundria, conforme mostrado em detalhes na Seo 5.3.1. Um caso especial da rvore B, mais apropriada para memria primria, a rvore 2-3, na qual cada nodo tem duas ou trs subrvores. Bayer (1971) mostrou que as rvores 2-3 podem ser representadas por rvores binrias, conforme mostrado na Figura 4.4. Quando a rvore 2-3 vista como uma rvore B binria, existe uma assimetria inerente no sentido de que os apontadores esquerda tm que ser verticais (isto , apontam para um nodo no nvel abaixo), enquanto os apontadores direita podem ser verticais ou horizontais. A eliminao da assimetria nas rvores B binrias leva s rvores B binrias simtricas,
3 O comprimento do caminho interno corresponde soma dos comprimentos dos caminhos entre a raiz e cada um dos nodos internos da rvore. Por exemplo, o comprimento do caminho interno da rvore esquerda na Figura 4.3 8 = (0 + 1 + 1 + 2 + 2 + 2).
119
Figura 4.4: Uma rvore 2-3 e a rvore B binria correspondente
cujo nome foi abreviado para rvores SBB (Symmetric Binary B-trees) por Bayer (1972). A Figura 4.5 apresenta uma rvore SBB.
Figura 4.5: rvore SBB
A rvore SBB uma rvore binria com dois tipos de apontadores, chamados apontadores verticais e apontadores horizontais, tal que: 1. todos os caminhos da raiz at cada nodo externo possuem o mesmo nmero de apontadores verticais, e 2. no podem existir dois apontadores horizontais sucessivos. Uma rvore SBB pode tambm ser vista como uma representao binria da rvore 2-3-4 apresentada por Guibas e Sedgewick (1978) e mostrada em detalhes em Sedgewick (1988), na qual "supernodos" podem conter at trs chaves e quatro filhos. Por exemplo, tal "supernodo", com chaves 3, 5 e 9, pode ser visto na rvore SBB da Figura 4.5. Transformaes para Manuteno da Propriedade SBB 0 algoritmo para rvores SBB usa transformaes locais no caminho de insero (retirada) para preservar o balanceamento. A chave a ser inserida ( retirada) sempre inserida (retirada) aps o apontador vertical mais baixo na rvore. Dependendo da situao anterior insero (retirada), podem aparecer dois apontadores horizontais sucessivos e, neste caso, necessrio
120
realizar uma transformao. Se uma transformao realizada, a altura da subrvore transformada um mais do que a altura da subrvore original, o que pode provocar outras transformaes ao longo do caminho de pesquisa, at a raiz da rvore. A Figura 4.6 mostra as transformaes propostas por Bayer (1972), onde transformaes simtricas podem ocorrer.
Figura 4.6: Transformaes propostas por Bayer (1972)
A estrutura de dados rvore SBB ser utilizada para implementar o tipo abstrato de dados Dicionrio. A estrutura do Dicionrio apresentada no Programa 4.11. A nica diferena da estrutura utilizada para implementar a rvore de pesquisa sem balanceamento (vide Programa 4.4) est nos campos BitE e BitD dentro do registro Nodo, usados para indicar o tipo de apontador ( horizontal ou vertical) que sai do nodo.
P r o g r a m a 4.11: Estrutura do dicionrio para rvores SBB
121
O procedimento Pesquisa para rvores SBB idntico ao procedimento Pesquisa para rvores sem balanceamento mostrado no Programa 4.5, porque o procedimento Pesquisa ignora completamente os campos BitE e BitD. Logo, nenhum tempo adicional necessrio para pesquisar na rvore SBB. Os quatro procedimentos EE, ED, DD e DE so utilizados nos procedimentos Insere e Retira, com o objetivo de eliminar dois apontadores horizontais sucessivos. 0 Programa 4.12 mostra a implementao destes procedimentos.
122
O procedimento Insere tem uma interface idntica interface do procedimento Insere para rvores sem balanceamento, conforme pode ser visto no Programa 4.13. Para que isso seja possvel o procedimento Insere simplesmente chama um outro procedimento interno de nome Ilnsere, cuja interface contm dois parmetros a mais que o procedimento Insere, a saber: o parmetro IAp indica que a inclinao do apontador toma o valor horizontal sempre que um nodo elevado para o nvel seguinte durante uma insero, e o parmetro Fim toma o valor t r u e quando a propriedade SBB reestabelecida e nada mais necessrio fazer.
123
Programa 4.13: Procedimento para inserir na rvore SBB
A Figura 4.7 mostra o resultado obtido quando se insere uma seqncia de chaves em uma rvore SBB inicialmente vazia: a rvore esquerda obtida aps a insero das chaves 7, 10, 5; a rvore do meio obtida aps a insero das chaves 2, 4 na rvore anterior; a rvore direita obtida aps a insero das chaves 9, 3, 6 na rvore anterior. A rvore de pesquisa mostrada na Figura 4.5 pode ser obtida quando as chaves 1, 8 so inseridas na rvore direita na Figura 4.7.
Programa 4.14: Procedimento para inicializar a rvore SBB
124
O procedimento Retira pode ser visto no Programa 4.15. Assim como o procedimento Insere mostrado acima, o procedimento Retira contm um outro procedimento interno de nome IRetira, cuja interface interface contm um parmetro a mais que o procedimento Retira, a saber: o parmetro Fim toma o valor true quando a propriedade SBB reestabelecida e nada mais necessrio fazer. Por sua vez, o procedimento IRetira utiliza trs procedimentos internos, a saber: EsqCurto (DirCurto) chamado quando um nodo folha (que referendado por um apontador vertical) retirado da subrvore esquerda ( direita), tornando-a menor na altura aps a retirada; Quando o nodo a ser retirado possui dois descendentes, o procedimento Antecessor localiza o nodo antecessor para ser trocado com o nodo a ser retirado.
125
126
Programa 4.15: Procedimento para retirar da rvore SBB
A Figura 4.8 mostra o resultado obtido quando se retira uma seqncia de chaves da rvore SBB: a rvore esquerda obtida aps a retirada da chave 7 da rvore direita na Figura 4.7 acima; a rvore do meio obtida aps a retirada da chave 5 da rvore anterior; a rvore direita obtida aps a retirada da chave 9 da rvore anterior.
Anlise
Para as rvores SBB necessrio distinguir dois tipos de alturas. Uma delas a altura vertical h, necessria para manter a altura uniforme e obtida atravs da contagem do nmero de apontadores verticais em qualquer caminho entre a raiz e um nodo externo. A outra a altura k, que representa o nmero mximo de comparaes de chaves obtida atravs da contagem do nmero total de apontadores no maior caminho entre a raiz e um nodo ex-
4.4. PESQUISA DIGITAL
127
4.4 Pesquisa Digital

A pesquisa digital baseada na representao das chaves como uma seqncia de caracteres ou de dgitos. Grosso modo, o mtodo de pesquisa digital realizado da mesma forma que uma pesquisa em dicionrios que possuem aqueles "ndices de dedo". Com a primeira letra da palavra so determinadas todas as pginas que contm as palavras iniciadas por aquela letra. Os mtodos de pesquisa digital so particularmente vantajosos quando as chaves so grandes e de tamanho varivel. No problema de casamento
128
de cadeias, trabalha-se com chaves semi-infinitas4, isto , sem limitao explicita quanto ao tamanho delas. Um aspecto interessante quanto aos mtodos de pesquisa digital a possibilidade de localizar todas as ocorrncias de uma determinada cadeia em um texto, com tempo de resposta logartmico em relao ao tamanho do texto.
Trie
Uma trie uma rvore M-ria cujos nodos so vetores de M componentes com campos correspondentes ao dgitos ou caracteres que formam as chaves. Cada nodo no nvel i representa o conjunto de todas as chaves que comeam com a mesma seqncia de i dgitos ou caracteres. Este nodo especifica uma ramificao com M caminhos dependendo do (i + 1)-simo dgito ou caractere de uma chave. Considerando as chaves como seqncia de bits (isto , M = 2), o algoritmo de pesquisa digital semelhante ao de pesquisa em rvore, exceto que, ao invs de se caminhar na rvore de acordo com o resultado de comparao entre chaves, caminha-se de acordo com os bits de chave. A Figura 4.9 mostra uma trie construda a partir das seguintes chaves de 6 bits: B = 010010 C = 010011 H = 011000 J = 100001 Q = 101000 Para construir .uma trie, faz-se uma pesquisa na rvore com a chave a ser inserida. Se o nodo externo em que a pesquisa teminar for vazio, cria-se um novo nodo externo nesse ponto contendo a nova chave, como ilustra a insero da chave W = 110110 na Figura 4.10. Se o nodo externo contiver uma chave, cria-se um ou mais nodos internos cujos descendentes contero a chave j existente e a nova chave. A Figura 4.10 ilustra a insero da chave K = 100010 que envolve repor J por um novo nodo interno cuja subrvore esquerda outro novo nodo interno cujos filhos so J e K, porque estas chaves possuem os mesmos bits at a quinta posio. O formato das tries, diferentemente das rvores binrias comuns, no depende da ordem em que as chaves so inseridas e sim da estrutura das chaves atravs da distribuio de seus bits. Uma grande desvantagem das
4 Uma chave semi-infinita uma seqncia de caracteres em que somente a sua extremidade inicial definida. Logo, cada posio no texto representa uma chave semi-infinita, constituda pela seqncia que inicia naquela posio e se estende direita tanto quanto for necessrio ou at o final do texto. Por exemplo, um banco de dados constitudo de n palavras ( as posies de interesse nesse caso so os endereos de incio das palavras) possui n chaves semi-infinitas.
129
tries a formao de caminhos de uma s direo para chaves com um grande nmero de bits em comum. Por exemplo, se duas chaves diferirem somente no ltimo bit, elas formaro um caminho cujo comprimento igual ao tamanho delas, no importando quantas chaves existem na rvore. Veja o caminho gerado pelas chaves B e C na Figura 4.10.
Patricia
PATRICIA a abreviatura de Practical Algorithm To Retrieve Information Coded In Alphanumeric (Algoritmo Prtico para Recuperar Informao Codificada em Alfanumrico). Este algoritmo foi originalmente criado por Morrison (1968) num trabalho de casamento de cadeias, aplicado recuperao de informao em arquivos de grande porte. Knuth (1973) deu um novo tratamento ao algoritmo, reapresentando-o de frma mais clara como um caso particular de pesquisa digital, essencialmente, um caso de rvore trio binria. Sedgewick(1988) apresentou novos algoritmos de pesquisa e de insero baseados nos algoritmos propostos por Knuth. Gonnet e Baeza-Yates (1991) propuzeram tambm outros algoritmos.
130
O algoritmo para construo da rvore Patricia baseado no mtodo de pesquisa digital, mas sem apresentar o inconveniente citado para o caso das tries. 0 problema de caminhos de uma s direo eliminado por meio de uma soluo simples e elegante: cada nodo interno da rvore contm o ndice do bit a ser testado para decidir qual ramo tomar. A Figura 4.11 apresenta a rvore Patricia gerada a partir das chaves B, C, H, J e Q apresentadas acima.
Para inserir a chave K = 100010 na rvore da Figura 4.11, a pesquisa inicia pela raiz e termina quando se chega ao nodo externo contendo J. Os ndices dos bits nas chaves esto ordenados da esquerda para a direita. Assim, o bit de ndice 1 de K 1, indicando a subrvore direita, e o bit de ndice 3 indica a subrvore esquerda que, neste caso, um nodo externo. Isto significa que as chaves J e K mantm o padro de bits 1xOxxx, assim como qualquer outra chave que seguir este caminho de pesquisa. Um novo nodo interno repe o nodo J, e este juntamente com o nodo K sero os nodos externos descendentes. 0 ndice do novo nodo interno dado pelo primeiro bit diferente das duas chaves em questo, que o bit de ndice 5. Para determinar qual ser o descendente esquerdo e o direito, s verificar o valor do bit 5 de ambas as chaves, conforme mostrado na Figura 4.12.
131
A insero da chave W = 110110 ilustra um outro aspecto. A pesquisa sem sucesso na rvore da Figura 4.13 realizada de maneira anloga. Os bits das chaves K e W so comparados a partir do primeiro para determinar em qual ndice eles diferem, sendo, neste caso, os de ndice 2. Portanto o ponto de insero agora ser no caminho de pesquisa entre os nodos internos de ndice 1 e 3. Cria-se a um novo nodo interno de ndice 2, cujo descendente direito um nodo externo contendo W e cujo descendente esquerdo a subrvore de raiz de ndice 3, conforme ilustra a Figura 4.13.
132
133
P r o g r a m a 4 . 2 0 : I n i c i a l i z a o d a r v o r e
Cada chave k inserida de acordo com os passos abaixo, partindo da raiz: 1. Se a subrvore corrente for vazia, ento criado um nodo externo contendo a chave k (isto ocorre somente na insero da primeira chave) e o algoritmo termina. 2. Se a subrvore corrente for simplesmente um nodo externo, os bits da chave k so comparados, a partir do bit de ndice imediatamente aps o ltimo ndice da seqncia de ndices consecutivos do caminho de pesquisa, com os bits correspondentes da chave k' deste nodo externo at encontrar um ndice i cujos bits difiram. A comparao dos bits
134
4.35. TRANSFORMAO DE CHAVE (HASHING)
135
a partir do ltimo ndice consecutivo melhora consideravelmente o desempenho do algoritmo. Se todos forem iguais, a chave j se encontra na rvore e o algoritmo termina, seno vai-se para o Passo 4. 3. Caso contrrio, ou seja, se a raiz da subrvore corrente for um nodo interno, vai-se para a subrvore indicada pelo bit da chave k de ndice dado pelo nodo corrente, de forma recursiva. 4. Depois so criados um nodo interno e um nodo externo: o primeiro contendo o ndice i e o segundo, a chave k. A seguir, o nodo interno ligado ao externo pelo apontador de subrvore esquerda ou direita, dependendo se o bit de ndice i da chave k seja 0 ou 1, respectivamente. 5. 0 caminho de insero percorrido novamente de baixo para cima, subindo com o par de nodos criados no Passo 4 at chegar a um nodo interno cujo ndice seja menor que o ndice i determinado no Passo 2. Este o ponto de insero e o par de nodos inserido.
4.5 Transformao de Chave (Hashing)

Os mtodos de pesquisa apresentados anteriormente so baseados na comparao da chave de pesquisa com as chaves armazenadas na tabela, ou na utilizao dos bits da chave de pesquisa para escolher o caminho a seguir. 0 mtodo de transformao de chave (ou hashing) completamente diferente: os registros armazenados em uma tabela so diretamente endereados a partir de uma transformao aritmtica sobre a chave de pesquisa. De acordo com o Webster's New World Dictionary, a palavra hash significa: (i) fazer picadinho de carne e vegetais para cozinhar; (ii) fazer uma baguna. Como veremos a seguir, o termo hashing um nome apropriado pata o mtodo. Um mtodo de pesquisa atravs da transformao de chave constitudo de duas etapas principais: 1. Computar o valor da funo de transformao (tambm conhecida por funo hashing), a qual transforma a chave de pesquisa em um endereo da tabela; 2. Considerando que duas ou mais chaves podem ser transformadas em um mesmo endereo de tabela, necessrio existir um mtodo para lidar com colises. Se porventura as chaves fossem inteiros de 1 a n, ento poderamos armazenar o registro com chave i na posio i da tabela, e qualquer registro poderia ser imediatamente acessado a partir do valor da chave. Por outro
136
lado, vamos supor uma tabela capaz de armazenar M = 97 chaves, onde cada chave pode ser um nmero decimal de 4 dgitos. Neste caso existem N = 10000 chaves possveis, e a funo de transformao no pode ser um para um: mesmo que o nmero de registros a serem armazenados seja muito menor do que 97, qualquer que seja a funo de transformao, algumas colises iro ocorrer fatalmente, e tais colises tm que ser resolvidas de alguma forma. Mesmo que se obtenha uma 'funo de transformao que distribua os registros de forma uniforme entre as entradas da tabela, existe uma alta probabilidade de haver colises. 0 paradoxo do aniversrio (Feller, 1968, p. 33), diz que em um grupo de 23 ou mais pessoas, juntas ao acaso, existe uma chance maior do que 50% de que 2 pessoas comemorem aniversrio no mesmo dia. Isto significa que, se for utilizada uma funo de transformao uniforme que enderece 23 chaves randmicas em uma tabela de tamanho 365, a probabilidade de que haja colises maior do que 50%.
4.5.1 Funes de T r a n s f o r m a o
Uma funo de transformao deve mapear chaves em inteiros dentro do intervalo [0..M 1 ] , onde M o tamanho da tabela. A funo de transformao ideal aquela que: (i) seja simples de ser computada; (ii) para cada chave de entrada, qualquer uma das sadas possveis igualmente provvel de ocorrer. Considerando que as transformaes sobre as chaves so aritmticas, o primeiro passo transformar as chaves no numricas em nmeros. No caso do Pascal, basta utilizar a funo ord que recebe um argumento de um tipo escalar qualquer e retorna o nmero ordinal dentro do tipo (por exemplo, ord (t r u e) 1 desde que o tipo boolean definido como (false, t r u e) ) . Vrias funes de transformao tm sido estudadas (Knott, 1975; Knuth, 1973). Um dos mtodos que funciona muito bem usa o resto da diviso por M 5: h(K) = K mod M onde K um inteiro correspondente chave. Este um mtodo muito simples de ser implementado, conforme ilustra o Programa 4.22. 0 nico cuidado a tomar na escolha do valor de M. Por exemplo, se M par, ento h(K) par quando K par, e h(K) mpar quando K mpar. Resumindo, M deve ser um nmero primo, mas no qualquer primo: 'devem ser evitados os nmeros primos obtidos a partir de
137
138
Programa 4.23: Estrutura do dicionrio para listas encadeadas
liza, Pesquisa, Insere, Retira. A estrutura do dicionrio apresentada no Programa 4.23. A implementao das operaes sobre o Dicionrio so mostradas no Programa 4.24. As operaes FLVazia, Insere e Retira, definidas sobre o TipoLista, mostradas no Programa 2.4 do Captulo 2, podem ser utilizadas para manipular as listas encadeadas. Entretanto, ser necessrio alterar os nomes do procedimentos Insere e Retira do Programa 2.4 para Ins e Ret respectivamente, para no haver conflito com os nomes dos procedimentos Insere e Retira do Dicionrio (vide procedimentos Insere e Retira no Programa 4.24).
Anlise
Assumindo que qualquer item do conjunto tem igual probabilidade de ser endereado para qualquer entrada de T, ento o comprimento esperado de cada lista encadeada N / M , onde N representa o nmero de registros na tabela e M o tamanho da tabela. Logo, as operaes Pesquisa, Insere e Retira custam 0 ( 1 + N / M ) operaes em mdia, onde a constante 1 representa o tempo para encontrar a entrada na tabela e N / M o tempo para percorrer a lista. Para valores de M prximos de N , o tempo se torna constante, isto , independente de N .
139
Programa 4.24: Operaes do Dicionrio usando listas encadeadas
140
4.5.3 Open Addressing

Quando o nmero de registros a serem armazenados na tabela puder ser previamente estimado, ento no haver necessidade de usar apontadores para armazenar os registros. Existem vrios mtodos para armazenar N registros em uma tabela de tamanho M > N, os quais utilizam os lugares vazios na prpria tabela para resolver as colises. Tais mtodos so chamados Open-addressing (Knuth, 1973, p.518). Em outras palavras, todas as chaves so armazenadas na prpria tabela, sem o uso de apontadores explcitos. Quando uma chave x endereada para uma entrada da tabela que j esteja ocupada, uma seqncia de localizaes alternativas h1 (x), h2 (x), ... escolhida dentro da tabela. Se nenhuma das h1 ( x), h2 (x), ... posies est vazia ento a tabela est cheia e no podemos inserir x. Existem vrias propostas para a escolha de localizaes alternativas. A mais simples chamada de hashing linear, onde a posio hi na tabela dada por:
A estrutura de dados open addressing ser utilizada para implementar o tipo abstrato de dados Dicionrio, com as operaes Inicializa, Pesquisa, Insere, Retira. A estrutura do dicionrio apresentada no Programa 4.25. A implementao das operaes sobre o Dicionrio so mostradas no Programa 4.26.
141
O hashing linear sofre de um mal chamado agrupamento (clustering) ( Knuth, 1973, pp.520521). Este fenmeno ocorre na medida em que a tabela comea a ficar cheia, pois a insero de uma nova chave tende a ocupar uma posio na tabela que esteja contgua a outras posies j ocupadas, o que deteriora o tempo necessrio para novas pesquisas. Entretanto, apesar do hashing linear ser um mtodo relativamente pobre para resolver colises os resultados apresentados so bons. A tabela 4.1 mostra alguns valores para C( n) para diferentes valores de a.
0.10 0.25 0.50 0.75 0.90 0.95
C(n)
1.06 1.17 1.50 2.50 5.50 10.50
Tabela 4.1: Nmero de comparaes em uma pesquisa com sucesso para hashing linear
0 aspecto negativo do mtodo, seja listas encadeadas ou open addresstng, est relacionado com o pior caso, que O(N). Se a funo de transformao no conseguir espalhar os registros de forma razovel pelas entradas da tabela, ento uma longa lista linear pode ser formada, deteriorando o tempo mdio de pesquisa. 0 melhor caso, assim como o caso mdio, 0(1).
142
143
Como vantagens na utilizao do mtodo de transformao da chave citamos: (i) alta eficincia no custo de pesquisa, que 0(1) para o caso mdio e, (ii) simplicidade de implementao. Como aspectos negativos citamos: (i) o custo para recuperar os registros na ordem lexicogrfica das chaves alto, sendo necessrio ordenar o arquivo e, (ii) o pior caso O(N).
Notas Bibliogrficas
As principais referncias para pesquisa em memria interna so Gonnet e Baeza-Yates (1991), Knuth (1973), e Mehlhorn (1984). Outros livros incluem Standish (1980), Wirth (1976), Wirth (1986), Aho, Hoperoft e Ullman ( 1983), Terada (1991). Um estudo mais avanado sobre estruturas de dados e algoritmos pode ser encontrado em Tarjan (1983). Um dos primeiros estudos sobre insero e retirada em rvores de pesquisa foi realizado por Hibbard (1962), tendo provado que o comprimento mdio do caminho interno aps n inseres randnicas 21n n. A definio de rvore binria foi extrada de Knuth (1968, p.315). A primeira rvore binria de pesquisa com balanceamento foi proposta por Adel'son-Vel'skii e Landis (1962), dois matemticos russos, a qual recebeu o nome de rvore AVL. Uma rvore binria de pesquisa uma rvore AVL se a altura da subrvore esquerda de cada nodo nunca difere de l da altura da subrvore direita. A Figura 4.16 apresenta uma rvore com esta propriedade.
Figura 4.16: Arvore AVL
A forma de manter a propriedade AVL atravs de transformaes localizadas no caminho de pesquisa. Como a altura das rvores AVL fica sempre entre log2(n + 1) e 1.4404 log2(n + 2) 0.328 (Adel'son-Vel'skii e Landis, 1962), o custo para inserir ou retirar O(log n), que exatamente o custo
144
para percorrer o caminho de pesquisa. Wirth (1976, 1986) apresenta implementaes dos algoritmos de insero e de retirada para as rvores AVL. O material utilizado na Seo 4.3.2 veio de Bayer (1971), Bayer (1972), Olivi (1980), Ziviani e Tompa (1982) e Ziviani, Olivi e Gonnet (1985). Os trabalhos de Bayer apresentam as rvores SBB, o de Olivi sugere uma melhoria para o algoritmo de insero e o de Ziviani e Tompa apresentam implementaes para os algoritmos de insero e retirada. A rvore SBB pode ser vista como uma representao binria da rvore 2-3-4, apresentada por Guibas e Sedgewick (1978). Este mesmo trabalho mostra como adaptar vrios algoritmos clssicos para rvores de pesquisa balanceadas dentro do esquema rvores red-black. Sleator e Tarjan (1983) apresentam vrios mtodos para manuteno de rvores auto-ajustveis. A idia mover os nodos mais freqentemente acessados em direo raiz aps cada acesso: embora cada operao isolada possa ter custo mais alto, ao longo de um perodo maior o tempo mdio de cada operao menor, isto , o custo amortizado diminui ao longo do tempo. Em outras palavras, uma operao particular pode ser lenta, mas qualquer seqncia de operaes rpida.
Exerccios
1) Considere as tcnicas de pesquisa seqencial, pesquisa binria e a pesquisa baseada em hashing. a) Descreva as vantagens e desvantagens de cada uma das tcnicas acima, colocando em que situaes voc usaria cada uma delas. b) D a ordem do pior caso e do caso esperado de tempo de execuo para cada mtodo. c) Qual a eficincia de utilizao de memria (relao entre o espao necessrio para dados e o espao total necessrio) para cada mtodo?
EXERCCIOS
145
c) Voc conhece algum algoritmo que seja timo para resolver o problema? 3) Qual a principal propriedade de uma rvore binria de pesquisa? 4) rvore Binria de Pesquisa a) Desenhe a rvore binria de pesquisa que resulta da insero sucessiva das chaves Q U E S T A O F C I L numa rvore inicialmente vazia. b) Desenhe as rvores resultantes das retiradas dos elementos E e depois U da rvore obtida no item anterior. 5) Arvores Binrias Suponha que voc tenha uma rvore binria na qual esto armazenadas uma chave em cada nodo. Suponha tambm que a rvore foi construda de tal maneira que, ao caminhar nela na ordem central, as chaves so visitadas em ordem crescente. a) Qual propriedade entre as chaves deve ser satisfeita para que isso seja possvel? b) Dada uma chave k, descreva sucintamente um algoritmo que procure por k em uma rvore com essa estrutura. c) Qual a complexidade do seu algoritmo no melhor caso e no pior caso? Justifique. 6) rvore SBB a) Desenhe a rvore SBB que resulta da insero sucessiva das chaves Q U E S T A O F C I L numa rvore inicialmente vazia. b) Desenhe as rvores resultantes das retiradas dos elementos E e depois U da rvore obtida no item anterior. 7) rvore SBB Um novo conjunto de transformaes para a rvore SBB foi proposto por Olivi (1980). 0 algoritmo de insero usando as novas transformaes produz rvores SBB com menor altura e demanda um nmero menor de transformaes de diviso de nodos para construir a rvore, conforme comprovado em Ziviani e Tompa (1982) e Ziviani, Olivi e Gonnet (1985). A Figura 4.17 mostra as novas transformaes. 0 operao divide esquerda-esquerda requer modificao de trs apontadores, a operao divide esquerda-direita requer a alterao de cinco
146
apontadores, e a operao aumenta altura requer apenas a modificao de dois bits. Transformaes simtricas tambm podem ocorrer. Quando ocorre uma transformao do tipo aumenta altura, a altura da subrvore transformada um mais do que a altura da subrvore original, o que pode provocar outras transformaes ao longo do caminho de pesquisa at a raiz da rvore. Usualmente, o retorno ao longo do caminho de pesquisa termina quando um apontador vertical encontrado ou uma transformao do tipo divide realizada. Como a altura da subrvore que sofreu a diviso a mesma que a altura da subrvore original, apenas uma transformao do tipo divide suficiente para restaurar a propriedade SBB da rvore.
EXERCCIOS
147
Bayer (1972), Olivi (1980) e tambm Wirth (1976) usaram dois bits por nodo em suas implementaes para indicarem se os apontadores direita e esquerda so horizontais ou verticais. Entretanto, apenas um bit necessrio: a informao indicando se o apontador direita ( esquerda) horizontal ou vertical pode ser armazenada no filho direita (esquerda). Alm do fato de demandar menos espao em cada nodo, o retorno ao longo do caminho de pesquisa para procurar por dois apontadores horizontais pode ser terminado mais edo, porque a informao sobre o tipo de apontador que leva a um nodo disponvel sem a necessidade de retornar at seu pai. Implemente as novas transformaes mostradas na Figura 4.17. Utilize apenas 1 bit por nodo para manter a informao sobre a inclinao dos apontadores. 8) Quais as caractersticas de uma boa funo hash? 9) Um dos mtodos utilizados para se organizar dados atravs de tabelas hash. a) Em que situaes a tabela hash deve ser utilizada? b) Descreva dois mecanismos diferentes para resolver o problema de colises de vrias chaves em uma mesma posio da tabela. Quais so as vantagens e desvantagens de cada mecanismo? 10) Em uma tabela hash cam 100 entradas, as colises so resolvidas usando listas encadeadas. Para reduzir o tempo de pesquisa, decidiu-se que cada lista seria organizada como uma rvore binria de pesquisa. A funo utilizada h(k) = k mod 100. Infelizmente, as chaves inseridas seguem o padro k i = 50i, onde k i corresponde i-sima chave inserida. a) Mostre a situao da tabela aps a insero de k i, com i = 1,2,., 13. (Faa desenho.) b) Depois que 1000 chaves so inseridas de acordo com o padro acima, inicia-se a insero de chaves escolhidas de forma randmica (isto , no seguem o padro das chaves j inseridas). Assim responda: i) Qual a ordem do pior caso (isto , o maior nmero de comparaes) para inserir uma chave? ii) Qual o nmero esperado de comparaes para inserir uma chave? (Assuma que cada uma das 100 entradas da tabela igualmente provvel de ser endereada pela funo h.)
148 11) Hashing
Substitua XXXXXXXXXXXX pelas 12 primeiras letras do seu nome, desprezando brancos e letras repetidas, nas duas partes desta questo. Para quem no tiver doze letras diferentes no nome, completar com as letras PQRSTUVWXYZ, nesta ordem, at completar 12 letras. Por exemplo, eu deveria escolher NIVOZAPQRSTU A segunda letra I de NIVIO no entra porque ela j apareceu antes, e assim por diante (Arabe, 1992). a) Desenhe o contedo da tabela hash resultante da insero de registros com as chaves XXXXXXXXXXXX, nesta ordem, numa tabela inicialmente vazia de tamanho 7 (sete), usando listas encadeadas. Use a funo hash h(k) = k mod 7 para a k-sima letra do alfabeto. b) Desenhe o contedo da tabela hash resultante da insero de registros com as chaves XXXXXXXXXXXX, nesta ordem, numa tabela inicialmente vazia de tamanho 13 (treze), usando open addressing e hashing linear para resolver as colises. Use a funo hash h(k) = k mod 13 para a k-sima letra do alfabeto. 12) Hashing Open addressing a) Hashing Linear. Desenhe o contedo da tabela hash resultante da insero de registros com as chaves Q U E S T A O F C I L, nesta ordem, numa tabela inicialmente vazia de tamanho 13 (treze) usando open addressing com hashing linear para a escolha de localizaes alternativas. Use a funo hash h(k) = k mod 13 para a k-sima letra do alfabeto. b) Hash Duplo. Desenhe o contedo da tabela hash resultante da insero de registros com as chaves Q U E S T A O F C I L, nesta ordem, numa tabela inicialmente vazia de tamanho 13 (treze) usando open addressing com hash duplo. Use a funo hash h 1(k) = k mod 13 para calcular o endereo primrio e j = 1 + (k mod 11) para resolver as colises, ou seja, para a escolha de localizaes alternativas. Logo h i(k) = (h i _ 1(k) + j) mod 13, para 2 i M (Sedgewick, 1988). 13) Considere as seguintes estruturas de dados: a) heap
EXERCCIOS
149
b) rvore binria de pesquisa c) vetor ordenado d) tabela hash com soluo para colises usando "open addressing" e) tabela hash com soluo para colises usando "listas encadeadas". Para cada um dos problemas abaixo, sugira a estrutura de dados mais apropriada dentre as listadas acima, de forma a minimizar tempo esperado e espao necessrio. Indique o tempo e o espao necessrio em cada escolha e por que superior aos outros. i) inserir/retirar/encontrar um elemento dado; ii) inserir/retirar/encontrar o elemento de valor mais prximo ao solicitado; iii) coletar um conjunto de registros, processar o maior elemento, coletar mais registros, processar o maior elemento, e assim por diante. iv) mesma situao descrita no item anterior adicionada da operao extra de ajuntar ("merge") duas estruturas. 14) 0 objetivo deste trabalho o de projetar e implementar um sistema de programas, incluindo as estruturas de dados e os algoritmos. Neste trabalho, o aluno ter a oportunidade de exercitar parcialmente o conceito de independncia de implementao, atravs da utilizao de duas estruturas de dados distintas para implementar o mesmo problema. Neste caso, o mdulo que implementa cada uma das estruturas de dados dever permitir o intercmbio entre uma estrutura e outra, causando o menor impacto possvel em outras partes do programa. Problema: Criao de ndice remissivo Vrias aplicaes necessitam de um relatrio de referncias cruzadas. Por exemplo, a maioria dos livros apresentam um ndice remissivo que corresponde a uma lista alfabtica de palavras chave ou palavras relevantes do texto com a indicao dos locais no texto onde cada palavra chave ocorre. Como exemplo, suponha um arquivo contendo um texto constitudo como abaixo:
Linha 1: Good programming is not learned from Linha 2: generalities, but by seeing how significant Linha 3: programs can be made clean, easy to Linha 4: read, easy to maintain and modify,
150
CAPTULO 4. PESQUISA EM MEMRIA PRIMRIA Linha 5: human-engineered, efficient, and reliable, Linha 6: by the application of common sense and Linha 7: by the use of good programming practices. Assumindo que o ndice remissivo seja constitudo das palavras chave: programming, programs, easy, by, human-engineered, and, be, to, o programa para criao do ndice deve produzir a seguinte sada:
and be by easy human-engineered programming programs to
4 3 2 3 5 1 3 3
5 6 6 7 4 7 4
Note que a lista de palavras chave est em ordem alfabtica. Adjacente a cada palavra est uma lista de nmeros de linhas, um para cada vez que a palavra ocorre no texto. Projete um sistema para produzir um ndice remissivo. O sistema dever ler um nmero arbitrrio de palavras chave que devero constituir o ndice remissivo, seguido da leitura de um texto de tamanho arbitrrio, o qual dever ser esquadrinhado procura de palavras que pertenam ao ndice remissivo. Cabe ressaltar que: a) Uma palavra considerada como uma seqncia de letras e dgitos, comeando com uma letra; b) Apenas os primeiros cl caracteres devem ser retidos nas chaves. Assim, duas palavras que no diferem nos primeiros cl caracteres so consideradas idnticas; c) Palavras constitudas por menos do que c1 caracteres devem ser preenchidas por um nmero apropriado de brancos. Utilize um mtodo eficiente para verificar se uma palavra lida do texto pertence ao ndice. Para resolver este problema, voc deve utilizar duas estruturas de dados distintas:
EXERCCIOS
151
a) Implementar o ndice como uma rvore de pesquisa; b) Implementar o ndice como uma tabela hash, usando o mtodo hashing linear para resolver colises. Observe que, apesar do hashing ser mais eficiente do que rvores de pesquisa, existe uma desvantagem na sua utilizao: aps atualizado todo o ndice remissivo, necessrio imprimir suas palavras em ordem alfabtica. Isto imediato em rvores de pesquisa, mas, quando se usa hashing, isto problemtico, sendo necessrio ordenar a tabela hash que contm o ndice remissivo. Utilize o exemplo acima para testar seu programa. Comece a pensar to logo seja possvel, enquanto o problema est fresco na memria e o prazo para termin-lo est to longe quanto jamais poder estar. 15) Considere duas listas ordenadas de nmeros. Determine para cada elemento da lista menor se ele est presente tambm na lista maior. (Pode assumir que no existem duplicaes em nenhuma das duas listas.) Considere os seguintes casos: uma lista contm apenas 1 elemento, a outra n as duas listas contm n elementos
a) Sugira algoritmos eficientes para resolver o problema b) Apresente o nmero de comparaes necessrio c) Mostre que cada algoritmo minimiza o nmero de comparaes. 16) rvore Patricia Desenhe a rvore Patricia que resulta da insero sucessiva das chaves QUESTAOFCIL numa rvore inicialmente vazia. 17) rvore Patricia a) Desenhe a rvore Patricia que resulta da insero sucessiva das chaves MULTICS numa rvore inicialmente vazia. b) Qual o custo para pesquisar em uma rvore Patricia construda atravs de n inseres randmicas? Explique.
152
CAPTULO 4. PESQUISA EM MEMRIA PRIMRIA c) Qual o custo para construir uma rvore Patricia atravs de n inseres randmicas? Explique. i) Sob o ponto de vista prtico, quando n muito grande (digamos 100 milhes), qual a maior dificuldade para construir a rvore Patricia? ii) Como a dificuldade apontada no item anterior pode ser superada?
18) rvore Patricia (Murta, 1992) Considere o seguinte trecho do poema "Quadrilha" de Carlos Drummond de Andrade: "Joo amava Teresa que amava Raimundo que amava Maria que amava Joaquim que amava Lill que no amava ningum." Construa uma rvore Patricia para indexar o texto acima. Considere a seguinte codificao para as palavras do texto:
Joo amava Teresa que Raimundo 01001011 00011101 11101011 10100101 11011010 Maria Joaquim Lili no ningum 01100101 00101110 01010011 10011100 10110010
a) Faa uma pesquisa pelas chaves "amava", "que amava" e "Lill". Mostre o caminho percorrido para cada pesquisa e as ocorrncias do termo pesquisado. b) Aponte a maior sequncia de palavras que se repete no banco de dados e mostre como localizar, em qualquer rvore Patricia, este tipo de ocorrncia. 19) rvore Patricia Construa, passo a passo, a rvore Patricia para as seis primeiras chaves semi-infinitas do texto abaixo, representado como uma seqncia de bits: 0 1 1 0 0 1 1 0 1 1 0 0 1 Texto 1 2 3 4 5 6 7 8 9 Posio
EXERCCIOS 20) rvore Patricia
153
Projete e implemente um sistema de programas para recuperao eficiente de informao em bancos de dados constitudos de textos. Tais bancos de dados geralmente recebem adies peridicas, mas nenhuma atualizao do que j existe realizada. Alm disso, o tipo de consulta aos dados totalmente imprevisvel. Estes conjuntos de dados aparecem em sistemas legislativos, judicirios, bibliotecas, jornalismo, automao de escritrio, dentre outros. Neste trabalho voc deve utilizar um mtodo que cria um ndice cuja estrutura uma rvore Patricia, construda a partir de uma sequncia de chaves semi-infinitas. O sistema de programas dever ser capaz de: a) construir a rvore Patricia sobre um texto de tamanho arbitrrio, representado como um conjunto de palavras; b) ler um conjunto de palavras de tamanho arbitrrio; c) encontrar todas as ocorrncias do conjunto de palavras no texto, imprimindo junto com o conjunto algumas palavras anteriores e posteriores no texto; d) informar o nmero de ocorrncias do conjunto de palavras no texto; e) encontrar o maior conjunto de palavras que se repete pelo menos uma vez no texto e informar o seu tamanho; f) dado um inteiro encontrar, se houver, todas as ocorrncias de conjuntos de palavras no texto cujo tamanho seja igual ao inteiro dado. 21) Pat Array Projete e implemente um sistema de programas para recuperao eficiente de informao em bancos de dados constitudos de textos. Tais bancos de dados geralmente recebem adies peridicas, mas nenhuma atualizao do que j existe realizada. Alm disso, o tipo de consulta aos dados totalmente imprevisvel. Estes conjuntos de dados aparecem em sistemas legislativos, judicirios, bibliotecas, jornalismo, automao de escritrio, dentre outros. Neste trabalho voc deve utilizar uma estrutura de dados chamada PAT array, (Gonnet e Baeza-Yates, 1991) construda a partir de uma seqncia de chaves semi-infinitas. 0 PAT array uma representao compacta da rvore Patricia (Seo 4.4), por armazenar
154
CAPTULO 4. PESQUISA EM MEMRIA PRIMRIA apenas os nodos externos da rvore. 0 arranjo constitudo de apontadores para o incio de cada palavra de um arquivo de texto. Logo, necessrio apenas um apontador para cada ponto de indexao no texto. Este arranjo dever estar indiretamente ordenado pela ordem lexicogrfica das chaves semi-infinitas, conforme mostrado na Figura 4.18.
A construo de um Pat array equivalente a ordenao de registros de tamanhos variveis, representados pelas chaves semi-infinitas. Qualquer operao sobre a rvore Patricia poder ser simulada sobre o Pat array a um custo adicional de O(log n). Mais ainda, para a operao de pesquisa de prefixo a rvore Patricia no precisa de fato ser simulada, sendo possvel obter algoritmos de custo O(log n) ao invs de O( log2 n) para esta operao. Esta operao pode ser implementada atravs de uma pesquisa binria indireta sobre o arranjo, com o resultado de cada comparao sendo menor que, igual ou menor que. Pat arrays so tambm chamados Suffix arrays (Manber e Myers, 1990). O sistema de programas dever ser capaz de: a) Construir o PAT array sobre um texto de tamanho arbitrrio, representado como um conjunto de palavras; b) Ler um conjunto de caracteres de tamanho arbitrrio. Este conjunto poder ser uma palavra ou um prefixo de palavra; c) Informar o nmero de ocorrncias do conjunto de caracteres no texto; d) Encontrar todas as ocorrncias do conjunto de caracteres no texto, imprimindo junto com o conjunto algumas palavras anteriores e posteriores no texto; e) Apresente a complexidade de pior caso para a letra c); f) Mostre a relao entre o PAT array e a rvore Patricia.
Captulo 5 Pesquisa em Memria Secundria

A pesquisa em memria secundria envolve arquivos contendo um nmero de registros que maior do que o nmero que a memria interna pode armazenar. Os algoritmos e as estruturas de dados para processamento em memria secundria tm que levar em considerao os seguintes aspectos: 1. O custo para acessar um registro algumas ordens de grandeza maior do que o custo de processamento na memria primria. Logo, a medida de complexidade principal est relacionada com o custo para transferir dados entre a memria principal e a memria secundria. A nfase deve ser na minimizao do nmero de vezes que cada registro transferido entre a memria interna e a memria externa. Por exemplo, o tempo necessrio para a localizao e a leitura de um nmero inteiro em disco magntico pode ser suficiente para obter a mdia aritmtica de algumas poucas centenas de nmeros inteiros ou mesmo orden-los na memria principal. 2. Em memrias secundrias apenas um registro pode ser acessado em um dado momento, ao contrrio das memrias primrias que permitem o acesso a qualquer registro de um arquivo a um custo uniforme. Os registros armazenados em fita magntica somente podem ser acessados de forma seqencial. Os registros armazenados em disco magntico ou disco tico podem ser acessados diretamente, mas a um custo maior do que o custo para acess-los seqencialmente. Os sistemas operacionais levam esse aspecto em considerao e dividem o arquivo em blocos, onde cada bloco constitudo de vrios registros. A operao bsica sobre arquivos trazer um bloco da memria secundria para uma rea de armazenamento na memria principal. Assim, a leitura de
155
156
CAPTULO 6. PESQUISA EM MEMRIA SECUNDRIA um nico registro implica na transferncia de todos os registros de um bloco para a memria principal. A escrita de registros em um arquivo segue caminho contrrio. Na medida em que registros so escritos no arquivo eles vo sendo colocados em posies contguas de memria na rea de armazenamento. Quando a rea de armazenamento no possui espao suficiente para armazenar mais um registro o bloco copiado para a memria secundria, deixando a rea de armazenamento vazia e pronta para receber novos registros. A tcnica de utilizao de reas de armazenamento evita que um processo que esteja realizando mltiplas transferncias de dados de forma seqencial tenha que ficar esperando que as transferncias se realizem para prosseguir o processamento. As transferncias so realizadas em blocos pelo sistema operacional diretamente para uma rea de armazenamento. 0 processo usurio pega o dado nesta rea e somente obrigado a esperar quando a rea se esvazia. Quando isto ocorre, o sistema operacional enche novamente a rea e o processo continua. Esta tcnica pode ser aprimorada com o uso de duas ou mais reas de armazenamento. Neste caso, enquanto um processo est operando em uma rea o sistema operacional enche a outra.
3. Para desenvolver um mtodo eficiente de pesquisa o aspecto sistema de computao da maior importncia. As caractersticas da arquitetura e do sistema operacional da mquina tornam os mtodos de pesquisa dependentes de parmetros que afetam seus desempenhos. Assim, a transferncia de blocos entre as memrias primria e secundria deve ser to eficiente quanto as caractersticas dos equipamentos disponveis o permitam. Tipicamente, a transferncia se torna mais eficiente quando o tamanho dos blocos de 512 bytes ou mltiplos deste valor, at 4096 bytes. Na prxima seo apresentamos um modelo de computao para memria secundria que transforma o endereo usado pelo programador no endereo fsico alocado para o dado a ser acessado. Este mecanismo utilizado pela maioria dos sistemas atuais para controlar o trnsito de dados entre o disco e a memria principal. A seguir, apresentamos o mtodo de acesso seqencial indexado e mostramos sua utilizao para manipular grandes arquivos em discos ticos de apenas leitura. Finalmente, apresentamos um mtodo eficiente para manipular grandes arquivos em discos magnticos que a rvore n-ria de pesquisa.
5.1. MODELO DE COMPUTAO PARA MEM. SECUNDRIA
157
5.1 Modelo de Computao para Memria Secundria

Esta seo apresenta um modelo de computao para memria secundria conhecido como memria virtual. Este modelo normalmente implementado como uma funo do sistema operacional. Uma exceo o sistema operacional DOS para microcomputadores do tipo IBM-PC, que, apesar de muito vendido no mundo inteiro, no oferece um sistema de memria virtual. Por essa razo, vamos apresentar o conceito e mostrar uma das formas possveis de se implementar um sistema de memria virtual. Alm disso, o conhecimento de seu funcionamento facilita a implementao eficiente dos algoritmos para pesquisa em memria secundria tambm em ambientes que j ofeream esta facilidade. Maiores detalhes sobre este tpico podem ser obtidos em livros da rea de sistemas operacionais, tais como Lister (1975), Peterson e Silberschatz (1983) e Tanenbaum (1987). Memria Virtual A necessidade de grandes quantidades de memria e o alto custo da memria principal tm levado ao modelo de sistemas de armazenamento em dois nveis. O compromisso entre velocidade e custo encontrado atravs do uso de uma pequena quantidade de memria principal (at 640 kbytes em microcomputadores do tipo IBM-PC usando sistema operacional DOS) e de uma memria secundria muito maior (vrios milhes de bytes). Como apenas a informao que est na memria principal pode ser acessada diretamente, a organizao do fluxo de informao entre as memrias primria e secundria extremamente importante. A organizao desse fluxo pode ser realizada utilizando-se um mecanismo simples e elegante para transformar o endereo usado pelo programador na correspondente localizao fsica de memria. 0 ponto crucial a distino entre espao de endereamento endereos usados pelo programador e espao de memria localizaes de memria no computador. O espao de endereamento N e o espao de memria M pode ser visto como um mapeamento de endereos do tipo f:NM. O mapeamento de endereos permite ao programador usar um espao de endereamento que pode ser maior que o espao de memria primria disponvel. Em outras palavras, o programador enxerga uma memria virtual cujas caractersticas diferem das caractersticas da memria primria. Existem vrias formas de implementar sistemas de memria virtual. Um dos meios mais utilizados o sistema de paginao no qual o espao de endereamento dividido em pginas de igual tamanho, em geral mltiplos
158
CAPTULO 5. PESQUISA EM MEMRIA SECUNDRIA
de 512 bytes, e a memria principal dividida de forma semelhante em Molduras_de_Pginas de igual tamanho. As Molduras de_Pginas contm algumas pginas ativas enquanto o restante das pginas esto residentes em memria secundria (pginas inativas). O mecanismo de paginao possui duas funes, a saber: a) realizar o mapeamento de endereos, isto , determinar qual pgina um programa est endereando, e encontrar a moldura, se existir, que contenha a pgina; b) transferir pginas da memria secundria para a memria primria quando necessrio, e transferi-las de volta para a memria secundria quando no esto mais sendo utilizadas. Para determinar a qual pgina um programa est se referindo, uma parte dos bits que compe o endereo interpretada como um nmero de pgina e a outra parte como o nmero do byte dentro da pgina. Por exemplo, se o espao de endereamento possui 24 bits ento a memria virtual de 224 bytes; se o tamanho da pgina de 512 bytes (29) ento 9 bits so utilizados para representar o nmero do byte dentro da pgina e os restantes 15 bits so utilizados para representar o nmero da pgina. O mapeamento de endereos a partir do espao de endereamento (nme ro da pgina mais nmero do byte) para o espao de memria (localizao fsica da memria) realizado atravs de uma Tabela_de_Pginas, cuja psima entrada contm a localizao p/ da Moldura_de_Pgina contendo a pgina nmero p, desde que esteja na memria principal (a possibilidade de que p no esteja na memria principal ser tratada logo frente). Logo, o mapeamento de endereos f(e)=f(p,b)=p/+b onde o endereo de programa e (nmero da pgina p e nmero do byte b) pode ser visto na Figura 5.1. A Tabela_de_Pginas pode ser um arranjo do tamanho do nmero de pginas possveis. Quando acontecer do programa enderear um nmero de pgina que no esteja na memria principal, a entrada correspondente na Tabela_de_Pginas estar vazia (p/ = nil) e a pgina correspondente ter que ser trazida da memria secundria para a memria primria, atualizando a Tabela_de_Pginas. Se no existir uma Moldura_de_Pgina vazia no momento de trazer uma nova pgina do disco ento alguma outra pgina tem que ser removida da memria principal para abrir espao para a nova pgina. O ideal remover a pgina que no ser referenciada pelo perodo de tempo mais longo no futuro. Entretanto, no h meios de se prever o futuro. O que normalmente
MODELO DE COMPUTAO PARA MEM. SECUNDRIA
159
F i g u r a 5.1: Mapeamento de endereos para paginao
feito tentar inferir o futuro a partir do comportamento passado. Existem vrios algoritmos propostos na literatura para a escolha da pgina a ser removida. Os mais comuns so: Menos Recentemente Utilizada (LRU). Um dos algoritmos mais utilizados o LRU (Least Recently Used), o qual remove a pgina menos recentemente utilizada, partindo do princpio que o comportamento futuro deve seguir o passado recente. Neste caso, temos que registrar a seqncia de acesso a todas as pginas. Uma forma possvel de implementar a poltica LRU para sistemas paginados atravs do uso de uma fila de Molduras_de_Pginas, conforme ilustrado na Figura 5.2. Toda vez que uma pgina utilizada (para leitura apenas, para leitura e escrita ou para escrita apenas), ela removida para o fim da fila (o que implica na alterao de cinco apontadores). A pgina que est na moldura do incio da fila a pgina LRU. Quando uma nova pgina tem que ser trazida da memria secundria ela deve ser colocada na moldura que contm a pgina LRU. Menos Freqentemente Utilizada (LFU). 0 algoritmo LFU (Least Frequently Used) remove a pgina menos freqentemente utilizada. A justificativa semelhante ao caso anterior, e o custo o de registrar o nmero de acessos a todas as pginas. Um inconveniente que uma pgina recentemente trazida da memria secundria tem um baixo nmero de acessos registrados e, por isso, pode ser removida.
160
CAPTULO 5. PESQUISA EM MEMRIA SECUNDARIA
Figura 5.2: Fila de Molduras_de_Pginas
Ordem de Chegada (FIFO). 0 algoritmo FIFO (First In First Out) remove a pgina que est residente h mais tempo. Este algoritmo o mais simples e o mais barato de se manter. A desvantagem que ele ignora o fato de que a pgina mais antiga pode ser a mais referenciada. Toda informao necessria ao algoritmo escolhido para remoo de pginas pode ser armazenada em cada Moldura_de_Pgina. Para registrar o fato de que uma pgina sofreu alterao no seu contedo (para sabermos se ela ter que ser reescrita na memria secundria) basta manter um bit na Moldura_de_Pgina correspondente. Resumindo, em um sistema de memria virtual o programador pode enderear grandes quantidades de dados, deixando para o sistema a responsabilidade de transferir o dado endereado da memria secundria para a memria principal. Esta estratgia funciona muito bem para os algoritmos que possuam uma localidade de referncia pequena, isto , cada referncia a uma localidade de memria tem grande chance de ocorrer em uma rea que relativamente perto de outras reas que foram recentemente referenciadas. Isto faz com que o nmero de transferncias de pginas entre a memria principal e a memria secundria diminua muito. Por exemplo, a maioria de referncias a dados no Quicksort ocorre perto de um dos dois apontadores que realizam a partio do conjunto, o que pode fazer com que este algoritmo de ordenao interna funcione muito bem em um ambiente de memria virtual para uma ordenao externa.
MODELO DE COMPUTAO PARA MEMRIA SECUNDRIA
161
P r o g r a m a 5.1: Estrutura de dados para o sistema de paginao
I m p l e m e n t a o de um S i s t e m a de P a g i n a o A seguir vamos mostrar uma das formas possveis de se implementar um sistema de paginao. A estrutura de dados apresentada no Programa 5.1. O Programa apresenta tambm a estrutura de dados para representar uma rvore binria de pesquisa, onde um apontador para um nodo da rvore representado pelo par nmero_da_pgina (p) e posio_dentro_da_pgina (b). Assumindo que a chave constituda por um inteiro de 2 bytes e o endereo ocupa 2 bytes para p e 1 byte para b, o total ocupado por cada nodo da rvore de 8 bytes. Como o tamanho da pgina de 512 bytes ento o nmero de itens (nodos) por pgina 64. Em algums casos pode ser necessrio manipular mais de um arquivo ao mesmo tempo. Neste caso, uma pgina pode ser definida como no Programa 5.2, onde o usurio pode declarar at trs tipos diferentes de pginas. Se o tipo PginaTipoA for declarado
162
O diagrama da Figura 5.3 mostra a transformao do endereo virtual para o endereo real de memria do sistema de paginao, tornando disponvel na memria principal o registro endereado pelo programador. Os quadrados representam resultados de processos ou arquivos, e os retngulos representam os processos transformadores de informao. A partir do endereo p o processo P1 verifica se a pgina que contm o registro solicitado se encontra na memria principal. Caso a pgina esteja na memria principal o processo P2 simplesmente retorna esta informao para o programa usurio. Se a pgina est ausente o processo P3 determina uma moldura para receber a pgina solicitada que dever ser trazida da memria secundria. Caso no haja nenhuma moldura disponvel, alguma pgina dever ser removida da memria principal para ceder lugar para a nova pgina, de acordo com o algoritmo adotado para remoo de pginas. Neste caso estamos assumindo o algoritmo mais simples de ser implementado, o FIFO, onde a pgina a ser removida a pgina que est na cabea da fila de Molduras_de_Pginas. Se a pgina a ser substituda sofreu algum tipo
5.2. ACESSO SEQENCIAL INDEXADO
163
Figura 5.3: Endereamento no sistema de paginao
de alterao no seu contedo ela dever ser gravada de volta na memria secundria pelo processo P5. 0 processo P4 l da memria secundria a pgina solicitada, coloca-a na moldura determinada pelo processo P3 e atualiza a Tabela_de_Pginas. 5.2 Acesso Seqencial Indexado O mtodo de acesso seqencial indexado utiliza o princpio da pesquisa seqencial: a partir do primeiro, cada registro lido seqencialmente at encontrar uma chave maior ou igual a chave de pesquisa. Para aumentar a eficincia, evitando que todos os registros tenham que ser lidos seqencialmente do disco, duas providncias so necessrias: (i) o arquivo deve mantido ordenado pelo campo chave do registro, (ii) um arquivo de n d i c e s contendo
164
pares de valores < x, p > deve ser criado, onde x representa uma chave e p representa o endereo da pgina na qual o primeiro registro contm a chave x. A Figura 5.4 mostra um exemplo da estrutura de um arquivo seqencial indexado para um conjunto de 15 registros. No exemplo, cada pgina tem capacidade para armazenar 4 registros do arquivo de dados e cada entrada do ndice de pginas armazena a chave do primeiro registro de cada pgina e o endereo da pgina no disco. Por exemplo, o ndice relativo primeira pgina informa que ela contm registros com chaves entre 3 e 14 exclusive, o ndice relativo a segunda pgina informa que ela contm registros com chaves entre 14 e 25 exclusive, e assim por diante.
Figura 5.4: Estrutura de um arquivo seqencial indexado Em um disco magntico vrias superfcies de gravao so utilizadas, conforme ilustra a Figura 5.5. 0 disco magntico dividido em crculos concntricos chamados trilhas. Quando o mecanismo de acesso est posicionado em uma determinada trilha, todas as trilhas que esto verticalmente alinhadas e possuem mesmo dimetro formam um cilindro. Neste caso, uma referncia a um registro que se encontre em uma pgina de qualquer trilha do cilindro no requer o deslocamento do mecanismo de acesso e o nico tempo necessrio o de latncia rotacional, que o tempo necessrio para que o incio do bloco que contenha o registro a ser lido passe pela cabea de leitura/gravao. A necessidade de deslocamento do mecanismo de acesso de uma trilha para outra responsvel pela parte maior do custo para acessar os dados e chamado de tempo de busca (seek time). Pelo fato de combinar acesso indexado com a organizao seqencial o mtodo chamado de acesso seqencial indexado. Para aproveitar as caractersticas do disco magntico e procurar minimizar o nmero de deslocamentos do mecanismo de acesso utiliza-se um esquema de ndices de cilindros e de pginas. Dependendo do tamanho do arquivo e da capacidade da memria principal disponvel possvel acessar qualquer registro do arquivo de dados realizando apenas um deslocamento do mecanismo de acesso. Para tal, um ndice de cilindros contendo o valor de chave mais alto dentre os registros
165
Figura 5.5: Disco magntico
de cada cilindro mantido na memria principal. Por sua vez, cada cilindro contm um ndice de blocos ou ndice de pginas, conforme mostrado na Figura 5.4. Para localizar o registro que contenha uma chave de pesquisa so necessrios os seguintes passos: 1. Localize o cilindro correspondente chave de pesquisa no ndice de cilindros; 2. Desloque o mecanismo de acesso at o cilindro correspondente; 3. Leia a pgina que contm o ndice de pginas daquele cilindro; 4. Leia a pgina de dados que contm o registro desejado. Desta forma, o mtodo de acesso seqencial indexado possibilita tanto o acesso seqencial quanto o acesso randmico. Entretanto, este mtodo adequado apenas para aplicaes nas quais as operaes de insero e de retirada ocorrem com baixa freqncia. Sua grande vantagem a garantia de acesso aos dados com apenas um deslocamento do mecanismo de acesso do disco magntico. Sua grande desvantagem a inflexibilidade: em um ambiente muito dinmico, com muitas operaes de insero e retirada, os dados tm que sofrer reorganizaes freqentes. Por exemplo, a adio de um registro com a chave 6 provoca um rearranjo em todos os registros do arquivo da Figura 5.4. Para contornar este problema necessrio criar reas de armazenamento (ou reas de overflow) para receber estes registros adicionais at que a prxima reorganizao de todo o arquivo seja realizada. Normalmente, uma rea de armazenamento reservada em cada cilindro, alm de uma
166
grande rea comum para ser utilizada quando alguma rea de algum cilindro tambm transborde. Assim, em ambientes realmente dinmicos, os tempos de acesso se deterioram rapidamente. Entretanto, em ambientes onde apenas a leitura de dados necessria, como no caso dos discos ticos de apenasleitura, o mtodo de acesso indexado seqencial bastante eficiente e adequado, conforme veremos na seo seguinte. Discos t i c o s de A p e n a s - L e i t u r a Os discos ticos de apenas-leitura, conhecidos como CD-ROM (Compact Disk Read Only Memory), tm sido largamente utilizados para distribuio de grandes arquivos de dados. 0 interesse crescente sobre os discos CD-ROM devido a sua capacidade de armazenamento (600 Megabytes) e baixo custo para o usurio final. As principais diferenas entre o disco CD-ROM e o disco magntico so: 1. o CD-ROM um meio de apenas-leitura e, portanto, a estrutura da informao armazenada esttica; 2. a eficincia na recuperao dos dados afetada pela localizao dos dados no disco e pela seqncia com que so acessados; 3. devido velocidade linear constante as trilhas possuem capacidade varivel e o tempo de latncia rotacional varia de trilha para trilha. Ao contrrio dos discos magnticos, a trilha no disco CD-ROM tem a forma de uma espiral contnua, embora para efeito de estudo analtico cada volta da espiral possa ser considerada como uma trilha. Ele possui cerca de 300.000 setores de tamanho fixo de 2 Kbytes, distribudos em aproximadamente 20.000 trilhas. Como a velocidade linear de leitura constante, o tempo de latncia rotacional varia de cerca de 60 milissegundos para as trilhas mais internas at 138 milissegundos para as trilhas mais externas. Por outro lado, o nmero de setores por trilha aumenta de 9 para a trilha mais interna at 20 para a trilha mais externa. No CD-ROM o tempo de busca (seek time) para acesso a trilhas mais distantes demanda mais tempo que no disco magntico devido necessidade de deslocamento do mecanismo de acesso e mudanas na rotao do disco. Entretanto, possvel acessar um conjunto de trilhas vizinhas sem nenhum deslocamento do mecanismo de leitura. Esta caracterstica dos discos CDROM , denominada varredura esttica. Nos discos atuais a amplitude de varredura esttica pode atingir at 60 trilhas ( 30 trilhas a partir da trilha corrente). 0 acesso a trilhas dentro da amplitude da varredura esttica consome 1 milissegundo por trilha adicional, sendo realizado por um pequeno deslocamento angular do feixe de laser a partir da trilha corrente, chamada
167
de ponto de ncora. Neste caso, o tempo de procura desprezvel se comparado com o tempo de latncia rotacional. Para acessar trilhas fora da varredura esttica o tempo de procura varia de 200 at 600 milissegundos. Conforme mostrado na seo imediatamente anterior, a estrutura seqencial indexada permite tanto o acesso seqencial quanto o acesso randmico aos dados. Nos discos magnticos a estrutura seqencial indexada implementada mantendo-se um ndice de cilindros na memria principal. Neste caso, cada acesso demanda apenas um deslocamento do mecanismo de acesso, desde que cada cilindro contm um ndice de pginas com o maior valor de chave em cada pgina daquele cilindro. Entretanto, para aplicaes dinmicas esta condio no pode ser mantida se um nmero grande de registros tem que ser adicionado ao arquivo. No caso dos discos CD-ROM esta organizao particularmente interessante devido natureza esttica da informao. O conceito de cilindro em discos magnticos pode ser estendido para os discos CD-ROM. Barbosa e Ziviani (1992) denominaram o conjunto de trilhas cobertas.por uma varredura esttica de cilindro tico. 0 cilindro tico difere do cilindro de um disco magntico em dois aspectos: (i) as trilhas de uma varredura esttica que compem um cilindro tico podem se sobrepor a trilhas de outro cilindro tico com ponto de ncora prximo; (ii) como as trilhas tm capacidade varivel, os cilindros ticos com ponto de ncora em trilhas mais internas tm capacidade menor do que cilindros ticos com ponto de ncora em trilhas mais externas. Em um trabalho analtico sobre discos ticos Christodoulakis e Ford ( 1988) demonstraram que o nmero de deslocamentos e a distncia total percorrida pela cabea tica de leitura so minimizados quando (i) as trilhas de duas varreduras estticas consecutivas no se sobrepem, (ii) a cabea de leitura se movimenta apenas em uma direo durante a recuperao de um conjunto de dados. A estrutura seqencial indexada pode ser implementada eficientemente no CD-ROM considerando a natureza esttica da informao e a capacidade de varredura esttica do mecanismo de leitura. A partir destas observaes, Barbosa e Ziviani (1992) propuseram uma estrutura seqencial indexada para discos CD-ROM na qual o mecanismo de leitura posicionado em cilindros ticos pr-selecionados, com o objetivo de evitar sobreposio de varreduras e minimizar o nmero de deslocamentos da cabea de leitura. Para tal, a estrutura de ndices construda de maneira que cada pgina de ndices faa referncia ao maior nmero possvel de pginas de dados de um cilindro tico. A Figura 5.6 mostra esta organizao para um arquivo exemplo de 3 Megabytes, alocado a partir da trilha 1940 do disco, no qual cada pgina ocupa 2 Kbytes (equivalente a 1 setor do disco). Supondo que o mecanismo de leitura tenha uma amplitude de varredura esttica de 8 trilhas, na posio
168
Figura 5.6: Organizao de urn arquivo indexado seqencial para o CD-ROM
de trilha nmero 1940 possvel acessar aproximadamente 78 setores sem deslocamento da cabea de leitura. Assim sendo, para obter uma organizao seqencial indexada para este arquivo so necessrios os seguintes passos: 1. Alocar o arquivo no disco determinando a trilha inicial e calculando a trilha final que ele deve ocupar; 2. Computar o nmero total de cilindros ticos para cobrir todas as trilhas do arquivo sem que haja sobreposio de trilhas. Determine os respectivos pontos de ncora; 3. Construir um ndice de cilindros ticos, o qual dever conter o valor de chave mais alto associado aos registros que esto dentro de cada cilindro tico. 0 ndice de cilindros ticos deve ser mantido na memria principal; 4. Construir um ndice de pginas para cada cilindro tico. Este ndice dever conter o valor de chave mais alto de cada pgina e deve ser armazenado na trilha central ou ponto de ncora de cada cilindro tico. Para recuperar uma dada chave de pesquisa o primeiro passo obter o endereo do cilindro tico que contm a chave consultando o ndice de cilindros ticos na memria principal. 0 mecanismo de leitura ento deslocado para o ponto de ncora selecionado na nica operao de busca necessria. A seguir, o ndice de pginas lido e a pgina de dados contendo a chave de pesquisa poder ser encontrada dentro dos limites da varredura esttica. Os detalhes para obteno do nmero de trilhas que um arquivo deve ocupar a partir de determinada posio no disco, os pontos de ncora dos cilindros ticos, ou quaisquer outros, podem ser obtidos em Barbosa e Ziviani (1992).
169
5.3 rvores de Pesquisa

As rvores binrias de pesquisa introduzidas na Seo 4.3 so estruturas de dados muito eficientes quando se deseja trabalhar com tabelas que caibam inteiramente na memria principal do computador. Elas satisfazem condies e requisitos diversificados e conflitantes, tais como acesso direto e seqencial, facilidade de insero e retirada de registros e boa utilizao de memria. Vamos agora considerar o problema de recuperar informao em grandes arquivos de dados que estejam armazenados em memria secundria do tipo disco magntico. Uma forma simplista de resolver este problema utilizando rvores binrias de pesquisa armazenar os nodos da rvore no disco e os apontadores esquerda e direita de cada nodo se tornam endereos de disco ao invs de endereos de memria principal. Se a pesquisa for realizada utilizando o algoritmo de pesquisa para memria principal visto anteriormente sero necessrios da ordem de log2 n acessos a disco, significando que um arquivo com n = 106 registros necessita aproximadamente log2 106 20 buscas no disco. Para diminuir o nmero de acessos a disco, os nodos da rvore podem ser agrupados em pginas, conforme ilustra a Figura 5.7. Neste exemplo, o formato da rvore muda de binrio para quaternrio, com quatro filhos por pgina, onde o nmero de acessos a pginas cai para metade no pior caso. Para arquivos divididos em pginas de 127 registros, possvel recuperar qualquer registro do arquivo com trs acessos a disco no pior caso.
Figura 5.7: rvore binria dividida em pginas A forma de organizar os nodos da rvore dentro de pginas muito importante sob o ponto de vista do nmero esperado de pginas lidas quando se realiza uma pesquisa na rvore. A rvore da Figura 5.7 tima sob este aspecto. Entretanto, a organizao tima difcil de ser obtida durante a construo da rvore, tornando-se um problema de otimizao muito com-
170
plexo. Um algoritmo bem simples, o da alocao seqencial, armazena os nodos em posies consecutivas na pgina medida em que vo chegando, sem considerar o formato fsico da rvore. Este algoritmo utiliza todo o espao disponvel na pgina, mas os nodos dentro da pgina esto relacionados pela localidade da ordem de entrada das chaves e no pela localidade dentro da rvore, o que torna o tempo de pesquisa muito pior do que o tempo da rvore tima. Um mtodo de alocao de nodos em pginas que leva em considerao a relao de proximidade dos nodos dentro da estrutura da rvore foi proposto por Muntz e Uzgalis (1970). No mtodo proposto, o novo nodo a ser inserido sempre colocado na mesma pgina do nodo pai. Se o nodo pai estiver em uma pgina cheia, ento uma nova pgina criada e o novo nodo colocado no incio da nova pgina. Knuth (1973) mostrou que o nmero esperado de acessos a pginas em uma pesquisa na rvore muito prxih (1973) mostrou que o nmero esperado de acessos a pginas em uma pesquisa na rvore muito prximo do timo. Entretanto, a ocupao mdia das pginas extremamente baixa, da ordem de 10%, o que torna o algoritmo invivel para aplicaes prticas. Uma soluo brilhante para este problema, simultaneamente com uma proposta para manter equilibrado o crescimento da rvore e permitir inseres e retiradas a vontade, o assunto da prxima seo.
5.3.1 rvores B
O objetivo desta seo o de apresentar uma tcnica de organizao e manu teno de arquivos atravs do uso de rvores B (Bayer e McCreight, 1972). A origem do nome rvores B nunca foi explicada pelos autores, R. Bayer e E. McCreight, cujo trabalho foi desenvolvido no Boeing Scientific Research Labs. Alguns autores sugerem que o "B" se refere a "Boeing", enquanto Comer (1979) acha apropriado pensar em "B-trees" como "Bayer-trees", por causa das contribuies de R. Bayer ao assunto. Outras introdues ao assunto podem ser encontradas em Comer (1979), Wirth (1976), e Knuth ( 1973). Definio e A l g o r i t m o s Quando uma rvore de pesquisa possui mais de um registro por nodo ela deixa de ser binria. Estas rvores so chamadas n-rias, pelo fato de possurem mais de dois descendentes por nodo. Nestes casos os nodos so mais comumente chamados de pginas. A rvore B n-ria. Em uma rvore B de ordem m temos que: 1. cada pgina contm no mnimo m registros (e m + 1 descendentes) e
171
no mximo 2m registros (e 2m + 1 descendentes), exceto a pgina raiz que pode conter entre 1 e 2m registros; 2. todas as pginas folha aparecem no mesmo nvel. Uma rvore B de ordem m = 2 com 3 nveis pode ser vista na Figura 5.8. Todas as pginas contm 2, 3, ou 4 registros, exceto a raiz que pode conter um registro apenas. Os registros aparecem em ordem crescente da esquerda para a direita. Este esquema representa uma extenso natural da organizao da rvore binria de pesquisa. A Figura 5.9 apresenta a forma geral de uma pgina de uma rvore B de ordem m.
Figura 5.9: Nodo de uma rvore B de ordem m com 2m registros
A estrutura de dados rvore B ser utilizada para implementar o tipo abstrato de dados Dicionrio, com as operaes Inicializa, Pesquisa, Insere e Retira. A estrutura e a representao do Dicionrio apresentada no Programa 5.3, onde mm significa 2m. 0 procedimento Inicializa extremamente simples, conforme ilustra o Programa 5.4. Um procedimento Pesquisa para rvore B semelhante ao algoritmo Pesquisa para rvore binria de pesquisa, conforme pode ser visto no Programa 5.5. Para encontrar um registro x, primeiro compare a chave que rotula o registro com as chaves que esto na pgina raiz, at encontrar o intervalo onde ela se encaixa. Depois, siga o apontador para a subrvore correspondente ao intervalo citado e repita o processo recursivamente, at que a chave procurada seja encontrada ou ento uma pgina folha seja atingida (no caso um apontador nulo). Na implementao do Programa 5.5 a
172
Programa 5.4: Procedimento para inicializar uma rvore B
localizao do intervalo onde a chave se encaixa obtida atravs de uma pesquisa seqencial. Entretanto, esta etapa pode ser realizada de forma mais eficiente atravs do uso de pesquisa binria (vide Seo 4.2). Vamos ver agora como inserir novos registros em uma rvore B. Em primeiro lugar preciso localizar a pgina apropriada onde o novo registro deve ser inserido. Se o registro a ser inserido encontra seu lugar em uma pgina com menos de 2m registros, o processo de insero fica limitado quela pgina. Entretanto, quando um registro precisa ser inserido em uma pgina j cheia (com 2m registros), o processo de insero pode provocar a criao de uma nova pgina. A Figura 5.10, parte (b), ilustra o que acontece quando o registro contendo a chave 14 inserido na rvore da parte (a). 0 processo composto pelas seguintes etapas: 1. O registro contendo a chave 14 no encontrado na rvore, e a pgina 3 (onde o registro contendo a chave 14 deve ser inserido) est cheia. 2. A pgina 3 dividida em 2 pginas, o que significa que uma nova pgina 4 criada. 3. Os 2m+1 registros (no caso so 5 registros) so distribudos igualmente entre as pginas 3 e 4, e o registro do meio (no caso o registro contendo a chave 20) movido para a pgina pai no nvel acima.
173
F i g u r a 5 . 1 0 : Insero em u m a r v o r e B d e o r d em 2
No esquema de insero apresentado acima, a pgina pai tem que acomodar um novo registro. Se a pgina pai tambm estiver cheia, ento o mesmo processo de diviso tem que ser aplicado de novo. No pior caso, o processo de diviso pode se propagar at a raiz da rvore e, neste caso, a rvore aumenta sua altura de um nvel. E interessante observar que uma rvore B somente aumenta sua altura atravs da diviso da raiz. Um primeiro refinamento do procedimento Insere pode ser visto no Pro-. grama 5.6. 0 procedimento contm um outro procedimento interno recursivo, de nome Ins, de estrutura semelhante ao Programa 5.5 acima. Quando um apontador nulo encontrado, significa que o ponto de insero foi localizado. Neste momento o parmetro Cresceu passa a indicar este fato informando que um registro vai ser passado para cima atravs do parmetro
174
RegRetorno para ser inserido na prxima pgina que contenha espao para acomod-lo. Se Cresceu = t r u e no momento do retorno do procedimento Ins para o procedimento Insere significa que a pgina raiz foi dividida e ento uma nova pgina raiz deve ser criada para acomodar o registro emergente, fazendo com que a rvore cresca na altura. p r o c e d u r e Insere (Reg: Registro; var Ap: Apontador); procedure Ins (Reg:Registro; Ap:Apontador; var Cresceu:Boolean; var RegRetorno:Registro; var ApRetorno:Apontador);
Programa 5.G: Primeiro refinamento do algoritmo Insere na rvore B
O procedimento Insere utiliza o procedimento auxiliar InsereNaPgina mostrado no Programa 5.7.
175
176
CAPITULO 5. PESQUISA EM MEMRIA SECUNDRIA
P r o g r a m a 5.8: Refinamento final do algoritmo Insere
A Figura 5.11 mostra o resultado obtido quando se insere uma seqncia de chaves em uma rvore B de ordem 2: A rvore da Figura 5.11, parte (a), obtida aps a insero da chave 20, a rvore da parte (b) obtida aps a insero das chaves 10, 40, 50 e 30 na rvore da parte (a), a rvore da parte
177
(c) obtida aps a insero das chaves 55, 3, 11, 4, 28, 36, 33, 52, 17, 25 e 13 na rvore da parte (b) e, finalmente, a rvore da parte (d) obtida aps a insero das chaves 45, 9, 43, 8 e 48.
Figura 5.11: Crescimento de uma rvore B de ordem 2
A ltima operao a ser estudada de retirada. Quando a pgina que contm o registro a ser retirado uma pgina folha a operao simples. No caso de no ser uma pgina folha, o registro a ser retirado deve ser primeiro substitudo por um registro contendo uma chave adjacente (antecessora ou sucessora), como no caso da operao de retirada de registros em rvores binrias de pesquisa, conforme mostrado na Seo 4.3. Para localizar uma chave lexicograficamente antecessora, basta procurar pela pgina folha mais direita na subrvore esquerda. Por exemplo, a antecessora da chave 30 na rvore da Figura 5.11 (d) a chave 28. To logo o registro seja retirado da pgina folha, necessrio verificar se pelo menos m registros passam a ocupar a pgina. Quando menos do que m registros passam a ocupar a pgina significa que a propriedade rvore B violada. Para reconstituir a propriedade rvore B necessrio tomar emprestado um registro da pgina vizinha. Conforme pode ser verificado na Figura 5.12, existem duas possibilidades: 1. O nmero de registros na pgina vizinha maior do que m: basta tomar um registro emprestado e traz-lo para a pgina em questo via pgina pai. A Figura 5.12 (a) mostra a retirada da chave 3.
178
2. No existe um nmero suficiente de registros na pgina vizinha (a pgina vizinha possui exatamente m registros): neste caso o nmero total de registros nas duas pginas 2m 1 e, conseqentemente, as duas pginas tm que ser fundidas em uma s, tomando emprestado da pgina pai o registro do meio, o que permite liberar uma das pginas. Este processo pode se propagar at a pgina raiz e no caso em que o nmero de registros da pgina raiz fica reduzido a zero ela eliminada, causando reduo na altura da rvore. A Figura 5.12 (b) mostra a retirada da chave 3.
(b) Pgina vizinha possui exatamente m registros

Figura 5.12: Retirada da chave 3 na rvore B de ordem m = 1
O procedimento Retira apresentado no Programa 5.9. 0 procedimento contm um outro procedimento interno recursivo, de nome Ret. No procedimento Ret, quando a pgina que contm o registro a ser retirado uma pgina folha a operao simples. No caso de no ser uma pgina folha, a tarefa de localizar o registro antecessor realizada pelo procedimento Antecessor. A condio de que menos do que m registros passam a ocupar a pgina sinalizada pelo parmetro Diminuiu, fazendo com que o procedimento Reconstitui seja ativado. procedure Retira (Ch : TipoChave; var Ap : Apontador); var Diminuiu : Boolean; Aux : Apontador; procedure Ret(Ch:TipoChave; var Ap:Apontador; var Diminuiu:Boolean); var Ind, j : integer;
179
180
181
182
5.3.2 r v o r e s B*
Existem vrias alternativas para implementao da rvore B original. Uma delas a rvore B*. Em uma rvore B*, todos os registros so armazenados no ltimo nvel (pginas folhas). Os nveis acima do ltimo nvel constituem um ndice cuja organizao a organizao de uma rvore B. A Figura 5.14 mostra a separao lgica entre o ndice e os registros que constituem o arquivo propriamente dito. No ndice s aparecem as chaves, sem nenhuma informao associada, enquanto nas pginas folha esto todos os registros do arquivo. As pginas folha so conectadas da esquerda para a direita, o que permite um acesso seqencial mais eficiente do que o acesso atravs do ndice. Alm do acesso seqencial mais eficiente, as rvores B* apresentam outras vantagens sobre as rvores B, como a de facilitar o acesso concorrente ao arquivo, conforme veremos adiante.
Para recuperar um registro, o processo de pesquisa inicia-se na raiz da rvore e continua at uma pgina folha. Como todos os registros residem nas folhas, a pesquisa no pra se a chave procurada for encontrada em uma pgina do ndice. Neste caso o apontador direita seguido at que uma pgina folha seja encontrada. Esta caracterstica pode ser vista na rvore B* da Figura 5.15 onde as chaves 29, 60, e 75 aparecem no ndice e em registros do arquivo. Os valores encontrados ao longo do caminho so irrelevantes desde que eles conduzam pgina folha correta. Como no h necessidade do uso de apontadores nas pginas folha possvel utilizar este espao para armazenar uma quantidade maior de registros em cada pgina folha. Para tal devemos utilizar um valor de m diferente para para as pginas folha. Isto no cria nenhum problema para os algoritmos de insero pois as metades de uma pgina que est sendo particionada permanecem no mesmo nvel da pgina original antes da partio ( algo semelhante acontece com a retirada de registros). A estrutura de dados rvore B* apresentada no Programa 5.10. O procedimento Pesquisa deve ser implementado como no Programa 5.11.
183
184
Figura 5.15: Exemplo de uma rvore B"
A operao de insero de um registro em uma rvore B* essencialmente igual insero de um registro em uma rvore B. A nica diferena que quando uma folha dividida em duas, o algoritmo promove uma cpia da chave que pertence ao registro do meio para a pgina pai no nvel anterior, retendo o registro do meio na pgina folha da direita. A operao de retirada em uma rvore B* relativamente mais simples do que em uma rvore B. 0 registro a ser retirado reside sempre em uma pgina folha, o que torna sua remoo simples, no havendo necessidade de utilizao do procedimento para localizar a chave antecessora (vide procedimento Antecessor do Programa 5.9). Desde que a pgina folha fique pelo menos com metade dos registros, as pginas do ndice no precisam ser modificadas, mesmo se uma cpia da chave que pertence ao registro a ser retirado esteja no ndice. A Figura 5.16 mostra a rvore B* resultante quando a seguinte seqncia de chaves retirada da rvore B* da Figura 5.15: 5 19 22 60; 9. Observe que a retirada da chave 9 da rvore da Figura 5.16, parte (a), provoca a reduo da rvore. 5.3.3 Acesso C o n c o r r e n t e em rvores B* Em muitas aplicaes o acesso simultneo ao banco de dados por mais de um usurio fator importante. Nestes casos, permitir acesso para apenas um processo de cada vez pode criar um gargalo inaceitvel para o sistema de banco de dados. Concorrncia ento introduzida para aumentar a utilizao e melhorar o tempo de resposta do sistema. Deste modo o uso de rvores B* em tais sistemas deve permitir o processamento simultneo de vrias solicitaes diferentes. Entretanto, existe a necessidade de se criar mecanismos chamados protocolos para garantir a integridade tanto dos dados quanto da estrutura. Considere a situao em que dois processos estejam simultaneamente acessando o banco de dados. Em um determinado momento, um dos processos est percorrendo uma pgina para localizar o intervalo onde a chave de pesquisa se encaixa e seguir o apontador para a subrvore correspondente, enquanto o outro processo est inserindo um novo registro que provoca divises
185
F i g u r a 5.16: Retirada de registros em rvores B*
de pginas no mesmo caminho da rvore. Pode acontecer que o processo que est percorrendo a pgina pode obter um apontador que fica apontando para uma subrvore errada ou para um endereo inexistente. Uma pgina chamada segura quando se sabe que no existe possibilidade de modificaes na estrutura da rvore, como conseqncia de uma operao de insero ou de retirada naquela pgina. Cabe lembrar que a operao de recuperao no altera a estrutura da rvore, ao contrrio das operaes de insero ou retirada, que podem provocar modificaes na estrutura da rvore. No caso de operaes de insero, uma pgina considerada segura se o nmero atual de chaves naquela pgina menor do que 2m. No caso de operaes de retirada, uma pgina considerada segura quando o nmero de chaves na pgina maior do que m. Os algoritmos para acesso concorrente fazem uso destes fatos para aumentar o nvel de concorrncia em uma rvore B*. Bayer e Schkolnick (1977) apresentam um conjunto de trs diferentes alternativas de protocolos para travamentos1 (lock protocols) que asseguram a integridade dos caminhos de acesso aos dados da rvore B*, e, ao mesmo tempo, permitem acesso concorrente. Em uma das alternativas pro-postas a operao de recuperao trava (ou retm) uma pgina to logo ela seja lida, de modo que outros processos no possam interferir com a pgina. Na medida em que a pesquisa continua em direo ao nvel seguinte
1 Um protocolo para travamento um mecanismo que assegura a modificao de apenas uma pgina de cada vez na rvore.
186
da rvore, a trava aplicada na pgina antecessora liberada, permitindo a leitura das pginas por outros processos. Um processo executando uma operao de recuperao chamado processo leitor, enquanto um processo executando uma operao de insero ou de retirada chamado processo modificador. A operao de modificao requer protocolos mais sofisticados, porque tal operao pode modificar as pginas antecessoras nos nveis acima. Em uma das alternativas apresentadas por Bayer e Schkolnick (1977), o processo modificador coloca um travamento exclusivo em cada pgina acessada, podendo mais tarde liberar o travamento caso a pgina seja segura. Vamos apresentar a seguir o protocolo para processos leitores e o protocolo para processos modificadores relativos alternativa mais simples dentre as trs alternativas apresentadas por Bayer e Schkolnick (1977). Estes protocolos utilizam dois tipos de travamento: 1. o travamento-para-leitura, que permite um ou mais leitores acessarem os dados, mas no permite insero ou retirada de chaves; 2. o travamento-exclusivo, que permite qualquer tipo de operao na pgina (quando um processo recebe este tipo de travamento, nenhum outro processo pode operar na pgina). O protocolo para processos leitores : (0) Coloque um travamento-para-leitura na raiz; (1) Leia a pgina raiz e faa-a pgina corrente; (2) Enquanto a pgina corrente no uma pgina folha faa {o n de travamentos-para-leitura mantidos pelo processo = 1 } (3) Coloque um travamento-para-leitura no descendente apropriado; (4) Libere o travamento-para-leitura na pgina corrente; (5) Leia a descendente cia pgina corrente e faa-a pgina corrente. O protocolo para processos modificadores : (0) Coloque um travamento-exclusivo na raiz; (1) Leia a pgina raiz e faa-a pgina corrente; (2) Enquanto a pgina corrente no uma pgina folha faa {o nmero de travamentos-exclusivos mantidos pelo processo 1 } (3) Coloque um travamento-exclusivo no descendente apropriado; (4) Leia a descendente da pgina corrente e faa-a pgina corrente; (5) Se a pgina corrente segura ento libere todos os travamentos mantidos sobre as pginas antecessoras da pgina corrente.
187
Para exemplificar o funcionamento do modelo do protocolo para processos modificadores considere a modificao da pgina y da rvore B* apresentada na Figura 5.17. Assuma que as pginas , , e so seguras, e a pgina y no segura. Antes da execuo do anel principal (passos 2 a 5 do algoritmo), um travamento-exclusivo colocado na pgina raiz, e a pgina lida e examinada. A seguir a seguinte seqncia de eventos ocorre: Passo 3: Um travamento-exclusivo sobre a pgina solicitado; Passo 4: Aps receber o travamento-exclusivo a pgina lida; Passo 5: Desde que a pgina segura, o travamento-exclusivo sobre a pgina a e liberado, permitindo o acesso a pgina a para outros processos; Passo 3: Um travamento-exclusivo sobre a pgina solicitado; Passo 4: Aps receber o travamento-exclusivo a pgina lida; Passo 5: Desde que a pgina no segura, o travamento-exclusivo sobre a pgina mantido; Passo 3: Um travamento-exclusivo sobre a pgina solicitado; Passo 4: Aps receber o travamento-exclusivo, a pgina b lida; Passo 5: Desde que a pgina segura, os travamentos-exclusivos sobre as pginas ( e podem ser liberados. A soluo apresentada acima requer um protocolo bem simples e ainda assim permite um nvel razovel de concorrncia. Essa soluo pode ser melhorada em relao ao nvel de concorrncia com a utilizao de protocolos mais sofisticados. Por exemplo, o processo modificador pode fazer uma " reserva" em cada pgina acessada e mais tarde modificar a reserva para travamento-exclusivo caso o processo modificador verifique que as modificaes a serem realizadas na estrutura da rvore devero se propagar at a pgina com reserva. Essa soluo aumenta o nvel de concorrncia, desde que as pginas com reserva possam ser lidas por outros processos. Os tipos de travamentos referidos aqui so aplicados ao nvel fsico do banco de dados. Em um banco de dados cujo acesso aos dados realizado atravs de uma rvore B*, a unidade de transferncia dos dados da memria secundria para a memria principal a pgina. Deste modo, os protocolos de travamento so aplicados neste nvel. A implementao dos travamentos descritos acima pode ser obtida usando semforos. De acordo com Dijkstra (1965), um semforo um inteiro
188
Figura 5.17: Parte de uma rvore B*
no negativo que pode ser modificado somente pelas operaes wait e signal, assim descritas: wait (s): when s > 0 do s := s 1; e signal (s): s := s + 1. A operao s := s + 1 indivisvel, isto , somente um processo consegue realiz-la de cada vez. Por exemplo, se dois processos A e B querem realizar signal (s) ao mesmo tempo para s = 3, ao final s = 5. Se a operao s := s + l no indivisvel e as duas operaes atribuem o resultado 4 a s, o resultado final pode ser 4 (e no 5). Outra referncia sobre semforos, bem como sua aplicao para sincronizar processos concorrentes, pode ser encontrada em Lister (1975). Outro importante aspecto a ser considerado em um ambiente de processamento concorrente o problema de deadlock. 0 deadlock ocorre quando dois processos esto inserindo um registro cada um em pginas adjacentes que estejam cheias. Neste caso cada um dos processos fica esperando pelo outro eternamente. Lister (1975) mostra que o deadlock pode ser evitado atravs da eliminao de dependncias circulares entre processos e recursos. Esta condio pode ser satisfeita atravs do uso da estrutura em rvore para ordenar todas as solicitaes para acessar o banco de dados. Basta que os algoritmos usem as operaes de travamento de cima para baixo, isto , da pgina raiz para as pginas folha. Bayer e Schkolnick (1977) provaram que as solues apresentadas so livres de deadlock.
5.3 . RVORES DE PESQUISA
189
5.3.4 Consideraes P r a t i c a s
A rvore B simples, de fcil manuteno, eficiente e verstil. A rvore B permite acesso seqencial eficiente, e o custo para recuperar, inserir, e retirar registros do arquivo logartmico. O espao utilizado pelos dados , no mnimo, 50% do espao reservado para o arquivo. Oespao utilizado varia com a aquisio e liberao da rea utilizada, medida em que o arquivo cresce ou diminui de tamanho. As rvores B crescem e diminuem automaticamente, e nunca existe necessidade de uma reorganizao completa do banco de dados. O emprego de rvores B em ambientes onde o acesso concorrente ao banco de dados necessrio vivel e relativamente simples de ser implementado. Um bom exemplo de utilizao prtica de rvores B* o mtodo de acesso a arquivos da IBM, chamado VSAM (Keehn e Lacy, 1974; Wagner, 1973). VSAM um mtodo de acesso a arquivos de aplicao geral que permite tanto o acesso seqencial eficiente, bem como as operaes de insero, retirada e recuperao em tempo logartmico. Comparado com a organizao indexado seqencial, o mtodo VSAM oferece as vantagens da alocao dinmica de memria, garantia de utilizao de no mnimo 50% da memria reservada ao arquivo, e nenhuma necessidade de reorganizao peridica de todo o arquivo. O VSAM considerado uma evoluo do antigo ISAM, o qual utiliza o mtodo indexado seqencial (vicie Seo 5.2). Anlise Pelo que foi visto acima, as operaes de insero e retirada de registros em uma rvore B sempre deixam a rvore balanceada. Alm do mais, o caminho mais longo em uma rvore B de ordem m com N registros contm no mximo cerca de log,m+1N pginas. De fato, Bayer e McCreight (1972) provaram que os limites para a altura mxima e altura mnima de uma rvore B de ordem m contendo N registros so
O custo para processar uma operao de recuperao de um registro cresce com o logaritmo base m do tamanho do arquivo. Para se ter uma idia do significado da frmula acima, considere a Tabela 5.1. Uma rvore B de ordem 50, representando um ndice de um arquivo de um milho de registros, permite a recuperao de qualquer registro com 4 acessos ao disco, no pior caso. Na realidade o nmero de acessos no caso mdio e 3. A altura esperada de uma rvore B no conhecida analiticamente, pois ningum foi capaz de apresentar um resultado analtico. A partir do clculo analtico do nmero esperado de pginas para os quatro primeiros nveis
190

Tamanho Tamanho do arquivo da pgina 1 . 0 0 0 10.000 100.000 1.000.000 10 3 4 5 6 50 2 3 3 4 100 2 2 3 3 150 2 2 3 3
10.000.000 7 4 4 4
Tabela 5.1: Nmero de acessos a disco, no pior caso, para tamanhos variados de pginas e arquivos usando rvore B
contados das pginas folha em direo pgina raiz 'de uma rvore 2-3 (ou rvore B de ordem m = 1) obtido por Eisenbarth, Ziviani, Gonnet, Mehlhorn e Wood (1982, p. 159), eles propuseram a seguinte conjetura: a altura esperada de uma rvore 2-3 randmica (vide definio de rvore de pesquisa randmica na Seo 4.3) com N chaves
Outras medidas de complexidade relevantes para as rvores B randmicas so: 1. A utilizao de memria cerca de ln 2 para o algoritmo original proposto por Bayer e McCreight (1972). Isto significa que as pginas tm uma ocupao de aproximadamente 69% da rea reservada aps N inseres randmicas em uma rvore B inicialmente vazia. 2. No momento da insero, a operao mais cara a partio da pgina quando ela passa a ter mais do que 2m chaves, desde que a operao envolve a criao de uma nova pgina, o rearranjo das chaves e a insero da chave do meio na pgina pai localizada no nvel acima. Uma medida de complexidade de interesse Pr{j parties}, que corresponde probabilidade de que j parties ocorram durante a N-sima insero randmica. No caso da rvore 2-3
191
No caso de uma rvore B de ordem m = 70, Pr{1 ou mais parties} 0, 01. Em outras palavras, em 99% das vezes nada acontece em termos de parties durante uma insero. 3. Considere o acesso concorrente em rvores B. Bayer e Schkolnick (1977) propuseram a tcnica de aplicar um travamento na pgina segura mais profunda (Psmp) no caminho de insero. De acordo com o que foi mostrado na Seo 5.3.3, uma pgina segura se ela contm menos do que 2m chaves. Uma pgina segura a mais profunda de um caminho de insero se no existir outra pgina segura abaixo dela. Desde que o travamento da pgina impede o acesso de outros processos interessante saber qual a probabilidade de que a pgina segura mais profunda esteja no primeiro nvel. Estas medidas esto relacionadas com as do item anterior. No caso da rvore 2-3
Novamente, no caso de uma rvore B de ordem m = 70, em 99% das vezes a pgina segura mais profunda (Psmp) est localizada em uma pgina folha, o que permite um alto grau de concorrncia para processos modificadores. Estes resultados mostram que solues muito complicadas para permitir o uso de concorrncia de operaes em rvores B no trazem grandes benefcios porque, na maioria das vezes, o travamento ocorrer em pginas folha, o que permite alto grau de concorrncia mesmo para os protocolos mais simples. Maiores detalhes sobre os resultados analticos apresentados acima podem ser obtidos em Eisenbarth et al. (1982).
192
Observaes Finais Existem inmeras variaes sobre o algoritmo original da rvore B. Uma delas a rvore B*, tratada na Seo 5.3.2. Outra importante modificao a tcnica de transbordamento (ou tcnica de overflow) proposta por Bayer e McCreight (1972) e Knuth (1973). A idia a seguinte: assuma que um registro tenha que ser inserido em uma pgina cheia que contenha 2m registros. Ao invs de particion-la, ns olhamos primeiro para a pgina irm direita. Se a pgina irm possui menos do que 2m registros, um simples rearranjo de chaves torna a partio desnecessria. Se a pgina direita tambm estiver cheia ou no existir, ns olhamos para a pgina irm esquerda. Se ambas estiverem cheias, ento a partio ter que ser realizada. 0 efeito desta modificao o de produzir uma rvore com melhor utilizao de memria e uma altura esperada menor. Esta alterao produz uma utilizao de memria de cerca de 83% para uma rvore B randmica. Qual a influncia de um sistema de paginao no comportamento de uma rvore B? Desde que o nmero de nveis de uma rvore B muito pequeno (apenas 3 ou 4) se comparado com o nmero de molduras de pginas, o sistema de paginao garante que a pgina raiz esteja sempre presente na memria principal, desde que a poltica de reposio de pginas adotada seja a poltica LRU. 0 esquema LRU faz tambm com que as pginas a serem particionadas em uma insero estejam automaticamente disponveis na memria principal. Finalmente, importante observar que a escolha do tamanho adequado da ordem m da rvore B geralmente feita em funo das caractersticas de cada computador. Por exemplo, em um computador com memria virtual paginada, o tamanho ideal da pgina da rvore corresponde ao tamanho da pgina do sistema, e a transferncia de dados da memria secundria para a memria principal e vice-versa realizada pelo sistema operacional. Estes tamanhos variam de 512 bytes at 4096 bytes, em mltiplos de 512 bytes.
Notas Bibliogrficas
O material utilizado na Seo 5.1 sobre um modelo de computao para memria secundria veio de Lister (1975). As rvores B foram introduzi-das por Bayer e McCreight (1972). Comer (1979) discute rvores B sob um ponto de vista mais prtico. Wirth (1976) apresenta uma implementao dos algoritmos de insero e de retirada; Gonnet e Baeza-Yates (1991) apresentam uma implementao do algoritmo de insero. A principal referncia utilizada no item concorrncia em rvores B veio de Bayer e Schkolnik (1977).
EXERCCIOS Exerccios
193
1) a) Construa uma rvore B de ordem m = 1 para as seguintes chaves: 15, 10, 30, 40, 5, 20, 12. b) Retire a chave 15 e depois a chave 20 da rvore obtida acima. 2) Neste trabalho voc deve apresentar uma implementao do conjunto de procedimentos para criao de um ambiente de memria virtual paginada em Pascal, conforme descrito na Secao 5.1. Ao implementar o sistema voc deve ter em mente que o conjunto de procedimentos dever permitir a o usurio incorporar facilmente um ambiente de memria virtual ao seu programa para poder organizar o fluxo de dados entre a memria primria e a memria secundria. Para tal procure colocar todos os procedimentos e declaraes de tipos em um nico arquivo chamado SMV.PAS. Este arquivo poder ser incorporado a qualquer programa escrito em Pascal, o qual dever aparecer antes das declaraes de variveis do usurio. O tamanho mximo de cada estrutura de dados utilizada pelo sistema dever ser definido atravs de constantes que podero facilmente ser ajustadas pelos usurios diretamente n o arquivo SMV.PAS, de acordo com suas convenincias. O que cada aluno deve fornecer: a) Uma listagem completa do conjunto de procedimentos precedida de documentao pertinente. A descrio de cada procedimento dever conter pelo menos a sua funo e a de seus parmetros. Dependendo da complexidade de cada procedimento pode ser interessante descrever sucintamente a lgica do mdulo obtido (evite descrever o que bvio). b) Uma listagem de um programa de demonstrao (DEMO) que mostre claramente ao usurio como utilizar o pacote SMV.PAS. O programa DEMO deve servir tambm para mostrar toda a flexibilidade e potencial do SMV.PAS. c) Teste do Sistema Para testar os vrios mdulos do sistema de paginao voc deve gerar um arquivo em disco contendo algumas pginas (para fins de teste voc pode utilizar uma pgina de tamanho pequeno, digamos 32 bytes). 0 arquivo de teste em disco dever conter as pginas de uma rvore binria de pesquisa sem balanceamento, conforme mostrado no Programa 5.1.
194
Para mostrar o pleno funcionamento do sistema importante criar procedimentos para mostrar o contedo de todas as pginas em disco, da fila de Moldura_de_Pginas e da Tabela_de_Pginas. Estes procedimentos devem ser invocados pelo programa de teste nos momentos mais interessantes para se ver o comportamento do sistema (talvez seja interessante realizar uma adaptao do programa DEMO para fins de testar o SMV conforme descrito acima). A impresso de todos estes momentos deve ser fornecida junto com a listagem do programa de teste. 3) O objetivo deste trabalho projetar e implementar um sistema de programas para recuperar, inserir e retirar registros de um arquivo que pode conter at alguns poucos milhes de registros. A aplicao que utiliza o arquivo bastante dinmica, existindo um grande nmero de consultas e atualizaes (inseres, retiradas e alteraes de registros). Alm do mais a aplicao requer periodicamente a recuperao total ou parcial dos registros na ordem lexicogrfica das chaves. Es-tas caractersticas sugerem fortemente a utilizao de rvore B como estrutura de dados. 0 que fazer: a) Para implementar os algoritmos de pesquisa, insero e retirada em uma rvore B de ordem m utilize o pacote SMV.PAS proposto em exerccio acima, para criar um ambiente de memria virtual e resolver o problema de fluxo de dados entre as memrias primria e secundria. b) Para testar o seu sistema de programas para uma rvore B de ordem m = 2, utilize a seguinte seqncia de chaves: Insero: 20; 10 40 50 30; 55 3 11 4 28; 36; 33 52 17 25 13; 45 9 43 8 48; A cada ponto-e-vrgula voc dever imprimir a rvore. Retirada: 45 30 28; 50 8; 10 4 20 40 55; 17 33 11 36; 3 11 52; A cada ponto-e-vrgula voc dever imprimir a rvore. c) Para termos uma idia da eficincia do mtodo de acesso construdo faa a medida do tempo de execuo para: a) Construir rvores B de tamanhos 1.000, 10.000 e 50.000 chaves geradas randomicamente atravs de um gerador de nmeros aleatrios. A medida de tempo deve ser tomada de forma independente para cada uma das trs rvores. A ordem m das rvores deve ser tal que o tamanho da pgina seja igual ou menor do que 512 bytes.
EXERCCIOS
19 5
b) Para a maior das trs rvores que voc conseguiu construir gere aleatoriamente um conjunto de 200 chaves e realize uma pesquisa na rvore para cada chave. Caso haja chaves que no estejam presentes no arquivo informe quantas pesquisas foram com sucesso e quantas foram sem sucesso. Com esta medida podemos ter uma idia do tempo aproximado para pesquisar um registro no arquivo. Ateno: procure interpretar os resultados obtidos. Por exemplo, voc deve informar qual foi o nmero de Molduras_de_Pginas utilizadas para os experimentos acima (com 256 Kbytes de memria real disponvel possvel manter cerca de 120 molduras na memria principal). Quaisquer outras observaes relevantes devem ser relatadas. Observaes: a) A pesquisa da chave de um registro dentro de uma pgina da rvore B pode ser feita atravs de uma pesquisa seqencial. b) A deciso sobre a documentao a ser apresentada fica por conta do aluno. 4) Modifique a implementao do procedimento original apresentado no Programa 5.5 para que a pesquisa da chave dentro de uma pgina da rvore B seja realizada atravs de um pesquisa binria.
Apndice A
Programas C do Captulo 1
197
198
PROGRAMAS EM C DO CAPTULO 1
199
200
201
Apndice B
203
204
205
206
207
208
209
210
211
212
213
214
215
Apndice C
Programas C
do Captulo 3
217
218
219
220
221
Apndice D
223
224
225
226
227
228
229
230
231
232
233
234
235
236
PROGRAMAS EM C DO CAPTULO 4.
237
238
239
240
241
Apndice E
Programas C
do Captulo 5
243
244
245
246
247
248
249
250
251
Apndice F
Caracteres ASCII
253
Apndice G
Referncias Bibliogrficas
Adel'son-Vel'skii, G.M. e Landis, E.M. (1962) "An Algorithm for the Organization of Information", Doklady Akademia Nauk USSR 146 (2), 263-266, Traduo para o Ingls em Soviet Math. Doklay 3, 1962, 1259-1263. Aho, A.V., Hoperoft J.E. e Ullman J.D. (1974) The Design and Analysis of Computer Algorithms. Addison-Wesley, Reading, Mass. Aho, A.V., Hoperoft, J.E. e Ullman, J.D. (1983) Data Structures and Algorithms. Addison-Wesley, Reading, Mass. Albuquerque, L.C.A. e Ziviani, N. (1985) "Estudo Emprico de uma Nova Implementao para o Algoritmo de Construo da Arvore Patricia". V Congresso da Sociedade Brasileira de Computao, Porto Alegre, RGS, 254-267. rabe, J.N.C. (1992) Comunicao Pessoal, Belo Horizonte, MG. Barbosa, E.F. e Ziviani, N. (1992) `"Data Structures and Access Methods for Read-Only Optical Disks". Baeza-Yates, R. e Manber, U. (Eds.) in Computer Science: Research and Applications, Plenum Publishing Corp. , New York, NY, 189-207. Bayer, R. (1971) "Binary B Trees for Virtual Memory", ACM SIGFIDET Workshop, San Diego, 219-235. Bayer, R. (1972) "Symmetric Binary B-Trees: Data Structure and Maintenance Algoritms", Acta Informatica 1 (4), 290-306. Bayer, R. e McCreight, E.M. (1972) "Organization and Maintenance of Large Ordered Indices". Acta Informatica 1(3), 173-189. 255
256
REFERNCIAS BIBLIOGRFICAS
Bayer, R. e Schkolnick, M. (1977) "Concurrency of Operations on B-trees: Acta Informatica 9(1), 1-21. Carvalho, M.L.B. (1992) Comunicao Pessoal, Belo Horizonte, MG. Clancy, M. e Cooper, D. (1982) Oh! Pascal. W . W. Norton, New York, NY. Comer, D. (1979) "The Ubiquitous B-tree," ACM Computing Surveys 11(2), 121-137. Cooper, D. (1983) Standard Pascal User Reference Manual. W . W . Norton, New York, NY. Cormem, T.H., Leiserson, C.E. e Rivest, R.L. (1990) Introduction to Algorithms. McGraw-Hill e The Mit Press, Cambridge, Mass. Dahl, O.J., Dijkstra, E.W. e Hoare, C.A.R. (1972) Structured Programming. Academic Press, New York, NY. Dijkstra, E.W. (1965) "Co-operating Sequential Processes". In Programming Languages F. Genuys (ed.), Academic Press, New York, NY. Dijkstra, E.W. (1971) A Short Introduction to the Art of Programming. Technological University Endhoven. Dijkstra, E.W. (1976) A Discipline of Programming. Prentice-Hall, Englewood Cliffs, NJ. Eisenbarth, B., Ziviani, N., Gonnet, G.H., Mehlhorn, K. e Wood, D. (1982) " The Theory of Fringe Analysis and Its Application to 2-3 Trees and BTrees", Information and Control 55 (1-3), 125-174. Feller, W. (1968) An Introduction to Probability Theory and Its Applications. Vol. 1, Wiley, New York, NY. Flajolet, P. e Vitter, J.S. (1987) "Average-case Analysis of Algorithms and Data Structures". Technical Report 718, INRIA, Frana. Floyd, R.W. (1964) "Treesort". Algorithm 243, Communications ACM 7(12), 701. Furtado, A.L. (1984) Comunicao Pessoal, Rio de Janeiro, RJ. Garey, M.R. e Johnson, D.S. (1979) Computers and Intractability A Guide to the Theory of NP-Completeness. Freeman, San Francisco, CA.
257
Gonnet, G.H. e Baeza-Yates, R. (1991) Handbook of Algorithms and Data Structures. Addison-Wesley, Reading, Mass., segunda edio. Graham, R.L., Knuth, D.E. e Patashnik, O. (1989) Concrete Mathematics. Addison-Wesley, Reading, Mass. Greene, D.H. e Knuth, D.E. (1982) Mathematics for the Analysis of Algorithms. Birkhanser, Boston, Mass. Guibas, L. e Sedgewick, R. (1978) "A Dichromatic Framework for Balanced Trees", 19th Annual Symposium on Foundations of Computer Science, IEEE. Hibbard, T.N. "Some Combinatorial Properties of Certain Trees with Applications to Searching and Sorting". Journal of the ACM 9, 13-28. Hoare, C.A.R. (1962) "Quicksort". The Computer Journal 5(1), 10-15. Hoare, C.A.R (1969) "Axiomatic Bases of Computer Programming". Communications ACM 12 (10), 576-583. Horowitz, E. e Sahni, S. (1978) Fundamentals of Computer Algorithms. Computer Science Press, Potomac, Maryland. Jensen, K. e Wirth, N. (1974) Pascal User Manual and Report. SpringerVerlag, Berlin, segunda edio. Keehn, D. e Lacy, J. (1974) "VSAM Data Set Design Parameters". IBM Systems Journal 3, 186-212. Knott, G. (1975) "Hashing Functions". The Computer Journal 18 (3), 265-378. Knuth, D.E. (1968) The Art of Computer Programming, Vol.1: Fundamental Algorithms. Addison-Wesley, Reading, Mass. Knuth, D.E. (1971) "Mathematical Analysis of Algorithms". Procedings IFIP Congress 71, vol. 1, North Holland, Amsterdam, Holanda, 135143. Knuth, D.E. (1973) The Art of Computer Programming; Volume 3: Sorting and Searching. Addison-Wesley, Reading, Mass. Knuth, D.E. (1976) "Big Omicron and Big Omega and Big Theta". ACM SIGACT News 8 (2), 18-24. Knuth, D.E. (1981) The Art of Computer Programming, Vol. 2: Seminumerical Algoritms. Segunda edio, Addison-Wesley, Reading, Mass.
258
Lister, A.M. (1975) Fundamentals of Operating Systems. Macmillan, London. Lueker, G.S. (1980) "Some Techniques for Solving Recurrences". ACM Computing Surveys 12(4), 419-436. Manber, U. (1988) "Using Induction to Design Algorithms". Communications ACM 31 (11), 1300-1313. Manber, U. (1989) Introduction to Algorithms A Creative Approach. Addison-Wesley, Reading, Mass. Manber, U. e Myers, G. (1990) "Suffix Arrays: A New Method for On-Line String Searches". 1st ACM-SIAM Symposium on Discrete Algorithms, San Francisco, CA, 319-327. Morrison, D.R. (1968) "PATRICIA - Practical Algorithm To Retrieve Information Coded In Alphanumeric". Journal of the ACM15(4), 514-534. Murta, C.D. (1992) Comunicao Pessoal. Belo Horizonte, MG. Mehlhorm, K. (1984) Data Structures and Algorithms, Vol.1: Sorting and Searching. Springer-Verlaq, Berlin. Olivi, H. (1980) "Symmetric Binary B-Trees Revisited" , Technical Report 80-01, Interstedelijke Industrile Hogerschool Antwerpen-Mechelen, Blgica. Peterson, J. e Silberschatz, A. (1983) Operating System Concepts. AddisonWesley, Reading, Mass. Sedgewick, R. (1975) "The Analysis of Quicksort Programs". Acta Informatica 7, 327-355. Sedgewick, R. (1978) Quicksort. Garland. (tambm publicado como tese de doutorado do autor, Stanford University, C.S. Department Techical Report 75-492, 1975). Sedgewick, R. (1978a) "Implementing Quicksort Programs". Communications ACM 21 (10), 847-857. Sedgewick, I t (1988) Algorithms. Addison-Wesley, Reading, Mass., segunda edio. Shell, D.L. (1959) "A Highspeed Sorting Procedure". Communications ACM 2(7), 30-32.
259
Sleator, D.D. e Tarjan, R.E. (1985) "Self-Adjusting Binary Search Trees". Journal of the ACM 32, 652-686. Stanat, D.F. e McAllister, D.F. (1977) Discrete Matematics in Computer Science. Prentice-Hall, Englewood Cliffs, NJ, Capitulo 5, 218-274. Standish, T.A. (1980) Data Structures Techniques. Addison-Wesley, Reading, Mass. Tanenbaum, A.S. (1987) Operating Systems: Design and Implementation. Prentice-Hall, Englewood Cliffs, NJ. Tarjan, R.E. (1983) Data Structures and Network Algorithms. SIAM, Philadelphia, Pennsylvania. Tarjan, R.E. (1985) "Amortized Computational Complexity". SIAM Journal on Applied and Discrete Mathematics 6, 306-318. Terada, R. (1991) Desenvolvimento de Algoritmos e Estruturas de Dados. McGraw-Hill e Makron Books do Brasil, So Paulo, SP. Vuillemin, J. (1978) "A Data Structure for Manipulating Priority Queues". Communications ACM 21 (4), 309-314. Wagner, R. (1973) "Indexing Design Considerations," IBM Systems Journal4, 351-367. Weide, B. (1977) "A Survey of Analysis Techniques for Discrete Algorithms". ACM Computing Surveys 9 (4), 291-313. Williams, J.W.J. (1964) "Algorithm 232". Communications ACM 7(6), 347348. Wirth, N. (1971) "Program Development by Stepwise Refinement ". Communications ACM 14 (4), 221-227. Wirth, N. (1974) "On The Composition of well-Structured Programs".ACM Emputing Serveys 6 (4), 247-259. Wirth, N. (1976) Algorithms + Data Structures = Programs. Prentice-Hall, Englewood Cliffs, NJ. Wirth, N. (1986) Algorithms and Data Structures. Prentice-Hall, Englewood Cliffs, NJ. Ziviani, N., Olivi, H. e Gonnet, G.H. (1985) "The Analysis of the Improved Symmetric Binary B-Tree Algorithm". The Computer Journal 28 (4), 417-425.
260
Ziviani, N. e Tompa, F.W. (1982) "A Look at Symmetric Binary B-Trees" INFOR Canadian Journal of Operational Research and Information Processing 20 (2), 65-81.
ndice
O notao, 13 O operaes, 12, 13 [ ] conjunto em Pascal, 27 notao, 14 [ ] teto, 8 [] - Piso, 8 somatrio, 21 2-3, rvores, 118, 190 2-34, rvores, 119, 144 Adel'son-Vel'skii G.M., 143 Agrupamento em tabelas hashing, 141 Aho A.V., 2, 13, 19, 30, 36, 56, 58, 99, 143 Albuquerque L.C.A., 131 Algoritmos anlise de, 324 classes de, 15 comparao, 1424 complexidade, 324 conceito, 1 escolha de, 1, 12, 71, 107 exponenciais, 16, 17 timos, 4, 5, 11, 24 polinomiais, 17 recursivos, 1924, 47, 79, 112 135, 170192 Alocao dinmica, 29, 189 encadeada, 29, 38, 49, 65 Altura de rvore, 112, 126 Amortizado, custo, 30, 144 Anlise de algoritmos, 324 caso mdio, 6 de um algoritmo particular, 3 de uma classe de algoritmos, 4 melhor caso, 6 pior caso, 6 tcnicas de, 1824 Arabe J.N.C., 59, 100, 103, 148 rea de armazenamento, 97, 155, 165 Arquivo conceito, 107 definio, 28 Arranjos, definio, 26 Arvores, 83, 84, 112135, 169192, 194 2-3, 118, 190 2-3-4, 119, 144 altura de, 112, 126 auto-ajustvel, 144 AVL, 143 B, 118, 170181, 194 binrias, 118 definio, 170 tcnica de overflow, 192 B*, 182188 acesso concorrente, 184188 deadlock, 188 definio, 182 pgina segura, 185 processo leitor, 186 processo modificador, 186 protocolos, 184 semforos, 187
261
262 balanceadas, 117127, 169192 binrias, 83, 112 binrias de pesquisa, 112 binrias de pesquisa com balanceamento, 117127 binrias de pesquisa sem balanceamento, 112117 binrias completas, 83 caminhamento central, 115 caminho interno, 118, 143 completamente balanceadas, 117 definio, 112 digitais de pesquisa, 127135 nrea, 170 nvel de um nodo, 112 Patricia, 129135 randmicas, 117, 190 red-black, 144 representao de, 84, 112, 171 SBB, 118145 definio, 119 Trie, 128129 ASCII, tabela de caracteres, 253 Assinttica complexidade, 14 dominao, 12 Assinttico classes de comportamento, 14 18 funes que expressam, 14 Auto-ajustvel, rvores, 144 AVL, rvores, 143 Baeza-Yates R., 4, 99, 118, 129, 143, 153, 192 Balanceada, intercalao, 9297 Balanceadas, rvores, 117127, 169 192 Barbosa E.F., 167, 168 Bayer R., 118-120, 127, 144, 147, 170, 185, 186, 188191 Binria rvore, 83, 111127
NDICE
pesquisa, 110111 Blocos em fitas, 93 ordenados, 92, 96 Bolha, mtodo de ordenao, 89 Bruta, fora, 16 Bubblesort, 89 Bucketsort, 71' Cabea de lista, 38 Caminhamento em rvores, 115 Caminho interno em rvores de pesquisa, 118, 143 Cartes, classificadora de, 71 Cartas, jogo de, 70, 73 Carvalho M.L.B., 33, 34 Casamento de cadeias, 129 de padres, 129 Caso mdio, anlise de algoritmos, 6 CD-ROM (Compact Disk Read Only Memory), 166 Central, caminhamento em rvores, 115 Chave de ordenao, 69 de pesquisa, 6, 107 de tamanho varivel, 127 semi-infinita, 128, 152, 153 transformao de, 135143 Christodoulakis S., 167 Cilindro em discos ticos, 167 em discos magnticos, 164, 167 Circulares, listas, 56 Clancy M., 25 Classes de comportamento assinttico, 1418 Classificao, vide Ordenao Classificadoras de cartes, 71 Clustering, 141
NDICE Colises, resoluo de, 135137, 140,

147149, 151 Comer D., 170, 192 Comparao de algoritmos, 14 ordenao por, 70 Completa, rvore binria, 83 Complexidade amortizada, 30, 144 anlise de, 324 assinttica, 14 constante, 15 cbica, 15 de algoritmos, 324 de espao, 5 de tempo, 5 exponencial, 16, 17 funo de, 5 linear, 15 logartmica, 15 nlogn, 15 quadrtica, 15 Concorrente, acesso em rvores B*, 184188 Conjuntos em Pascal, 27 Constante, algoritmos de complexidade, 15 Cooper D., 25, 30 Cormen T.H., 30, 58, 99 Cbicos, algoritmos, 15 Custo amortizado, 30, 144 funo de, 12 Dados estruturas de conceito, 1, 2530 escolha de, 1, 44 tipos. abstratos de, 23, 35, 42, 44, 47, 48, 53, 55, 82, 107, 108 tipos de, 2-3, 2530, 35, 42, 44, 47, 48, 53, 55, 82, 107,
263 108 Dahl O.J., 30 Deadlock, 188 Dicionrio, 108 Digital rvores de pesquisa, 127135 ordenao, 71 Dijkstra E.W., 1, 2, 30, 187 Dinmica, alocao, 29, 189 Disco tico, 166168 cilindro tico, 167 feixe de laser, 166 ponto de ncora, 167 tempo de busca, 166 trilha, 166 varredura esttica, 166 Disco magntico, 70, 91, 98, 164 cilindro, 164, 167 latncia rotacional, 164 tempo de busca, 164 trilha, 164 Distribuio, ordenao por, 70 Dominao assinttica, 12 Double hashing, vide Hashing duplo Eisenbarth B., 190, 191 Encadeada, alocao, 29, 38, 49, 65 Equao de recorrncia, vide Relao de recorrncia Espao, complexidade, 5 Estvel, mtodo de ordenao, 69, 73, 75, 77, 81, 86 Estruturas de dados conceito, 2530 escolha de, 1, 44 Execuo, tempo de, 324 Exponenciais, algoritmos, 16, 17 Externa ordenao, 70, 9199, 104 pesquisa em memria, 155192 Feixe de laser, 166
264 Feller W., 136

Fifo, (first-in-first-out), 55, 160 Filas, 55-58 Filas de prioridades, 81-83, 91, 94-96 Fitas magnticas, 70, 9194, 98 Flajolet P., 30 Floyd R.W., 84, 99 Fora bruta, 16 Ford D.A., 167 Funes comportamento assinttico, 11 de complexidade, 5, 1416 de transformao, 135137 hashing, 135 piso (LJ), 8 teto ((I), 8 Furtado A.L., 42 Garey M.R., 16, 17 Gonnet G.H., 4, 99, 118, 129, 143-145, 153, 190, 192 Graham R.L., 30 Greene D.H., 30 Guibas L., 119, 144 Hashing, 135143 duplo, 148 funes de transformao, 136 137 linear, 140 listas encadeadas, 137138 open addressing, 140143 Heaps, 83-86, 91 Heapsort, 81-86, 90 Hibbard T.N., 143 Hoare C.A.R., 78 Hoare, C.A. R., 30, 99 Hoperoft J.E., 2, 13, 19, 30, 36, 47, 56, 58, 99, 143 Horowitz E., 10, 30
NDICE
em rvores de pesquisa com balanceamento, 122 sem balanceamento, 113 em rvores B, 172 em rvores B*, 184 em filas, 55, 57, 60 em listas lineares, 36 em pilhas, 48, 50, 52 em tabelas hashing, 138, 140 ordenao por, 73-75, 89, 91 Intercalao balanceada, 92-97 de dois arquivos, 103 ordenao por, 91-99 ISAM, 189 Jensen K., 25, 30 Johnson D.S., 16, 17 Keehn D., 189 Knott G., 136 Knuth D.E., 3, 4, 13, 30, 36, 58, 73, 76, 96, 97, 99, 112, 129, 136, 137, 140, 141, 143, 170, 192 Lacy J., 189 Landis E.M., 143 Laser, feixe de, 166 Latncia, em disco magntico, 164 Leiserson C.E., 30, 58, 99 Lfu (least-frequently-used), 159 Lifo (last-in-first-out), 47 Limite inferior conceito, 4, 10 orculo, 10 para obter o mximo de um conjunto, 5 para obter o mximo e o mnimo de um conjunto, 10 Lineares, algoritmos, 15 Listas cabea de, 38, 61 circulares, 56
Indireta, ordenao, 90 Insero
NDICE
duplamente encadeadas, 59 encadeadas (em hashing), 137-138 lineares, 3558 Lister A.M., 157, 188, 192 Localidade de referncia, 160 Lock protocols, vide Protocolos para travamento Logartmicos, algoritmos., 15 Lru (least-recently-used), 159, 192 Lueker G.S., 30 Mximo de um conjunto, 5 Mximo e mnimo de um conjunto, 7 11, 2324 Manber U., 30, 154 Matrizes esparsas, 59 McAllister D.F., 5, 30 McCreight E.M., 118, 170, 189, 190, 192 Mehlhorn K., 143, 190 Melhor caso, anlise de algoritmos, 6 Memria virtual, 157163 Merge, vide intercalao Mergesort, 103 Morrison D.R., 129 Muntz R., 170 Murta C.D., 152 Myers G., 154 Notao , definio, 14 Notao O, definio, 13 Notao O, operaes, 12, 13 Olivi H., 144, 145, 147 Open addressing, 140143 Orculo, 10 Ordenao, 69106 externa, 70, 9199, 104 por intercalao, 9199 interna, 7091 bolha, 89 bubblesort, 89
265
bucketsort, 71 comparao entre os mtodos, 87 91 digital, 71 estvel, 69, 73, 75, 77, 81, 86 heapsort, 8186, 90 indireta, 90 mergesort, 103 por insero, 7375, 89, 91 por seleo, 7273, 89 quicksort, 7881, 90 radixsort, 71 shellsort, 7677, 89 por comparao, 70 por distribuio, 70 Ordenadas, listas, 75, 83 timo, algoritmo, 4, 5, 11, 24Overflow, tcnica de insero em rvores B, 192 Pgina de uma rvore B, 170 em sistemas de paginao, 157 segura, 191 tamanho em uma rvore B, 192 Paginao, 157163, 192 Pai, em estrutura de rvore, 83 Paradoxo do aniversrio, 136 Partio, Quicksort, 79 Pascal, linguagem de programao, 2530 Pat array, 153 Patashnik O., 30 Patricia, 129135 Pesquisa com sucesso, 107 em listas lineares, 36 em memria externa, 155192 em rvores B*, 182 em memria interna, 6, 107143 binria, 110111
266
digital, 127135 em rvores binrias, 111 em rvores binrias com balanceamento, 117127 em rvores binrias sem balanceamento, 112117 em rvores Patricia, 129135 em rvores Trie, 128129 por comparao de chave, 108 127 por transformao de chave, 135143 seqencial, 6, 108110 seqencial rpida, 110 sem sucesso, 107 Peterson J., 157 Pilhas, 4753 Pior caso, anlise de algoritmos, 6 Piso, funo ([ J), 8 Polinomiais, algoritmos, 17 Ponto de ncora, em discos ticos, 167 Previso, tcnica de, 98 Prioridades, filas de, 8183, 9496 Processo leitor, 186 modificador, 186 Programas, 2 Protocolos, 184 para processos leitores, 186 para processos modificadores, 186 para travamento, 185 Quadrticos, algoritmos, 15 Quicksort, 7881, 90 mediana de trs, 81, 90 partio, 79 pequenos subarquivos, 90 piv, 7880, 90 Radixsort, 71 Randmica, rvore de pesquisa, 117, 190
NDICE
Recorrncia, relao de, 18, 21, 31, 33 Recursivos, algoritmos, 1924, 47, 79, 112135 Red-black, rvores, 144 Registros, 6, 27, 107 Relao de recorrncia, 18, 21, 31, 33 Retirada de itens em rvores B, 177 em rvores B*, 184 em rvores de pesquisa com balanceamento, 124 sem balanceamento, 113 em filas, 55, 57, 60 em listas lineares, 36, 39, 41 em pilhas, 48, 50, 52 em tabelas hashing, 138, 140 Rivest R.L., 30, 58, 99
Sahni S., 10, 30 S B B , rvores, 118145 Schkolnick M., 185, 186, 188, 191 Schkolnik M., 192 Sedgewick R., 58, 70, 90, 91, 96, 98, 99, 119, 129, 144, 148 Seek time, vide Tempo de busca Segura, pgina de uma rvore B*, 185, 191 Seleo ordenao por, 7273, 89 por substituio, 9497 Selfadjusting, vide Auto-ajustve l Semforo, 187 Semi-infinita, chave, 128, 152, 153 Sentinelas, 72, 7476, 110 Seqencial indexado, 163168 Seqencial, pesquisa, 6, 108110 Shell D.L., 76, 99 Shellsort, 7677, 89 Silberschatz A., 157 Sleator D.D., 144 Stanat D.F., 5, 30
NDICE Standish T.A., 143 Suffix array, 154 Tanenbaum A.S., 157 Tarjan R.E., 30, 143, 144 Tempo complexidade de, 5 de busca em discos ticos, 166 em discos magnticos, 164 de execuo, .3-24 Terada R., 143 Teto, funo (1'1), 8 Tipos abstratos de dados, 2-3, 35, 42, 44, 47, 48, 53, 55, 82, 107, 108 Tompa F.W., 127, 144, 145 Transbordamento, vide overflow Transformao de chave, 135-143 duplo, 148 funes de, 136-137 listas encadeadas, 137-138 open addressing, 140-143 Trie, 128-129 Trilha em disco tico, 166 em disco magntico, 164 Ullman J.D., 2, 13, 19, 30, 36, 47, 56, 58, 99, 143 Uzgalis R., 170 Valor mdio de uma distribuio de probabilidades, 6 Varredura esttica, em discos ticos, . 166 Virtual, memria, 157-163 Vitter J.S., 30 VSAM, 189 Vuillemin J., 83 Wagner R., 189 Weide B., 30 Williams 3.W.3., 83, 99
267 Wirth N., 2, 25, 30, 99, 115, 143, 144, 147, 170, 192 Wood D., 190 Ziviani N., vii, 127, 131, 144, 145, 167, 168, 190

Projetos de Algoritmos Com Implementação em Pascal e C (Nivio Ziviani, 4ed)

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Projetos de Algoritmos Com Implementação em Pascal e C (Nivio Ziviani, 4ed)

Enviado por

Direitos autorais:

Formatos disponíveis

Maria, esposa e companheira, Patricia e Paula, nossas filhas.

Dados Internacionais de Catalogao na Publicao (CIP) ( C i m a r a B r a s i l e i r a do L i v r o , S P, B r a s i l ) Ziviani, Nivio Projeto de algoritmos c o m

Pascal C / Nivio Ziviani. -- 4. ad. -- So Paulo : Pioneira, 1999. -- (Pioneira Informtica)

Nivio Ziviani, Ph.D.

Capa do Riccardo Fanucchi

Nivio Ziviani Belo Horizonte Dezembro de 1992 Endereo Internet: nivio@dcc.ufmg.br

1.2 Tipos de Dados e Tipos Abstratos de Dados

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA

1.3 Medida do Tempo de Execuo de um Programa

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 5

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 7

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 9

Comparao dos algoritmos para obter o mximo e o mnimo

1.3.1 Comportamento Assinttico de Funes

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 13

1.3.2 Classes de Comportamento Assinttico

T a b e l a 1.2: Comparao de virias funes de complexidade

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 17

Tabela 1.3: Influncia do aumento de velocidade dos computadores no tamanho t do problema

CAPT ULO 1. INTRODUO

Figura 1.4: Problema do caixeiro viajante

1.4 Tcnicas de Anlise de Algoritmos

1.4. TCNICAS DE ANLISE DE ALGORITMOS

1.4. TCNICAS DE ANLISE DE ALGORITMOS

program label const type var procedure ou function begin . . . end

F i g u r a 1.5: Estrutura de um programa Pascal

Se as variveis c, s, e d so declaradas var c cor; var s sexo; var b boolean; : : :

'Patricia'; 21; 10; fern;

Programa 1.8: Programa para copiar arquivo

Pascal marca registrada da Borland International

30 var Lista: Apontador;

possvel criar uma lista como ilustrada na Figura 1.7.

Figura 1.7: Lista encadeada

Estruturas de Dados Bsicas

CAPTULO 36. ESTRUTURAS DE DADOS BSICAS

2.37. LISTAS LINEARES

2.1.1 Implementao de Listas A t r a v s de Arranjos

Figura 2.1: Implementao de uma lista atravs de arranjo

CAPTULO 2. ESTRUTURAS DE DADOS BSICAS

Programa 2.1: Estrutura da lista usando arranjo

2.1.2 Implementao de Listas Atravs de Apontadores

2.1. LISTAS LINEARES

Programa 2.2: Operaes sobre listas usando posies contguas de memria

CAPTULO 2. ESTRUTURAS DE DADOS BSICAS

Programa 2.3: Estrutura da lista usando apontadores

41.1. LISTAS LINEARES

Programa 2.4: Operaes sobre listas usando apontadores

CAPTULO 2. ESTRUTURAS DE DADOS BSICAS

: 1..999; NotaFinal : 0..10; Opo : array [1..3] of 1..7;

2.43. LISTAS LINEARES

Programa 2.6: Primeiro refinamento do programa Vestibular

CAPTULO 44. ESTRUTURAS DE DADOS BSICAS

Programa 2.7: Segundo refinamento do programa Vestibular

2.1. LISTAS LINEARES

Programa 2.8: Estrutura da lista

CAPITULO 2. ESTRUTURAS DE DADOS BSICAS

CAPTULO 2. ESTRUTURAS DE DADOS BSICAS

Programa 2.10: Estrutura da pilha usando arranjo

CAPTULO 2. ESTRUTURAS DE DADOS BSICAS

CAPTULO 2. ESTRUTURAS DE DADOS BSICAS

Programa 2.13: Operaes sobre pilhas usando apontadores

CAPITULO 4. ESTRUTURAS DE DADOS BSICAS

Programa 2.14: Implementao do ET

Programa 2.15: Procedimento Imprime utilizado no programa ET