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 refina-
mentos sucessivos at o nvel de uma implementao na linguagem Pascal, o
que permite que qualquer pessoa com um mnimo de experincia em pro-
gramao 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 desempe-
nho 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 se-
cundria: intercalao balanceada; (iv) mtodos de pesquisa em memria
primria: pesquisa seqencial, pesquisa binria, rvores de pesquisa e has-
hing; (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 so-
bre as caractersticas de desempenho de cada algoritmo apresentado. Entre-
tanto, 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 im-
plementados na linguagem Pascal so tambm implementados na linguagem
C. Todo programa Pascal de um captulo tem um programa C correspon-
dente 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 ra-
dixsort; 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 se-
cundria 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 ma-
terial 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 imple-
mentaes de algoritmos de utilidade geral. Os algoritmos propostos so
completamente implementados nas linguagens Pascal e C e as operaes en-
volvidas 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 Pe-
reira de Lucena e Routo Terada por lembrarem do meu nome para participar
da I Escola Brasileiro-Argentina de Informtica, o que motivou o desenvol-
vimento da semente deste texto. Gostaria de agradecer a Cilio Rosa Ziviani,
Cleber Hostalcio de Melo, Jos Monteiro da Mata, Lilia Tavares Mascare-
nhas, 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. Agra-
deo a todos pela ajuda e pelas crticas construtivas. O Departamento de
Cincia da Computao da Universidade Federal de Minas Gerais tem pro-
porcionado um excelente ambiente de trabalho. Os meus alunos de extenso,
graduao, especializao e ps-graduao, especialmente os alunos das disci-
plinas 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 Car-
valho, 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, desen-
volvido 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 v
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
D Programas C do Captulo 4 223
E Programas C do Captulo 5 243
F Caracteres ASCII 253
G 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 vari-

ados de pginas e arquivos usando rvore B .................................. 190
Lista de Programas
1.1 Funo para obter o mximo de um conjunto .......................................5

1.2 Implementao direta para obter o mximo e o mnimo . 7
1.3 Implementao melhorada para obter o mximo e o mnimo 8
1.4 Outra implementao para obter o mximo e o mnimo ..................... 9
1.5 Programa para ordenar .......................................................................... 20
1.6 Algoritmo recursivo .............................................................................. 21
1.7 Verso recursiva para obter o mximo e o mnimo ........................... 23
1.8 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 Funo para obter o maior elemento de um vetor ..........................197
A.2 Implementao direta para obter o mximo e o mnimo ............... 197
A.3 Implementao melhorada para obter o mximo e o mnimo ....... 198
A.4 Outra implementao para obter o mximo e o mnimo ................199
A.5 Programa para ordenar ...................................................................... 199
A.6 Algoritmo recursivo ...........................................................................199
A.7 Verso recursiva para obter o mximo e o mnimo ....................... 200
A.8 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 repre-
sentao 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 com-
plicadas, as quais devem ser memorizadas. Entretanto, a situao se inverte
quando consideramos a adio de grandes nmeros, sendo mais fcil a repre-
sentao por dgitos decimais por causa do princpio baseado no peso relativo
da posio de cada dgito.
1
2 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 lingua-
gem de mquina, que correspondem a uma seqncia de instrues obscuras
e desconfortveis. Para contornar tal problema necessrio construir lingua-
gens 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 ma-
temtico, 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 3
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 intei-
ros. 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 im-

plementao 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 Pro-

grama
0 projeto de algoritmos fortemente influenciado pelo estudo de seus com-
portamentos. 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 en-
contrados 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
importantes do algoritmo em questo devem ser investigadas, geralmente

uma anlise do nmero de vezes que cada parte do algoritmo deve ser exe-
cutada, 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, con-
forme 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 pode-
mos 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 manei-
ras. Uma delas atravs da execuo do programa em um computador real,
sendo o tempo de execuo medido diretamente. As medidas de tempo obti-
das 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 quan-
tidades 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 si-
tuaes 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 algo-
ritmo atravs do uso de um modelo matemtico, baseado em um computa-
dor 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
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 consul-

tado. 0 pior caso ocorre quando o registro procurado o ltimo consultado,
8 CAPTULO 1. I N T R O D U O
A Tabela 1.1 apresenta uma comparao entre os algoritmos dos Pro-

gramas 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 f (n)
Algoritmos
Melhor caso Pior caso Caso mdio
MaxMin1 2(n-1) 2(n-1) 2(n-1)
MaxMin2 n1 2(n-1) 3n/2-3/2
MaxMin3 3n/2-2 3n/2-2 3n/2-2
Tabela 1.1: Comparao dos algoritmos para obter o mximo e o mnimo
Considerando novamente o nmero de comparaes realizadas, existe

possibilidade de obter um algoritmo mais eficiente para este problema? Para
responder a esta questo necessrio conhecer o limite inferior para a classe
de algoritmos para obter o maior e o menor elemento de um conjunto.
Uma tcnica muito utilizada para obter o limite inferior para uma classe
qualquer de algoritmos atravs da utilizao de um orculo.2 Dado um mo-
delo 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), uti-
liza 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, repre-

sentada 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 ele-
mentos 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 pa-
lavras, 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 as-
sinttico 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.
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. En-
tretanto, 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 al-
goritmos 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 exe-
cutado. 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 comple-
xidade 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 tipica-
mente em algoritmos que resolvem um problema transformando-o em
problemas menores. Nestes casos, o tempo de execuo pode ser con-
siderado 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 com-
plexidade 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 com-
plexidade 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 com-
plexidade cbica. Algoritmos desta ordem de complexidade so teis
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 Computador Computador Computador

