(Ebook) Projetos de Algoritmos Com Implementações em Pascal e C (Nivio Ziviani, 4ed) PDF

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
xiii
Lista de Tabelas
xv
Lista de Programas
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
197
B Programas C do Captulo 2
203
SUMRIO
C
Programas C do Captulo 3
217
223
243
Caracteres ASCII
253
Referncias Bibliogrficas
255
ndice
261
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
Tabela 1.1:
f (n)
MaxMin1
MaxMin2
Melhor caso
2(n-1)
n1
Pior caso
2(n-1)
2(n-1)
Caso mdio
2(n-1)
3n/2-3/2
MaxMin3
3n/2-2
3n/2-2
3n/2-2
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.

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).

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
Computador
atual
Computador
100 vezes
mais rpido
Computador
1000 vezes
mais rpido
n
n2
n3
2n
tl
t2
t3
t4
100t 1
10t 2
4,6t 3
t 4+ 6 , 6
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
CAPTULO 1. INTRODUO
26
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
27
onde a constante n deve ser previamente declarada

const n = 20;
Dada a varivel
var x : coluna;
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
:
:
:
:
(mas, ferm);
var p: pessoa;
valores particulares podem ser atribuidos como se segue
p.sobrenome
p.primeironome
p.aniversrio.dia
p.aniversrio.ms
p.sexo
:=
:=
:=
:=
:=
'Ziviani';
'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
CAPTULO 1. INTRODUO
var Lista: Apontador;
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.
Programa 2.2: Operaes sobre listas usando posies contguas de memria
39
40
Programa 2.3: Estrutura da lista usando apontadores
Programa 2.4: Operaes sobre listas usando apontadores
41
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
63
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
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

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.
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
C A P T U L O 2 2 . ORDENAO
72
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
CAPTULO 32. ORDENAO
82
(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
CAPTULO 38. ORDENAO
Insero
Seleo
Shellsort
Quicksort
Heapsort
500
5000
10000
30000
11.3
16.2
1.2
1
1.5
87
124
1.6
1
1.6
161
228
1.7
1
1.6
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
Insero
Seleo
Shellsort
Quicksort
Heapsort
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
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
Quicksort
30000
1
1.5
3.7
5000
1
1.1
1.9
10000
1
1.1
2.0
Heapsort
30000
1
1.1
2.0
5000
1.1
1
1.1
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.
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
Programa
4.8:
115
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 .
Programa 4.24: Operaes do Dicionrio usando listas encadeadas
139
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

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

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
153
20) rvore Patricia

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

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
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 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 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
193
Exerccios
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
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
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
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
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
263
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,
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
NDICE
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
Indireta, ordenao, 90
Insero
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
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

(Ebook) Projetos de Algoritmos Com Implementações em Pascal e C (Nivio Ziviani, 4ed) PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

(Ebook) Projetos de Algoritmos Com Implementações em Pascal e C (Nivio Ziviani, 4ed) PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Maria, esposa e companheira,

Patricia e Paula, nossas filhas.

Dados Internacionais de Catalogao na Publicao (CIP)

Pascal C / Nivio Ziviani. -- 4. ad. -- So Paulo :

1. Algoritmos 2. C (Linguagem de programao

ndices para catlogo sistemtico:

Nivio Ziviani, Ph.D.

Este livro foi composto, revisado.

Nenhuma parte deste livro poder ser reproduzida sejam

autocontida e exige muito pouco conhecimento matemtico prvio para ser

Funo para obter o mximo de um conjunto .......................................5

2.1 Estrutura da lista usando arranjo ......................................................... 38

5.10 Estrutura do dicionrio para rvore B* ..........................................183

Funo para obter o maior elemento de um vetor ..........................197

B.1 Estrutura da lista usando arranjo ......................................................203

D.2 Implementao das operaes usando arranjo ................................ 224

Programar basicamente estruturar dados e construir algoritmos. De

1.2 Tipos de Dados e Tipos Abstratos de Dados

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA

mesma forma que um procedimento usado para encapsular partes de um

1.3 Medida do Tempo de Execuo de um Programa

importantes do algoritmo em questo devem ser investigadas, geralmente

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 5

A medida do custo de execuo de um algoritmo depende principalmente

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

Considerando novamente o nmero de comparaes realizadas, existe

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 11

1.3.1 Comportamento Assinttico de Funes

o problema, no sentido de que o tempo necessrio para resolver o problema

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 13

1.3.2 Classes de Comportamento Assinttico

1.3. MEDIDA DO TEMPO DE EXECUO DE UM PROGRAMA 15

7. (n) = 0(2n). Um algoritmo de complexidade 0(2n) dito ter complexidade

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

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

Um algoritmo cuja funo de complexidade O(c n), c > 1, chamado de

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

Infelizmente no existe um conjunto completo de regras para analisar

1.4. TCNICAS DE ANLISE DE ALGORITMOS

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

valores, ou atravs da indicao de subintervalos que restringem tipos a uma

= (vermelho, azul, rosa);

ento so possveis as seguintes atribuies

onde a constante n deve ser previamente declarada

A Figura 1.6 ilustra este exemplo.

Programa 1.8: Programa para copiar arquivo

Pascal marca registrada da Borland International

possvel criar uma lista como ilustrada na Figura 1.7.

Figura 1.7: Lista encadeada

12) Apresente um algoritmo para obter o maior e o segundo maior elemento

Estruturas de Dados Bsicas

CAPTULO 36. ESTRUTURAS DE DADOS BSICAS

de operaes necessrio a uma maioria de aplicaes apresentado a seguir.

2.37. LISTAS LINEARES

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