custo de atual 100 vezes 1000 vezes
de tempo mais rpido mais rpido
n tl 100t 1 1000t 1
n2 t2 10t 2 31, 6t 2
n3 t3 4,6t 3 10t 3
2n t4 t 4+ 6 , 6 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 poli-
nomial 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 algo-
ritmos 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 or-
dem 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 efetiva-
mente 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 con-
junto que possuam uma propriedade comum. Estas tcnicas envolvem a
manipulao de somas, produtos, permutaes, fatoriais, coeficientes bino-
miais, 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 arbi-
trariamente 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 con-
dicional, 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 proce-
dimentos. 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) desconhe-
cida, 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, va-

mos apresentar alguns programas e, para cada um deles, mostrar com deta-
lhes os passos envolvidos em sua anlise.
Exemplo: Considere o algoritmo para ordenar os n elementos de um con-
junto A, cujo princpio o seguinte:
1. Selecione o menor elemento do conjunto
2. Troque este elemento com o primeiro elemento A[1].

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
1.4. TCNICAS DE ANLISE DE ALGORITMOS 23
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 to-
talidade, 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 cabealho do programa

label declarao de rtulo para goto
const definio de constantes
type definio de tipos de dados
var declarao de variveis
procedure ou function declarao de subprogramas
begin
.
. comandos do programa
.
end
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 adi-
cionais podem ser enumerados atravs de uma listagem de novos grupos de
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 = (vermelho, azul, rosa);
type sexo = (mas, fern);
type boolean = (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 = 1900..
1999; type letra =
'A'..'Z';
Dadas as variveis
vara :
ano; var b :
letra;
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 : (mas, ferm);
end;
Declarada a varivel
var p: pessoa;
valores particulares podem ser atribuidos como se segue
p.sobrenome := 'Ziviani';
p.primeironome := 'Patricia';
p.aniversrio.dia := 21;
p.aniversrio.ms := 10;
p.sexo := 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;
1.5. PASCAL 29
Programa 1.8: Programa para copiar arquivo
O Programa 1.8 copia o contedo arquivo Velho no arquivo Novo. Ob-

serve 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 encadea-
das, do tipo listas, rvores, e grafos. Um apontador uma varivel que re-
ferencia 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
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 pro-
gramas 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), Ho-
rowitz 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
EXERCCIOS 33
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 ne-

cessrias 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 de-
manda 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 compi-
ladores. 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 con-
junto 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 arran-
jos 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 anterior-
mente 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.
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

Programa 2.3: Estrutura da lista usando apontadores

Programa 2.4: Operaes sobre listas usando apontadores

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 con-
tendo 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, iniciando-
se 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 to-
mar 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
Programa 2.6: Primeiro refinamento do programa Vestibular
Figura 2.3. Aps a leitura do ltimo registro os candidatos esto automa-

ticamente 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.
Programa 2.7: Segundo refinamento do programa Vestibular
Neste momento ns somos forados a tomar decises sobre a imple-

mentao do tipo abstrato de dados Lista. Considerando-se que o tamanho
das listas varia de forma totalmente imprevisvel, a escolha deve cair
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, acompa-
nhada da troca dos operadores apresentados no Programa 2.4 pelos opera-
dores 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 pro-
curar 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 proces-
samento 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 ga-
rante 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.
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 imple-
mentaes 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 armaze-
nados 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 usa-
das 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.
2.2. PILHAS 51
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.@ cor-
responde 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 carac-
tersticas 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.
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 apon-
tadores 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
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 (ra-

be, 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.
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 circular-
Listas!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 clulas-
cabea, representar os termos diferentes de zero da matriz e devem
ter o seguinte tipo:
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, 4
1, 1, 50.0
2, 1, 10.0
2, 3, 20.0
4, 1, -30.0
4, 3, -60.0
4, 4, 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 pro-
cedimentos 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;

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 espe-
cificao 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 al-
teraes:
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 necessi-
dade 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?
10) Filas, Simulao (rabe, 1992)

O objetivo deste exerccio simular os padres de aterrissagem e deco-
lagem 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 che-
gando nas filas de decolagem (aterrissagem). A cada unidade de tempo,
assuma que os avies entram nas filas antes que aterrissagem ou de-
colagens 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 deco-
laram 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 espe-
cificao 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 es-
tabilidade 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 com-
paraes 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 espa-

das).
Mtodos como o ilustrado acima so tambm conhecidos como ordena-
o 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 apresen-
tado 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 tam-
bm 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 ar-
quivos 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, ilus-
trando com simplicidade os princpios de ordenao por comparao. Alm
72 C A P T U L O 2 2 . ORDENAO
Programa 3.2: Tipos utilizados na implementao dos algoritmos
do mais, existe um grande nmero de situaes em que melhor usar os

mtodos simples do que usar os mtodos mais sofisticados. Apesar de os
mtodos mais sofisticados usarem menos comparaes, estas comparaes
so mais complexas nos detalhes, o que torna os mtodos simples mais efici-
entes 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 2 3 4 5 6
Chaves iniciais: O R D E N A
i= 2 A R D E N O
i=3 A D R E N O
i=4 A D E R N O
i=5 A D E N R O
i=6 A D E N 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.
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 :

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 na-
tural 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.
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-
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 Pro-
grama 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.
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:
Anlise
Uma caracterstica interessante do Quicksort a sua ineficincia para ar-
quivos 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 pro-
cedimento 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.
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 or-
denao), a prxima seo ser dedicada ao seu estudo.
Filas de Prioridades
No estudo de listas lineares, no Captulo 2, vimos que a operao de desem-

pilhar 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
(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 me-
nos 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 priori-
dades aumente temporariamente de tamanho. A operao constri equi-
valente 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.
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.
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.
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 mo-

vimentadas 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.
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, respectiva-
mente. 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.
500 5000 10000 30000

Insero 11.3 87 161 -
Seleo 16.2 124 228 -
Shellsort 1.2 1.6 1.7 2
Quicksort 1 1 1 1
Heapsort 1.5 1.6 1.6 1.6
Tabela 3.1: Ordem aleatria dos registros
500 1 5000 110000 30000

Insero 1 1 1 1
Seleo 128 1524 3066 -
Shellsort 3.9 6.8 7.3 8.1
Quicksort 4.1 6.3 6.8 7.1
Heapsort 12.2 20.8 22.4 24.6
Tabela 3.2: Ordem ascendente dos registros
500 5000 10000 30000

Insero 40.3 305 575 -
Seleo 29.3 221 417 -
Shellsort 1.5 1.5 1.6 1.6
Quicksort 1 1 1 1
Heapsort 2.5 2.7 2.7 2.9
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 expe-
rimentados.
3. A relao Heapsort/Quicksort se mantm constante para todos os ta-
manhos, sendo o Heapsort mais lento.
4. A relao Shellsort/Quicksort aumenta medida que o nmero de ele-
mentos 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.
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 Quicksort Heapsort

5000 10000 30000 5000 10000 30000 5000 10000 30000
Asc 1 1 1 1 1 1 1.1 1.1 1.1
Des 1.5 1.6 1.5 1.1 1.1 1.1 1 1 1
Ale 2.9 3.1 3.7 1.9 2.0 2.0 1.1 1 1
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 en-
trada; 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 compor-
tamento 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 movi-
mentos 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
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 aponta-
dores, 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 regis-
tros que maior do que a memria interna do computador pode armazenar.
Os mtodos de ordenao externa so muito diferentes dos mtodos de or-
denao 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 im-
portantes 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 aces-
sados 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 depen-
dente do estado atual da tecnologia. A grande variedade de tipos de
unidades de memria externa pode tornar os mtodos de ordenao ex-
terna dependentes de vrios parmetros que afetam seus desempenhos.
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 al-
gortmico. 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 or-
denao 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 es-
tratgia 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 ar-

mazenado 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.
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 pri-

meiro 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 for-
mados 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 blo-
cos 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:
quantas passadas so necessrias para ordenar um arquivo de tamanho ar-

bitrrio?
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 re-
gistro 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 orde-
nados 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 in-
terna, o qual deve ser substitudo pelo prximo registro da fita de entrada.
A operao de substituio do menor item de uma fila de prioridades imple-
mentada atravs de um h e a p a operao ideal para resolver o problema.
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
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
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 com-
paraes 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,
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, sim-
plesmente 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 inter-
calao 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 proces-
sador 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 pro-
cessador 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 su-
ficiente 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 inter-
calao 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 ele-
mentos de cada linha. A seguir ordene em ordem crescente os elementos
de cada coluna. Prove que os elementos de cada linha continuam em
ordem.
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 con-
junto muito grande de n nmeros inteiros, cada nmero de grande
magnitude (com muitos dgitos), usando o seu mtodo O(n log n) fa-
vorito, aconteceu um terremoto de grandes propores. Milagrosa-
mente, o computador no destrudo (nem voc), mas, por algum
motivo, cada um dos 4 bits menos significativos de cada nmero in-
teiro 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, Se-
leo, Shellsort, Quicksort, Heapsort.
a) Determine experimentalmente o nmero esperado de (i) com-

paraes 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. Uti-
lize arquivos de diferentes tamanhos com chaves geradas rando-
micamente. 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 per-
mitem 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 re-
curso 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 empirica-
mente o melhor valor de M para um arquivo gerado aleatoria-
mente com 1000 (mil) elementos;
c) Melhore a verso 2 utilizando a tcnica de mediana-de-trs ele-
mentos para escolha do piv.
Gere massas de testes para testar e comparar cada uma das imple-
mentaes. Use sua criatividade para criar arquivos de teste interes-
santes. Faa tabelas e/ou grficos para mostrar e explicar os resultados
obtidos. .
O que deve ser apresentado:
a) Listagem dos programas em Pascal. Vo valer pontos clareza,

indentao e comentrios no programa.
c) Descrio sucinta dos arquivos de teste utilizados, relatrio com-
parativo 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 clas-

sificao utilizando o relgio da mquina;
b) mantenha contadores (que devem ser atualizados pelos procedi-
mentos 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 ar-
quivo 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 es-
teja 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 inter-

calao-balanceada-de-2-caminhos, utilizando apenas 3 fitas ma-
gnticas e uma memria interna com capacidade para armazenar
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 ar-
quivos intermedirios de trabalho. A seguir os arquivos intermedirios
so intercalados e copiados em outros arquivos de trabalho, at que to-
dos 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 imple-
mentar 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 ar-
mazenados 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 pre-
sentes 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 pra-
ticamente 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 abstra-
tos 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 ape-
nas 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
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 posi-
o 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, ex-

tremamente 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 al-
goritmo 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 armaze-
nar 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 regis-
tros; (iii) boa taxa de utilizao de memria; (iv) utilizao de memria
primria e secundria.
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 pes-
quisa 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 im-
plementar o tipo abstrato de dados Dicionrio (lembre-se que o tipo abstrato
Dicionrio contm as operaes Inicializa, Pesquisa, Insere e Retira). A es-
trutura 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.
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 es-
querda, 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: Programa para criar a rvore
O Programa 4.9 mostra a implementao da operao Retira. 0 proce-

dimento 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 caminha-
mento em rvores, mas a mais til a chamada ordem de caminhamento
central. Assim como a estrutura da rvore, o caminhamento central me-
lhor 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 Fi-
gura 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.
Programa 4.9: Procedimento para retirar x da rvore

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 balan-
ceada 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.
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 inter-

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

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 procedi-
mentos Insere e Retira, com o objetivo de eliminar dois apontadores hori-
zontais sucessivos. 0 Programa 4.12 mostra a implementao destes proce-
dimentos.
O procedimento Insere tem uma interface idntica interface do pro-

cedimento Insere para rvores sem balanceamento, conforme pode ser visto
no Programa 4.13. Para que isso seja possvel o procedimento Insere sim-
plesmente chama um outro procedimento interno de nome Ilnsere, cuja in-
terface contm dois parmetros a mais que o procedimento Insere, a saber:
o parmetro IAp indica que a inclinao do apontador toma o valor hori-
zontal 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.
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

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 referen-

dado 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.
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 de-
las a altura vertical h, necessria para manter a altura uniforme e obtida
atravs da contagem do nmero de apontadores verticais em qualquer cami-
nho 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 determina-
das 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
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 extre-
midade 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.
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 recu-
perao 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 in-
sero baseados nos algoritmos propostos por Knuth. Gonnet e Baeza-Yates
(1991) propuzeram tambm outros algoritmos.
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.
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.
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
4.35. TRANSFORMAO DE CHAVE (HASHING) 135
a partir do ltimo ndice consecutivo melhora consideravelmente o de-

sempenho 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 com-
parao 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 par-
tir 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 ar-

mazenar 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
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 trans-
formao 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
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 Pro-
grama 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 ) ope-
raes 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

4.5.3 Open Addressing

Quando o nmero de registros a serem armazenados na tabela puder ser pre-
viamente 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.
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.
C(n)
0.10 1.06
0.25 1.17
0.50 1.50
0.75 2.50
0.90 5.50
0.95 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 ta-
bela, ento uma longa lista linear pode ser formada, deteriorando o tempo
mdio de pesquisa. 0 melhor caso, assim como o caso mdio, 0(1).
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 in-
cluem 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 pes-
quisa 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 rece-
beu 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 loca-

lizadas 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
para percorrer o caminho de pesquisa. Wirth (1976, 1986) apresenta imple-

mentaes 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 im-
plementaes 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 pes-
quisa 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 pro-
blema?
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 su-

cessiva das chaves Q U E S T A O F C I L numa rvore inicial-
mente 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 pro-
cure 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 trans-
formaes produz rvores SBB com menor altura e demanda um n-
mero 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 apon-
tadores, a operao divide esquerda-direita requer a alterao de cinco
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 origi-
nal, 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 encon-
trado 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 rand-
mica (isto , no seguem o padro das chaves j inseridas). Assim
responda:
i) Qual a ordem do pior caso (isto , o maior nmero de com-
paraes) 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.)
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 re-

gistros com as chaves XXXXXXXXXXXX, nesta ordem, numa
tabela inicialmente vazia de tamanho 7 (sete), usando listas enca-
deadas. 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 re-
gistros com as chaves XXXXXXXXXXXX, nesta ordem, numa
tabela inicialmente vazia de tamanho 13 (treze), usando open ad-
dressing 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 es-
perado 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 so-
licitado;
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 con-
ceito de independncia de implementao, atravs da utilizao de
duas estruturas de dados distintas para implementar o mesmo pro-
blema. 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 rele-
vantes 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,
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 4 5 6
be 3
by 2 6 7
easy 3 4
human-engineered 5
programming 1 7
programs 3
to 3 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 cons-
tituir 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 dgi-

tos, 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 lis-
tas.) 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.
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 (diga-
mos 100 milhes), qual a maior dificuldade para construir
a rvore Patricia?
ii) Como a dificuldade apontada no item anterior pode ser su-
perada?
18) rvore Patricia (Murta, 1992)

Considere o seguinte trecho do poema "Quadrilha" de Carlos Drum-
mond 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 01001011 Maria 01100101

amava 00011101 Joaquim 00101110
Teresa 11101011 Lili 01010011
que 10100101 no 10011100
Raimundo 11011010 ningum 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 cha-
ves 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 efi-
ciente 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 con-
sulta 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 efi-
ciente 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 con-
sulta 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
apenas os nodos externos da rvore. 0 arranjo constitudo de aponta-

dores para o incio de cada palavra de um arquivo de texto. Logo, ne-
cessrio apenas um apontador para cada ponto de indexao no texto.
Este arranjo dever estar indiretamente ordenado pela ordem lexi-
cogrfica 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. Qual-
quer 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 simu-
lada, 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 resul-
tado 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 con-
junto 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 me-

dida 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, dei-
xando a rea de armazenamento vazia e pronta para receber novos
registros.
A tcnica de utilizao de reas de armazenamento evita que um pro-

cesso 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 arma-
zenamento. 0 processo usurio pega o dado nesta rea e somente
obrigado a esperar quando a rea se esvazia. Quando isto ocorre, o sis-
tema operacional enche novamente a rea e o processo continua. Esta
tcnica pode ser aprimorada com o uso de duas ou mais reas de ar-
mazenamento. 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 arquite-
tura e do sistema operacional da mquina tornam os mtodos de pes-
quisa dependentes de parmetros que afetam seus desempenhos. As-
sim, a transferncia de blocos entre as memrias primria e secundria
deve ser to eficiente quanto as caractersticas dos equipamentos dis-
ponveis o permitam. Tipicamente, a transferncia se torna mais efici-
ente 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 efici-
ente 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 Se-

cundria
Esta seo apresenta um modelo de computao para memria secundria
conhecido como memria virtual. Este modelo normalmente implemen-
tado 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 vir-
tual. 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 aces-
sada 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 loca-
lizao fsica de memria. 0 ponto crucial a distino entre espao de en-
dereamento 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 dis-
ponvel. 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
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 p-
sima 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 utili-

zados 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 pagi-
nados 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 apon-
tadores). A pgina que est na moldura do incio da fila a pgina
LRU. Quando uma nova pgina tem que ser trazida da memria se-
cundria ela deve ser colocada na moldura que contm a pgina LRU.
Menos Freqentemente Utilizada (LFU). 0 algoritmo LFU (Least Fre-
quently 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 p-

ginas 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 res-
ponsabilidade 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 Pro-
grama 5.2, onde o usurio pode declarar at trs tipos diferentes de pginas.
Se o tipo PginaTipoA for declarado
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 implemen-
tado, 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 se-
cundria 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 seqencial-
mente 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
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 posi-
cionado 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 lei-
tura/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 carac-
tersticas do disco magntico e procurar minimizar o nmero de deslocamen-
tos 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
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 armazena-
mento (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
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 apenas-
leitura, 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 aproxima-
damente 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 CD-
ROM , 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
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 seqen-
cial indexada permite tanto o acesso seqencial quanto o acesso randmico
aos dados. Nos discos magnticos a estrutura seqencial indexada imple-
mentada 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
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 tri-
lhas 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 cilin-
dros 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).
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 in-
teiramente 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 uti-
lizando 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 im-

portante 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-
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 relacio-
nados 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 in-
seres 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

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 extrema-
mente 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 Pro-
grama 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 atin-
gida (no caso um apontador nulo). Na implementao do Programa 5.5 a
Programa 5.4: Procedimento para inicializar uma rvore B
localizao do intervalo onde a chave se encaixa obtida atravs de uma pes-

quisa 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.
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 aco-

modar 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 recur-
sivo, de nome Ins, de estrutura semelhante ao Programa 5.5 acima. Quando
um apontador nulo encontrado, significa que o ponto de insero foi lo-
calizado. Neste momento o parmetro Cresceu passa a indicar este fato
informando que um registro vai ser passado para cima atravs do parmetro
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.
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
(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.
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 proce-
dimento 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 An-
tecessor. A condio de que menos do que m registros passam a ocupar a
pgina sinalizada pelo parmetro Diminuiu, fazendo com que o procedi-
mento 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;
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 re-
gistros 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 par-
ticionada 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.
Figura 5.15: Exemplo de uma rvore B"
A operao de insero de um registro em uma rvore B* essencial-

mente 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 re-
tirado 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 uti-
lizao 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 pro-
tocolos para garantir a integridade tanto dos dados quanto da estrutura.
Considere a situao em que dois processos estejam simultaneamente aces-
sando o banco de dados. Em um determinado momento, um dos processos
est percorrendo uma pgina para localizar o intervalo onde a chave de pes-
quisa se encaixa e seguir o apontador para a subrvore correspondente, en-
quanto o outro processo est inserindo um novo registro que provoca divises
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 possibi-
lidade 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 es-
trutura da rvore. No caso de operaes de insero, uma pgina conside-
rada 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.

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 pro-
cesso 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.
Para exemplificar o funcionamento do modelo do protocolo para proces-

sos modificadores considere a modificao da pgina y da rvore B* apre-
sentada 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 mo-
dificaes 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
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 proces-

samento 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 in-
sero, 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
Tamanho Tamanho do arquivo

da pgina 1 . 0 0 0 10.000 100.000 1.000.000 10.000.000
10 3 4 5 6 7
50 2 3 3 4 4
100 2 2 3 3 4
150 2 2 3 3 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 pro-

posto 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 in-
sero da chave do meio na pgina pai localizada no nvel acima. Uma
medida de complexidade de interesse Pr{j parties}, que corres-
ponde probabilidade de que j parties ocorram durante a N-sima
insero randmica. No caso da rvore 2-3
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 proces-
sos modificadores. Estes resultados mostram que solues muito com-
plicadas para permitir o uso de concorrncia de operaes em rvores
B no trazem grandes benefcios porque, na maioria das vezes, o tra-
vamento ocorrer em pginas folha, o que permite alto grau de con-
corrncia mesmo para os protocolos mais simples.
Maiores detalhes sobre os resultados analticos apresentados acima po-
dem ser obtidos em Eisenbarth et al. (1982).
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 pe-
queno (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) apre-
sentam 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. De-
pendendo da complexidade de cada procedimento pode ser inte-
ressante 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.
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. Es-
tes 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 cons-
trudo faa a medida do tempo de execuo para:
a) Construir rvores B de tamanhos 1.000, 10.000 e 50.000 cha-
ves geradas randomicamente atravs de um gerador de nme-
ros aleatrios. A medida de tempo deve ser tomada de forma
independente para cada uma das trs rvores. A ordem m das
rvores deve ser tal que o tamanho da pgina seja igual ou
menor do que 512 bytes.
EXERCCIOS 19 5
b) Para a maior das trs rvores que voc conseguiu construir

gere aleatoriamente um conjunto de 200 chaves e realize uma
pesquisa na rvore para cada chave. Caso haja chaves que
no estejam presentes no arquivo informe quantas pesquisas
foram com sucesso e quantas foram sem sucesso. Com esta
medida podemos ter uma idia do tempo aproximado para
pesquisar um registro no arquivo.
Ateno: procure interpretar os resultados obtidos. Por exemplo,
voc deve informar qual foi o nmero de Molduras_de_Pginas
utilizadas para os experimentos acima (com 256 Kbytes de
memria real disponvel possvel manter cerca de 120 molduras
na memria principal). Quaisquer outras observaes relevantes
devem ser relatadas.
Observaes:
a) A pesquisa da chave de um registro dentro de uma pgina da

rvore B pode ser feita atravs de uma pesquisa seqencial.
b) A deciso sobre a documentao a ser apresentada fica por conta
do aluno.
4) Modifique a implementao do procedimento original apresentado no

Programa 5.5 para que a pesquisa da chave dentro de uma pgina da
rvore B seja realizada atravs de um pesquisa binria.
Apndice A
Programas C do Captulo 1
197
198 PROGRAMAS EM C DO CAPTULO 1
PROGRAMAS EM C DO CAPTULO 1 199
Apndice B
203
Apndice C
217
Apndice D
223
PROGRAMAS EM C DO CAPTULO 4. 237
Apndice E
243
Apndice F
Caracteres ASCII
253
Apndice G
Referncias Bibliogrficas
Adel'son-Vel'skii, G.M. e Landis, E.M. (1962) "An Algorithm for the Or-
ganization 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 Al-
gorithms. 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 Mainte-
nance 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 Algo-

rithms. 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, En-

glewood 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 B-
Trees", 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.
REFERNCIAS BIBLIOGRFICAS 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 Algo-
rithms. 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 Ap-

plications 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". Com-

munications 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. Springer-
Verlag, 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, 135-
143.
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: Seminu-
merical Algoritms. Segunda edio, Addison-Wesley, Reading, Mass.
Lister, A.M. (1975) Fundamentals of Operating Systems. Macmillan, Lon-

don.
Lueker, G.S. (1980) "Some Techniques for Solving Recurrences". ACM
Computing Surveys 12(4), 419-436.
Manber, U. (1988) "Using Induction to Design Algorithms". Communica-

tions ACM 31 (11), 1300-1313.
Manber, U. (1989) Introduction to Algorithms A Creative Approach. Addi-
son-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 Infor-

mation 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, Bl-
gica.
Peterson, J. e Silberschatz, A. (1983) Operating System Concepts. Addison-

Wesley, Reading, Mass.
Sedgewick, R. (1975) "The Analysis of Quicksort Programs". Acta Infor-

matica 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". Communica-

tions ACM 21 (10), 847-857.
Sedgewick, I t (1988) Algorithms. Addison-Wesley, Reading, Mass., se-

gunda edio.
Shell, D.L. (1959) "A Highspeed Sorting Procedure". Communications

ACM 2(7), 30-32.
REFERNCIAS BIBLIOGRFICAS 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, Rea-

ding, 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, Phi-
ladelphia, 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 Jour-
nal4, 351-367.
Weide, B. (1977) "A Survey of Analysis Techniques for Discrete Algo-

rithms". ACM Computing Surveys 9 (4), 291-313.
Williams, J.W.J. (1964) "Algorithm 232". Communications ACM 7(6), 347-

348.
Wirth, N. (1971) "Program Development by Stepwise Refinement ". Com-
munications 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.
Ziviani, N. e Tompa, F.W. (1982) "A Look at Symmetric Binary B-Trees"

INFOR Canadian Journal of Operational Research and Information
Processing 20 (2), 65-81.
ndice
O notao, 13 caso mdio, 6
O operaes, 12, 13 de um algoritmo particular, 3 de
[ ] conjunto em Pascal, 27 uma classe de algoritmos, 4 melhor
notao, 14 caso, 6
[ ] teto, 8 pior caso, 6
[] - Piso, 8 tcnicas de, 1824
somatrio, 21 Arabe J.N.C., 59, 100, 103, 148 rea de
2-3, rvores, 118, 190 2-3- armazenamento, 97, 155, 165
4, rvores, 119, 144 Arquivo
Adel'son-Vel'skii G.M., 143 conceito, 107
Agrupamento em tabelas hashing, 141 definio, 28
Aho A.V., 2, 13, 19, 30, 36, 56, 58, 99, Arranjos, definio, 26
143 Arvores, 83, 84, 112135, 169192, 194
Albuquerque L.C.A., 131 2-3, 118, 190
2-3-4, 119, 144
Algoritmos
altura de, 112, 126
anlise de, 324
auto-ajustvel, 144
classes de, 15
comparao, 1424 AVL, 143
B, 118, 170181, 194
complexidade, 324
binrias, 118
conceito, 1
definio, 170
escolha de, 1, 12, 71, 107
tcnica de overflow, 192 B*,
exponenciais, 16, 17 timos,
182188
4, 5, 11, 24 polinomiais, 17
acesso concorrente, 184188
recursivos, 1924, 47, 79, 112
deadlock, 188
135, 170192 Alocao
definio, 182
dinmica, 29, 189
pgina segura, 185
encadeada, 29, 38, 49, 65
processo leitor, 186
Altura de rvore, 112, 126
processo modificador, 186
Amortizado, custo, 30, 144
protocolos, 184
Anlise de algoritmos, 324
semforos, 187
261
NDICE
262
balanceadas, 117127, 169192 pesquisa, 110111

binrias, 83, 112 Blocos
binrias de pesquisa, 112 binrias em fitas, 93
de pesquisa com ba- ordenados, 92, 96
lanceamento, 117127 Bolha, mtodo de ordenao, 89
binrias de pesquisa sem ba- Bruta, fora, 16 Bubblesort, 89
lanceamento, 112117 binrias Bucketsort, 71'
completas, 83 caminhamento central,
115 caminho interno, 118, 143 Cabea de lista, 38
completamente balanceadas, 117 Caminhamento em rvores, 115 Caminho
definio, 112 interno em rvores de pesquisa, 118,
digitais de pesquisa, 127135 n- 143
rea, 170 Cartes, classificadora de, 71
nvel de um nodo, 112 Cartas, jogo de, 70, 73
Patricia, 129135 Carvalho M.L.B., 33, 34
randmicas, 117, 190 Casamento
red-black, 144 de cadeias, 129
representao de, 84, 112, 171 de padres, 129
SBB, 118145 Caso mdio, anlise de algoritmos, 6
definio, 119 CD-ROM (Compact Disk Read Only
Trie, 128129 Memory), 166
ASCII, tabela de caracteres, 253 Central, caminhamento em rvores, 115
Assinttica Chave
complexidade, 14 de ordenao, 69
dominao, 12 de pesquisa, 6, 107
Assinttico de tamanho varivel, 127
classes de comportamento, 14 18 semi-infinita, 128, 152, 153
funes que expressam, 14 transformao de, 135143
Auto-ajustvel, rvores, 144 AVL, Christodoulakis S., 167
rvores, 143 Cilindro
em discos ticos, 167
Baeza-Yates R., 4, 99, 118, 129, 143, em discos magnticos, 164, 167
153, 192 Circulares, listas, 56
Balanceada, intercalao, 9297 Clancy M., 25
Balanceadas, rvores, 117127, 169 Classes de comportamento assinttico,
192 1418
Barbosa E.F., 167, 168 Classificao, vide Ordenao
Bayer R., 118-120, 127, 144, 147, 170, Classificadoras de cartes, 71
185, 186, 188191 Binria Clustering, 141
rvore, 83, 111127
NDICE 263
Colises, resoluo de, 135137, 140, 108

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

Fifo, (first-in-first-out), 55, 160 com balanceamento, 122
Filas, 55-58 sem balanceamento, 113 em
Filas de prioridades, 81-83, 91, 94-96 rvores B, 172
Fitas magnticas, 70, 9194, 98 em rvores B*, 184
Flajolet P., 30 em filas, 55, 57, 60
Floyd R.W., 84, 99 em listas lineares, 36
Fora bruta, 16 em pilhas, 48, 50, 52
Ford D.A., 167 em tabelas hashing, 138, 140
Funes ordenao por, 73-75, 89, 91
comportamento assinttico, 11 de Intercalao
complexidade, 5, 1416 de balanceada, 92-97
transformao, 135137 hashing, de dois arquivos, 103
135 ordenao por, 91-99
piso (LJ), 8 ISAM, 189
teto ((I), 8
Furtado A.L., 42
Jensen K., 25, 30
Garey M.R., 16, 17 Johnson D.S., 16, 17
Gonnet G.H., 4, 99, 118, 129, 143-145, Keehn D., 189
153, 190, 192 Graham R.L., 30 Knott G., 136
Greene D.H., 30 Knuth D.E., 3, 4, 13, 30, 36, 58, 73, 76,
Guibas L., 119, 144 96, 97, 99, 112, 129, 136, 137,
140, 141, 143, 170, 192
Hashing, 135143
duplo, 148 Lacy J., 189
funes de transformao, 136 Landis E.M., 143
137 Laser, feixe de, 166
linear, 140 Latncia, em disco magntico, 164
listas encadeadas, 137138 Leiserson C.E., 30, 58, 99
open addressing, 140143 Lfu (least-frequently-used), 159
Heaps, 83-86, 91 Lifo (last-in-first-out), 47
Heapsort, 81-86, 90 Limite inferior
Hibbard T.N., 143 Hoare conceito, 4, 10
C.A.R., 78 Hoare, C.A. orculo, 10
R., 30, 99 para obter o mximo de um
Hoperoft J.E., 2, 13, 19, 30, 36, 47, 56,
conjunto, 5
58, 99, 143
para obter o mximo e o mnimo de
Horowitz E., 10, 30
um conjunto, 10 Lineares,
algoritmos, 15 -
Listas
cabea de, 38, 61
circulares, 56
Indireta, ordenao, 90
Insero
NDICE 265
duplamente encadeadas, 59 bucketsort, 71

encadeadas (em hashing), 137-138 comparao entre os mtodos, 87
lineares, 3558 91
Lister A.M., 157, 188, 192 digital, 71
Localidade de referncia, 160 estvel, 69, 73, 75, 77, 81, 86
Lock protocols, vide Protocolos para heapsort, 8186, 90
travamento indireta, 90
Logartmicos, algoritmos., 15 mergesort, 103
Lru (least-recently-used), 159, 192 por insero, 7375, 89, 91 por
Lueker G.S., 30 seleo, 7273, 89 quicksort,
Mximo de um conjunto, 5 7881, 90 radixsort, 71
Mximo e mnimo de um conjunto, 7 shellsort, 7677, 89
11, 2324 por comparao, 70
Manber U., 30, 154 por distribuio, 70
Matrizes esparsas, 59 Ordenadas, listas, 75, 83
McAllister D.F., 5, 30 timo, algoritmo, 4, 5, 11, 24Overflow,
McCreight E.M., 118, 170, 189, 190, 192 tcnica de insero em rvores B,
Mehlhorn K., 143, 190 192
Melhor caso, anlise de algoritmos, 6
Memria virtual, 157163 Pgina
Merge, vide intercalao de uma rvore B, 170
Mergesort, 103 em sistemas de paginao, 157
Morrison D.R., 129 segura, 191
Muntz R., 170 tamanho em uma rvore B, 192
Murta C.D., 152 Paginao, 157163, 192
Myers G., 154 Pai, em estrutura de rvore, 83
Paradoxo do aniversrio, 136
Notao , definio, 14 Partio, Quicksort, 79
Notao O, definio, 13 Pascal, linguagem de programao,
Notao O, operaes, 12, 13 2530
Olivi H., 144, 145, 147 Pat array, 153
Open addressing, 140143 Patashnik O., 30
Orculo, 10 Patricia, 129135
Ordenao, 69106 Pesquisa
externa, 70, 9199, 104 por com sucesso, 107
intercalao, 9199 interna, em listas lineares, 36
7091 em memria externa, 155192 em
bolha, 89 rvores B*, 182
bubblesort, 89 em memria interna, 6, 107143
binria, 110111
266 NDICE
digital, 127135 Recorrncia, relao de, 18, 21, 31, 33

em rvores binrias, 111 em Recursivos, algoritmos, 1924, 47, 79,
rvores binrias com ba- 112135
lanceamento, 117127 Red-black, rvores, 144
em rvores binrias sem ba- Registros, 6, 27, 107
lanceamento, 112117 Relao de recorrncia, 18, 21, 31, 33
em rvores Patricia, 129135 Retirada de itens
em rvores Trie, 128129 em rvores B, 177
por comparao de chave, 108 em rvores B*, 184
127 em rvores de pesquisa
por transformao de chave, com balanceamento, 124
135143 sem balanceamento, 113 em
seqencial, 6, 108110 filas, 55, 57, 60
seqencial rpida, 110 em listas lineares, 36, 39, 41
sem sucesso, 107 em pilhas, 48, 50, 52
Peterson J., 157 em tabelas hashing, 138, 140
Pilhas, 4753 Rivest R.L., 30, 58, 99
Pior caso, anlise de algoritmos, 6
Piso, funo ([ J), 8
Polinomiais, algoritmos, 17
Ponto de ncora, em discos ticos, 167
Sahni S., 10, 30
Previso, tcnica de, 98
S B B , rvores, 118145
Prioridades, filas de, 8183, 9496
Schkolnick M., 185, 186, 188, 191
Processo
Schkolnik M., 192
leitor, 186
Sedgewick R., 58, 70, 90, 91, 96,
modificador, 186
98, 99, 119, 129, 144, 148
Programas, 2
Seek time, vide Tempo de busca Segura,
Protocolos, 184
pgina de uma rvore B*,
para processos leitores, 186 para
185, 191
processos modificadores, 186
Seleo
para travamento, 185
ordenao por, 7273, 89
Quadrticos, algoritmos, 15 por substituio, 9497 Self-
Quicksort, 7881, 90 adjusting, vide Auto-ajustve l
mediana de trs, 81, 90 Semforo, 187
partio, 79 Semi-infinita, chave, 128, 152, 153
pequenos subarquivos, 90 Sentinelas, 72, 7476, 110 Seqencial
piv, 7880, 90 indexado, 163168 Seqencial,
Radixsort, 71 pesquisa, 6, 108110 Shell D.L., 76, 99
Randmica, rvore de pesquisa, 117, 190 Shellsort, 7677, 89
Silberschatz A., 157
Sleator D.D., 144
Stanat D.F., 5, 30
NDICE 267
Standish T.A., 143 Wirth N., 2, 25, 30, 99, 115, 143,
Suffix array, 154 144, 147, 170, 192 Wood D., 190
Tanenbaum A.S., 157
Ziviani N., vii, 127, 131, 144, 145,
Tarjan R.E., 30, 143, 144
167, 168, 190
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

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

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.

1. Algoritmos 2. C (Linguagem de programao

Nivio Ziviani, Ph.D.

Nenhuma parte deste livro poder ser reproduzida sejam

Todos os direitos reservados por

O livro apresenta as principais tcnicas utilizadas para a implementao de

O material apresentado adequado para ser utilizado como livro texto em

Lista de Figuras xiii

Lista de Programas xvii

2 Estruturas de Dados Bsicas 35

4 Pesquisa em Memria Primria 107

5 Pesquisa em Memria Secundria 155

A Programas C do Captulo 1 197

B Programas C do Captulo 2 203

C Programas C do Captulo 3 217

D Programas C do Captulo 4 223

E Programas C do Captulo 5 243

F Caracteres ASCII 253

G Referncias Bibliogrficas 255

3.14 Conjunto ordenado na primeira passada .............................................. 96

4.1 Exemplo de pesquisa binria para a chave G ......................................... 111

5.1 Mapeamento de endereos para paginao ............................................ 159

3.1 Ordem aleatria dos registros ............................................................... 88

4.1 Nmero de comparaes em uma pesquisa com sucesso para hashing

5.1 Nmero de acessos a disco, no pior caso, para tamanhos vari-

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

3.4 Ordenao por insero ........................................................................ 75

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

C;1 Estrutura de um item do arquivo ....................................................... 217

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

1.1 Algoritmos, Estruturas de Dados e Programas

Programar basicamente estruturar dados e construir algoritmos. De

1.2 Tipos de Dados e Tipos Abstratos de Dados

mesma forma que um procedimento usado para encapsular partes de um

1. faa a lista vazia,

2. obtenha o primeiro elemento da lista. Se a lista estiver vazia ento

Existem vrias opes de estruturas de dados que permitem uma im-

1.3 Medida do Tempo de Execuo de um Pro-

importantes do algoritmo em questo devem ser investigadas, geralmente

A medida do custo de execuo de um algoritmo depende principalmente

melhor caso : (n) = 1

0 melhor caso ocorre quando o registro procurado o primeiro consul-

A Tabela 1.1 apresenta uma comparao entre os algoritmos dos Pro-

Tabela 1.1: Comparao dos algoritmos para obter o mximo e o mnimo

Considerando novamente o nmero de comparaes realizadas, existe

O comportamento do algoritmo pode ser descrito por uma 4-tupla, repre-

1.3.1 Comportamento Assinttico de Funes

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

1.3.2 Classes de Comportamento Assinttico

A maioria dos algoritmos possui um parmetro que afeta o tempo de

apenas para resolver pequenos problemas. Quando n cem, o nmero de

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

Para ilustrar melhor a diferena entre as classes de comportamento assinttico

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

Funo de Computador Computador Computador

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

Figura 1.4: Problema do caixeiro viajante

1.4 Tcnicas de Anlise de Algoritmos

Infelizmente no existe um conjunto completo de regras para analisar

1. 0 tempo de execuo de um comando de atribuio, de leitura ou de