Técnicas de Programação Avançada

PROF. MATEUS CONRAD BARCELLOS DA COSTA 

TÉCNICAS DE PROGRAMAÇÃO AVANÇADA 

VITÓRIA 

2008

Governo Federal 

Ministro de Educação 

Fernando Haddad 

CEFETES – Centro Federal de Educação Tecnológica do Espírito Santo 

Diretor Geral 

Jadir José Pela 

Diretor de Ensino 

Denio Rebello Arantes 

Coordenadora do CEAD – Centro de Educação a Distância 

Yvina Pavan Baldo 

Coordenadoras da UAB – Universidade Aberta do Brasil 

Yvina Pavan Baldo 

Maria das Graças Zamborlini 

Designer Instrucional 

Danielli Veiga Carneiro 

Curso de Tecnologia em Análise e Desenvolvimento de Sistemas 

Coordenação de Curso 

Isaura Nobre 

Professor Especialista/Autor 

Mateus Conrad Barcellos da Costa 

DIREITOS RESERVADOS 

Cefetes – Centro Federal de Educação Tecnológica do Espírito Santo 

Av. Vitória - Jucutuquara - Vitória - ES - (27) 3331.2139 

Créditos de autoria da editoração 

Capa: Leonardo Tavares Pereira 

Projeto gráfico: Danielli Veiga Carneiro 

Iconografia: Moreno Cunha 

Editoração eletrônica: Mateus Conrad B. da Costa, Humberto Wanke, Monia Vignati 

Revisão de texto: Karina Bersan Rocha 

COPYRIGHT – É proibida a reprodução, mesmo que parcial, por qualquer meio, sem 

autorização escrita dos autores e do detentor dos direitos autorais. 

Catalogação na fonte: Rogeria Gomes Belchior - CRB 12/417 

1. 

C837 Costa, Mateus Conrad Barcellos da 

Técnicas de programação avançada. / Mateus Conrad Barcellos da. – Vitória: 

CEFETES, 2008. 

132 p. : il. 

1. Programação (Computadores). I. Centro Federal de Educação Tecnológica do 

Espírito Santo. II. Título. 

CDD 005.1

Olá, Aluno(a)! 

É um prazer tê-lo conosco. 

O Cefetes oferece a você, em parceria com as Prefeituras e com o 

Governo Federal, o Curso Tecnologia em Análise e Desenvolvimento 

de Sistemas, na modalidade a distância. Apesar de este curso ser 

ofertado a distância, esperamos que haja proximidade entre nós, pois, 

hoje, graças aos recursos da tecnologia da informação (e-mails, chat, 

videoconferência, etc.) podemos manter uma comunicação efetiva. 

É importante que você conheça toda a equipe envolvida neste curso: 

coordenadores, professores especialistas, tutores a distância e tutores 

presenciais, porque quando precisar de algum tipo de ajuda, saberá a 

quem recorrer. 

Na EaD – Educação a Distância, você é o grande responsável pelo 

sucesso da aprendizagem. Por isso, é necessário que se organize para 

os estudos e para a realização de todas as atividades, nos prazos 

estabelecidos, conforme orientação dos Professores 

Especialistas e Tutores. 

Fique atento às orientações de estudo que se encontram 

no Manual do Aluno! 

A EaD, pela sua característica de amplitude e pelo uso de 

tecnologias modernas, representa uma nova forma de aprender, 

respeitando, sempre, o seu tempo. 

Desejamos-lhe sucesso! 

Equipe do CEFETES

ICONOGRAFIA 

Veja, abaixo, alguns símbolos utilizados neste material para guiá-lo em seus estudos. 

Fala do professor. 

Conceitos importantes. Fique atento! 

Atividades que devem ser elaboradas por você, após a leitura dos textos. 

Indicação de leituras complementares, referentes ao conteúdo estudado. 

Destaque de algo importante, referente ao conteúdo apresentado. Atenção! 

Reflexão/questionamento sobre algo importante, referente ao conteúdo 

apresentado. 

Espaço reservado para as anotações que você julgar necessárias.

Sumário 

1. ABSTRAÇÃO DE DADOS.......................................................................................................................... 9 

1.1 INTRODUÇÃO .......................................................................................................................................... 9 

1.2 CONCEITOS DE ABSTRAÇÃO DE DADOS ................................................................................................. 12 

1.2.1 Abstração em Computação.............................................................................................................. 12 

1.2.2 Abstração de Procedimentos ........................................................................................................... 14 

1.2.3 Tipos Abstratos de Dados................................................................................................................ 16 

1.2.4 Implementação de Tipos Abstratos de Dados.................................................................................. 23 

1.2.5 Avaliação de Implementações de Tipos Abstratos de Dados .......................................................... 25 

2. TIPOS ABSTRATOS DE DADOS FUNDAMENTAIS. ......................................................................... 30 

2.1 PILHAS.................................................................................................................................................. 30 

2.1.1 Especificação do TAD Pilha............................................................................................................ 32 

2.1.2 Implementação de Pilhas em Arranjos............................................................................................ 34 

2.2 FILAS .................................................................................................................................................... 37 

2.2.1 Especificação do TAD FILA............................................................................................................ 39 

2.2.2 Implementação de Filas em arranjos com deslocamento................................................................ 42 

2.2.3 Implementação de Filas com Arranjos circulares........................................................................... 45 

2.3 IMPLEMENTAÇÃO DE TADS COM ALOCAÇÃO DINÂMICA DE MEMÓRIA................................................. 47 

2.3.1 Revisão de Alocação Dinâmica de Memória................................................................................... 47 

2.3.2 Implementação do TAD Pilha ......................................................................................................... 55 

2.3.3 Implementação do TAD Fila ........................................................................................................... 59 

3. LISTAS E ÁRVORES................................................................................................................................ 65 

3.1 LISTAS CIRCULARES............................................................................................................................. 65 

3.2 LISTA CIRCULAR DUPLAMENTE ENCADEADA ....................................................................................... 75 

3.3 ÁRVORES BINÁRIAS.............................................................................................................................. 82 

3.3.1 Árvore Binária de Pesquisa............................................................................................................. 83 

3.3.2 O TAD Árvore Binária de Pesquisa ................................................................................................84 

3.3.3 Implementação do TAD árvore Binária de Pesquisa ...................................................................... 85 

4. PESQUISA EM MEMÓRIA PRIMÁRIA................................................................................................ 99 

4.1 PESQUISA SEQÜENCIAL...................................................................................................................... 101 

4.1.1 Implementação da Pesquisa Seqüencial........................................................................................ 102 

4.1.2 Tempo de execução de algoritmos.................................................................................................103 

4.2 PESQUISA BINÁRIA ............................................................................................................................. 106 

4.3 TABELAS HASH................................................................................................................................... 108 

4.3.1 Operações de Inserção e Pesquisa em Tabelas Hash.................................................................... 111 

4.3.2 Tratamento de Colisões................................................................................................................. 114 

4.3.3 Tratamento de Colisão usando endereçamento Aberto................................................................. 116 

5. ORDENAÇÃO EM MEMÓRIA PRIMÁRIA. ...................................................................................... 118 

5.1 CONCEITOS BÁSICOS DE ORDENAÇÃO ................................................................................................ 118 

5.1.1 Operações Típicas de processos de Ordenação ............................................................................ 119 

5.2 MÉTODOS DE ORDENAÇÃO................................................................................................................. 119 

5.2.1 Ordenação por Seleção ................................................................................................................. 120 

5.2.2 Método da Inserção....................................................................................................................... 121 

5.2.3 Método da Bolha ........................................................................................................................... 123 

5.2.4 Desempenho dos métodos de Seleção, Inserção e Bolha............................................................... 124 

5.2.5 Método de Shell ............................................................................................................................. 124 

5.2.6 O Método Quicksort ...................................................................................................................... 128

Olá! 

Meu nome é Mateus Barcellos Costa, sou professor 

e pesquisador do CEFET-ES desde 2005. Atuo na 

área de Engenharia de Software e sou professor de 

disciplinas de Programação. Se você quiser mais 

informações sobre mim e sobre os trabalhos que 

desenvolvo, pode visitar minha página pessoal em 

http://www.sr.cefetes.br/~mcosta. 

Produzi o material que ora lhe apresento como 

instrumento básico para o estudo da disciplina de 

Técnicas de Programação Avançada. Nesta 

disciplina iremos aprofundar nossos 

conhecimentos em Programação de 

Computadores usando uma linguagem imperativa 

ou procedimental. Exemplos destas linguagens 

são C e Pascal. Como de costume no nosso 

Curso, iremos adotar a linguagem C, em nossos 

exemplos e implementações. No entanto, é 

preciso que você saiba que os conceitos estudados 

aqui vão além da linguagem e podem ser 

aplicados em diversos cenários, na programação 

e na Engenharia de Software como um todo.

1. ABSTRAÇÃO DE DADOS. 

Olá! Neste Capítulo iremos discutir e aprender 

sobre Abstração de Dados. Abstração de Dados é 

uma técnica de programação que visa simplificar 

o desenvolvimento de programas. Sua aplicação 

pode se dar no desenvolvimento de programas 

menores. Mas podemos afirmar que seria 

impossível o desenvolvimento de sistemas que 

temos hoje, com milhões de linhas de código, 

sem o uso de abstração de dados. 

1.1 INTRODUÇÃO 

Um programa de computador desenvolvido para atender alguma 

finalidade prática é, normalmente, um artefato complexo. Por esse 

motivo, a atividade de desenvolvimento desses artefatos, a 

programação de computadores, está entre as atividades mais 

complexas desempenhadas pelo homem. Se você cursou disciplinas 

introdutórias de programação, pode estar se questionando: Ora, 

desenvolver um programa não é tão complexo assim! Basta 

compreender o problema, suas entradas e suas saídas e construir a 

solução usando uma linguagem de programação. Simples não? Não! 

A história da programação tem dado provas que programar não é tão 

simples assim. 

Figura 1: O Gap Semântico. 

Programar é uma atividade complexa por diversos aspectos, tanto de 

cunho teórico quanto prático. Dentre estes aspectos destacamos os 

seguintes: 

1. Programar um computador significa desenvolver programas de 

computadores (formais e precisos) para atender a finalidades 

Centro Federal de Educação Tecnológica do Espírito Santo 

Técnicas de Programação Avançada 

Página 9


Página 10 

práticas definidas em termos de conceitos do mundo real 

(informais e imprecisos). Existe um abismo entre o mundo 

dos problemas reais e o mundo das soluções. Esse abismo é 

chamado na computação de gap semântico. Transpor o abismo 

é um dos desafios centrais da programação de computadores e 

da Engenharia de Software como um todo. A Figura 1 é uma 

alegoria que busca mostrar a função do desenvolvedor de 

software: Transpor o abismo entre o mundo informal (dos 

problemas) e o mundo formal (das soluções computacionais). 

Nessa transposição existem muitos desafios e perigos que 

podem dificultar a trajetória do desenvolvedor. 

2. Muitas vezes, em disciplinas iniciais de programação, 

deparamo-nos com o desenvolvimento de programas mais 

simples, de cunho didático. Por exemplo, programas para 

calcular médias ou somatórios. Em outros momentos fazemos 

programas para aprender a usar um certo mecanismo, por 

exemplo, apontadores. Aqui, estamos nos referindo a 

programas de computadores para ajudar pessoas a resolverem 

problemas do mundo real, problemas grandes e complexos! 

Exemplos desses problemas incluem: 

a. Gerenciar as operações financeiras de uma empresa; 

b. Controlar uma aeronave; 

c. Controlar os trens de uma malha ferroviária; 

d. Produzir edições diárias de um jornal; 

e. Gerenciar o processo de produção de um filme. 

3. Problemas como esses não são simples de se resolver. 

Conseqüentemente, programas voltados para essas finalidades 

são complexos, levam muito tempo para ficar prontos, têm de 

ser desenvolvidos por uma equipe de pessoas, utilizando 

diversas tecnologias e seguindo um processo de 

desenvolvimento sistemático. 

4. Para atender às funcionalidades esperadas, um programa deve 

apresentar um conjunto de características que juntas vão 

tornar o programa efetivamente útil e determinarão a 

qualidade do mesmo. Essas características são as seguintes: 

a. Um programa deve estar correto, livre de erros; 

b. Um programa deve ser robusto. Um programa robusto 

ou sistema robusto é aquele que consegue funcionar, 

mesmo que precariamente, diante de uma adversidade. 

Por exemplo, suponha que um programa precise dos 

dados x, y e z para realizar uma tarefa. Se este for 

robusto, na falta de um dos dados, o programa pode 

Centro Federal de Educação Tecnológica do Espírito Santo

tentar realizar o processamento possível com a 

ausência dado; 

c. Um programa deve ser eficiente. A eficiência de um 

programa está relacionada ao seu tempo de execução 

(eficiência na execução) ou ao espaço em memória 

(eficiência na ocupação) de que necessita para executar 

(área de dados). Para um problema há infinitas 

soluções (programas). Quanto menores esses valores 

mais eficiente o programa. Em computação pode-se 

verificar se uma solução é ótima (mais eficiente 

possível) para um problema; 

d. Um programa deve ser compatível com outros 

programas; 

e. Um programa deve ser fácil de usar; 

f. Um programa deve ser portável, podendo funcionar em 

diferentes plataformas ou sistemas operacionais; 

g. Um programa deve ser íntegro, ou seja, deve evitar que 

os dados sejam corrompidos ou violados; 

h. O processamento realizado pelo programa deve ser 

verificável; 

i. O programa ou partes dele devem poder ser utilizados 

em outros cenários diferentes daquele para o qual o 

programa foi originalmente desenvolvido. 

5. Por último, devemos considerar a atividade de programação 

como atividade econômica. Assim como outras atividades 

econômicas, o desenvolvimento de software é regido por leis 

de mercado que impõem severas exigências aos 

desenvolvedores. De acordo com essas leis, não basta apenas 

desenvolver um programa que atenda à finalidade esperada. 

Esses programas devem ser desenvolvidos dentro dos prazos e 

custos estabelecidos. Além disso, o programa precisa ter 

outras características importantes que permitam a sua 

evolução. Essas características são chamadas de fatores 

internos. São eles: 

a. Facilidade de manutenção; 

b. Facilidade de evolução; 

c. Facilidade de entendimento; 

d. Modularidade. 

Pelos motivos discutidos acima, o desenvolvimento de programas 

requer a aplicação de princípios, métodos e técnicas que diminuam a 

complexidade desse desenvolvimento. A Abstração de Dados envolve 



Página 11


Página 12 

uma série de conceitos e princípios para esse fim. A seguir 

discutiremos esses conceitos. 

Atividades 

Nesta introdução foram levantados cinco aspectos que 

tornam o desenvolvimento de software uma tarefa 

difícil. Para atacar esses aspectos e tornar o 

desenvolvimento de software mais simples são 

consideradas três dimensões: Processo de 

desenvolvimento, Pessoas (partes interessadas: 

clientes, desenvolvedores) e Tecnologias de 

desenvolvimento. Releia os cinco motivos e tente 

escrever um texto resumido, estabelecendo uma 

relação entre esses 5 motivos e essas três dimensões. 

1.2 CONCEITOS DE ABSTRAÇÃO DE DADOS 

1.2.1 Abstração em Computação 

A abstração é um dos conceitos mais importantes da computação. 

Sem o uso deste conceito podemos afirmar que a evolução 

apresentada pela computação teria sido mais lenta. 

Segundo o dicionário Michaelis, temos a seguinte definição para a 

palavra Abstração: 

1. O ato ou efeito de abstrair. Consideração das qualidades 

independentemente dos objetos a que pertencem. Abstrair: Considerar 

um dos caracteres de um objeto separadamente; 2. Excluir, prescindir 

de. 

A finalidade principal de uso de abstração em qualquer área do 

conhecimento é colocarmos foco em um sub-conjunto dos aspectos 

de um sistema ou processo complexo. Considere, por exemplo, o 

processo de pintar um quadro. A Figura 2 mostra, à esquerda um 

esquema inicial mostrando as linhas principais do quadro que se 

encontra do lado direito (A Virgem, o Menino e Sant’Ana, Leonardo 

Da Vinci). 


Figura 2: Abstração na Pintura. 

Observe que, no desenho, as proporções, os detalhes das posturas e 

feições são já determinados. Esse processo ajuda o pintor, pois, no 

momento da idealização do quadro, ele não precisa se preocupar com 

outros aspectos complexos, como cores, nuances de sombras e 

reflexos, para definir a estrutura e a sua aparência geral. Podemos 

dizer então que o desenho à esquerda é uma abstração do quadro. 

Em computação, abstração também possui finalidades semelhantes. 

Em programação, especificamente, esse conceito está presente quase o 

tempo todo, seja nas construções existentes nas linguagens, seja nos 

métodos de programação empregados. 

Uma das principais abstrações das linguagens de programação é o 

conceito de variável. Uma variável é um conceito abstrato que 

esconde diversos aspectos técnicos que não interessam ao 

programador. Quando declaramos uma variável em um programa, essa 

declaração implica em “coisas” que não irão interferir no seu 

desenvolvimento. Por exemplo, por trás de uma variável do tipo 

inteiro em C, (ex. int x;), estão “escondidas” as características físicas 

do armazenamento da variável em memória, a saber: 

- A forma de representação de números inteiros usando base 2 

(por exemplo, complemento de 2); 

- O padrão usado pelo hardware (ex. little endian, big endian); 

- O número de bytes que uma variável do tipo inteiro ocupa; 

- O endereço da variável na memória principal; 

- O conjunto de bits responsável por armazenar o sinal do 

número inteiro. 

Para o programador em C, geralmente, nenhuma dessas 

informações é importante. O que o programador deseja é utilizar a 

variável realizando as operações permitidas aos números inteiros 

(operações aritméticas e comparações), atribuir, recuperar e 

modificar o valor contido na variável. 



Página 13


Página 14 

Assim podemos dizer que uma variável permite ao programador 

abstrair-se de detalhes que não interessam e não irão influenciar no 

comportamento do programa. 


Os itens 1,2 e 3 são abstrações. Para cada um deles 

descreva os aspectos que estão sendo escondidos e 

os aspectos que realmente importam ao 

programador: 

1. O comando 

2. Um arquivo 

3. A função scanf 

1.2.2 Abstração de Procedimentos 

Podemos afirmar que a grande maioria dos elementos de linguagem 

utilizados em uma linguagem de programação de alto nível são 

abstrações. Essas abstrações facilitaram o desenvolvimento de 

programas mais complexos e sofisticados, evitando que 

programadores precisassem manipular bits e endereços de memória e 

interagir diretamente com o sistema operacional. 

Uma outra abstração de programação importante é a Abstração de 

Procedimento. 

Abstração de Procedimento 

A abstração de procedimento permite que o programador 

crie, ele mesmo, sua “forma de abstrair”, utilizando 

os comandos disponíveis na linguagem. A possibilidade 

de criar procedimentos permite ao programador criar 

funcionalidades mais abstratas que “escondem” a 

sequencia de operações necessária para a realização de 

uma tarefa complexa. 


Por exemplo, sabemos que na linguagem C não existe um comando 

que seja capaz de ordenar um vetor de inteiros em ordem crescente. 

Seria muito bom que pudéssemos contar com esse comando, certo? 

Mas, como não temos esse comando, iremos criar uma função 

(abstração de procedimento) que realize essa tarefa para nós. A função 

ordena na Figura 3 é essa abstração. 

Figura 3: Função ordena: Cria uma abstração do procedimento de ordenação. 

Após a implementação da função ordena, quando o programador 

precisar ordenar um vetor, basta que ele invoque a função, passando 

os parâmetros necessários. Ou seja, ao usar o procedimento, o 

programador irá se preocupar apenas com o que a função faz e não 

mais com os detalhes de sua implementação. 

Uma abstração de procedimento deve realizar uma tarefa (por 

exemplo, ordenar um vetor de inteiros) que deve ser independente da 

forma como este vai ser implementado. O programador deve antes de 

tudo ver o procedimento como uma caixa preta, cuja especificação 

deve conter três elementos básicos (Figura 4): 

Entrada: O conjunto de dados de entrada necessário; 

Saída: O conjunto de dados produzido pelo procedimento; 

Função: A descrição do que o procedimento faz. 

ENTRADA SAÍDA 

FUNÇÃO 

Figura 4: Os elementos considerados na definição de um procedimento. 

Na especificação do procedimento, o programador não deve estar 

preocupado com a implementação, mas sim com o comportamento 

(função) do mesmo. Qualquer implementação que realize a função 

especificada irá servir como solução. Para o caso da ordenação, 

veremos adiante neste curso que existem diferentes métodos de 

ordenar um vetor. O método utilizado na função ordena se chama 

ordenação por inserção. A implementação interna poderia ser 



Página 15


Página 16 

substituída por qualquer outro método de ordenação. A própria 

linguagem C oferece em sua biblioteca padrão stdlib, uma função 

chamada qsort, que pode ser usada para ordenar vetores. Essa 

função utiliza um outro método de ordenação muito conhecido e 

também muito rápido, chamado de Quick Sort. 


1. Suponha que você tenha disponíveis as 

seguintes funções em C: 

Int CalculaMedia(int *notas); 

Void 

DeterminaMaiorEMenorNotas(int 

*v, int * maior, int *menor); 

Void leNotas(int *notas); 

Void MostraResultados(int 

media,int 

menorNota); 

maiorNota, int 

Utilizando essas funções, desenvolva um programa em 

C que leia as notas de 5 turmas e para cada uma delas, 

imprima a média, a maior e a menor nota. 

1.2.3 Tipos Abstratos de Dados 

A abstração de dados visa aos mesmos objetivos que a abstração de 

procedimentos, mas com relação às estruturas de dados utilizadas nos 

programas. A abstração de dados visa criar novos tipos de dados 

definidos em temos de seu comportamento. Esses novos tipos são 

chamados de Tipos Abstratos de Dados - TAD. 

É muito importante que você perceba que um tipo abstrato de dados 

não se resume a uma nova estrutura de dados. Vamos então discutir 

um pouco sobre essa diferença. 

Primeiramente, uma estrutura de dados pode ser definida 

simplesmente como uma variável capaz de armazenar mais de um 

valor simultaneamente. Assim, um vetor, uma matriz ou um registro 

(struct em C) são exemplos de estruturas de dados. A combinação 

desses elementos em estruturas mais complexas dá origem a outras 

estruturas de dados. A Figura 5 apresenta as declarações de struct 

ponto e struct reta, como exemplos de tipos de estruturas 

de dado. 


Figura 5: Estruturas de Dados ponto e reta. 

Ao definir a struct ponto, passamos a contar com mais uma 

alternativa para definição de tipos de variáveis e, conseqüentemente, 

para a composição de novos tipos de estruturas. Assim a struct 

reta foi definida como uma composição de duas variáveis do tipo 

struct ponto. Essas estruturas podem ser usadas para declarar 

tanto variáveis como argumentos de funções. 

Em C temos ainda a cláusula typedef, que permite definir o nome 

do novo tipo. Nesse caso, não precisamos usar a palavra reservada 

struct na declaração de variáveis do tipo definido. Na Figura 6 

temos o uso de typedef. Veja que na definição do tipo Reta, o 

nome Ponto é usado sem a palavra reservada struct. 

Figura 6: Definição dos tipos Reta e Ponto. 

Estrutura de Dados versus Tipo Abstrato de Dados 

A definição de uma estrutura de dados se preocupa em 

demonstrar como o objeto é representado na memória 

de um computador (representação). Nessa definição são 

considerados aspectos do tipo: quais as informações que 

serão armazenadas ali e qual a quantidade destas 

informações. A definição de um Tipo Abstrato de 

Dados segue uma abordagem diferente. Essa definição é 

feita em termos das operações que podem ser realizadas 

sobre o tipo. 

A definição de um Tipo Abstrato de Dado (TAD) é 

chamada de especificação e consiste, basicamente, em 

definir as operações relacionadas ao tipo. Dizemos que 

essas operações definem o comportamento do TAD. 



Página 17


Página 18 

Vamos aplicar o conceito de TAD considerando os objetos Reta e 

Ponto. Um passo importante na definição do TAD, que já ajuda na 

programação de uma maneira geral, é que não conseguimos defini-lo 

sem conhecermos a sua finalidade e o contexto no qual será usado. 

Em nosso exemplo precisamos saber para quê nós queremos um 

ponto e uma reta. Geralmente essa informação é conseguida a partir 

do enunciado do problema. Assim, vamos supor a seguinte descrição 

para o nosso problema envolvendo retas e pontos: 

Problema A. É necessário um programa de computador que realize 

operações geométricas envolvendo pontos e retas localizadas no 

plano cartesiano. O programa deve permitir: calcular a distância do 

ponto até a origem do plano cartesiano; calcular a distância entre 

dois pontos; dada a representação da reta por dois pontos, calcular o 

ângulo de inclinação da reta, fornecer os parâmetros a e b 

correspondentes a equação da reta ax + b. Determinar a distância de 

uma reta a um ponto. Evidentemente, o programa deve permitir a 

leitura e impressão de pontos e retas conforme a necessidade das 

operações. 

Com base na descrição acima podemos identificar a necessidade do 

TAD ponto e do TAD Reta, bem como suas operações. Essas 

operações aparecem sublinhadas no texto do problema e são 

apresentadas nas Figuras 7 e 8. 

Figura 7: operações do TAD Ponto para o problema A. 

Figura 8: operações do TAD Reta para o problema A. 


Agora, considere que estejamos desenvolvendo um programa para o 

problema abaixo: 

Problema B. É necessário um programa de computador para 

apresentar graficamente figuras geométricas formadas por pontos e 

retas, usando o monitor do computador como plano. O programa 

deve permitir: ler um ponto, plotar um ponto na tela, ligar dois pontos 

por um segmento de reta; dada uma reta passando por esse ponto, 

deslocar um outro ponto com base na equação dessa reta; dada uma 

reta representada por dois pontos, plotar esta reta no monitor; dada 

uma reta e um valor d, criar uma reta paralela à reta dada a uma 

distancia d da reta. 

As operações necessárias aos TAD Ponto e Reta neste problema são 

apresentadas nas Figuras 9 e 10. 

Figura 9: operações do TAD Ponto para o problema B. 

Figura 10: operações do TAD Reta para o problema B. 

Note que nos dois problemas foram definidos os tipos 

Ponto e Reta. No entanto, a abstração necessária difere 

de um problema para o outro, interferindo na definição 

das operações. Embora existam essas diferenças, iremos 

sempre tentar criar abstrações mais genéricas o quanto 

for possível. Quanto mais genérico um TAD, maior o 

número de problemas em que esse poderá ser aplicado. 



Página 19


Página 20 

Embora as operações não informem nada a respeito da 

representação interna de um TAD, elas fornecem ao 

programador tudo o que ele precisa para manipular o 

TAD. As operações de um TAD especificam a sua 

interface com o restante do programa. Isso significa que 

qualquer ação relacionada ao TAD deve ser feita 

mediante uma de suas operações. 

Temos como resultado prático que o programador, ao 

usar o TAD, não vai precisar se preocupar com sua implementação 

interna. Iremos agora analisar esse aspecto 

considerando os TAD Ponto e Reta e o problema A. 

Na implementação, ponto e reta foram definidos e implementados, 

originando dois módulos independentes: o módulo Ponto e o módulo 

Reta. Cada módulo em C é normalmente implementado por dois 

arquivos: o arquivo .h e o arquivo .c. No arquivo .c teremos a 

implementação das operações do TAD e no arquivo .h teremos a 

especificação da interface do TAD. A Figura 11 e a Figura 12 

apresentam as interfaces dos módulos Ponto e Reta, respectivamente. 

Figura 11: Interface do TAD Ponto. 

Figura 12: Interface do TAD Reta. 

Com a implementação dos TADs Ponto e Reta concluídas e 

devidamente testadas, qualquer outro módulo do programa poderá 

utilizar esses tipos por meio das operações definidas para os mesmos. 

Quando um módulo A utiliza um módulo B em programação, 

dizemos que o módulo A é cliente do módulo B. Essa relação de 

“clientela” entre os módulos (ou TADs) de um programa pode ser 

representada graficamente por meio de um diagrama de estrutura 

modular - DEM. 


Diagrama de Estrutura Modular 

Um diagrama de estrutura modular é formado por 

retângulos e linhas direcionadas relacionando os 

retângulos. Cada retângulo representa um módulo. As 

linhas direcionadas significam “cliente de” e indicam o 

acionamento de operações contidas no módulo apontado 

pelo módulo cliente. Esses digramas também são 

chamados diagramas hierárquicos, pois apresentam a 

hierarquia dos módulos, iniciando por um módulo que 

inicia o programa e acionam os demais módulos. 

Como exemplo, suponha que tenhamos também, junto aos módulos 

Ponto e Reta, um módulo chamado principal. Esse módulo é cliente 

dos módulos Ponto e Reta. A Figura 13 a seguir ilustra o DEM deste 

programa. O módulo que inicia o programa é o módulo principal (e 

deve conter uma função main()). Ele aciona as operações tanto do 

módulo ponto quanto do módulo reta. Reta, por sua vez, também é 

cliente do módulo ponto. 

Figura 13: DEM com módulos Ponto, Reta e Principal. 

A Figura 14 ilustra a implementação de um módulo Principal. Note 

que a única forma de acesso aos TADs Ponto e Reta é por meio das 

operações definidas em suas respectivas interfaces. 

Use diagramas de estrutura modular sempre que for 

iniciar um novo projeto. Defina os TADs e estabeleça o 

relacionamento entre eles por meio de DEMs. Junto às 

linhas, você pode especificar as operações do TAD que 

são acionadas pelo cliente. Isso vai ajudar você na 

especificação dos TADs. 



Página 21


Página 22 


Implementar as operações do TadPonto e do TadReta 

considerando o enunciado do problema 1, da Seção 1.2.3 

do texto, e desenvolver um programa usando a função 

principal (do quadro a seguir) de forma a testar as 

operações. 

Figura 14: Módulo Principal para o Problema A. 


Até o momento, em nosso exemplo envolvendo Ponto e 

Reta, não abordamos a questão de como as operações 

serão implementadas propositalmente. É que até a 

parte que apresentamos do desenvolvimento não 

precisamos saber mesmo. Você por acaso lembra como 

se calcula a distância entre dois pontos? E a distância 

entre uma reta e um ponto? Pois bem, o importante é 

que você tenha compreendido a discussão feita e o 

exemplo dado, mesmo sem saber responder essas duas 

perguntas. Assim espero! 

1.2.4 Implementação de Tipos Abstratos de Dados 

Um dos principais benefícios da abstração de dados é 

separar o comportamento do TAD, especificado por 

meio da definição de suas operações, da sua 

implementação. Em nosso exemplo, o que definimos a 

respeito dos TAD Ponto e Reta foi o seu 

comportamento, as suas operações. Nesta seção, 

discutiremos melhor como separar em um projeto a 

definição do comportamento e da implementação de um 

TAD. 

O projeto completo de um TAD consiste de dois passos: 

1. Especificação - Consiste na especificação do comportamento 

do TAD; 

2. Implementação – Implementação das operações e estruturas 

de dados. 

Especificação 

A especificação de um TAD descreve o que TAD faz, mas omite 

informações sobre como o mesmo é implementado. Por omitir 

detalhes de implementação, uma única especificação permite muitas 

implementações diferentes. 

A especificação é feita por meio da definição das operações do TAD. 

Para detalhar melhor cada uma destas operações, devemos estabelecer, 

para cada operação, dois elementos: 

- Pré-condições: definem as condições necessárias para que a 

operação possa ser realizada. Por exemplo, suponha que 

desejamos especificar o TAD Conjunto com a operação 

listarConjunto. Uma pré-condição para essa operação é 

que o Conjunto não esteja vazio. 



Página 23


Página 24 

- Pós-condições: definem o estado do TAD após a execução da 

operação. Por exemplo, suponha a operação 

inserirElemento no TAD conjunto. Uma pós-condição 

para essa operação seria: elementos no conjunto = elementos 

no conjunto + novo elemento. A Figura 15 ilustra a definição 

do TAD conjunto. 

Figura 15: Especificação do TAD Conjunto. 

Implementação 

Um TAD é implementado por um módulo de um programa. Uma 

única especificação permite diferentes implementações para um 

mesmo TAD. Uma implementação está correta se esta provê o 

comportamento especificado para o TAD. Implementações corretas 

podem diferir uma da outra, por exemplo, em termos do algoritmo ou 

da estrutura de dados que elas usam. Essas diferenças interferem na 

eficiência (desempenho em tempo de execução, ou ocupação de 

espaço) apresentado pelo TAD para realização das operações. 

Encapsulamento 

Para uma abstração funcionar corretamente, a sua 

implementação deve ser encapsulada. Se a 

implementação for encapsulada, nenhum outro módulo 

do programa vai depender de detalhes de 

implementação do TAD. Encapsulamento garante que 

módulos do programa podem ser implementados e reimplementados 

independentemente, sem afetar os outros 

módulos do programa. 

O encapsulamento geralmente é conseguido por meio da separação da 

interface e da implementação do módulo. Conforme já vimos 

anteriormente, em C a implementação de um TAD por meio de um 

módulo consiste em duas partes: a especificação da interface do 


módulo por meio do arquivo header (com extensão.h) e da implementação 

das operações por meio de um arquivo com extensão .c. 

1.2.5 Avaliação de Implementações de Tipos Abstratos de 

Dados 

É fundamental para um programador saber criticar e 

avaliar a qualidade de uma implementação! Uma 

implementação baseada em Abstração de Dados é um 

indicativo de boa qualidade. Nesta Seção, discutiremos 

elementos que permitem que você verifique se uma 

implementação realmente está de acordo com essa 

técnica. 

Embora a linguagem C não ofereça um mecanismo que impeça 

realmente que o programador tenha acesso à estrutura interna do TAD, 

esta é uma regra fundamental e deve ser respeitada pelo programador. 

Esta regra ou característica de TADs é o encapsulamento, discutido na 

seção anterior. Dizemos que um TAD é encapsulado por suas 

operações no sentido de que a estrutura interna do TAD fica 

preservada e invisível ao restante do programa. Violar essa regra 

significa não usar corretamente a Abstração de Dados. 

Localidade 

O maior benefício do encapsulamento chama-se 

princípio da Localidade. Esse princípio permite que um 

programa seja implementado, entendido e modificado 

um módulo de cada vez. A localidade aumenta a 

qualidade do software que está sendo desenvolvido. 

Dentre os benefícios oriundos do princípio da localidade temos: 

1. O programador de uma abstração sabe o que é necessário pelo 

que está descrito na especificação. Dessa forma, ele não 

precisa interagir com programadores de outros módulos (ou, 

pelo menos, essa interação vai ser bem limitada). 

2. De forma análoga, o programador de um módulo que usa a 

abstração sabe o que esperar desta abstração, apenas pelo 

comportamento descrito em sua especificação. 



Página 25


Página 26 

Uma ferramenta que pode contribuir para esse 

entendimento é a documentação do TAD. Ou seja, a 

explicação sobre o seu funcionamento e sobre como 

utilizá-lo. Procure sempre fazer uma boa documentação 

do TAD. Essa documentação pode vir como um 

documento à parte que acompanha o módulo. 

3. É necessário apenas o raciocínio local (por módulo), para saber 

o que o programa faz e se está fazendo a coisa certa. Para 

estudar e compreender o programa podemos dividi-lo em 

módulos, e analisar um módulo de cada vez. Em cada caso, 

preocupamo-nos em saber se o módulo faz o que é suposto que 

faça. Ou seja, se ele cumpre o que está na especificação. 

Pode-se assim limitar a atenção para um módulo, ignorando 

tanto os módulos usados por este quanto os que o utilizam. Os 

módulos que utilizam o módulo estudado podem ser ignorados 

porque dependem apenas de sua especificação e não da sua 

implementação. Os módulos utilizados são ignorados, 

raciocinando-se sobre o que eles fazem utilizando apenas sua 

especificação em vez de sua codificação. Com isso, tem-se 

uma grande economia de esforço, dado que as especificações 

são muito menores que as implementações. Observando-se 

apenas as especificações evita-se também um efeito cascata. 

Por exemplo, se tivermos que olhar o código do módulo que 

utilizamos, teremos que olhar também o código dos módulos 

que são utilizados pelos módulos que utilizamos e assim por 

diante. 

4. Finalmente, a modificação do programa pode ser feita módulo 

por módulo. Se uma abstração particular necessita ser 

reimplementada para prover um melhor desempenho, corrigir 

um erro ou prover uma nova funcionalidade, o módulo 

implementado anteriormente pode ser trocado por uma nova 

implementação sem afetar os outros módulos. 

Prototipagem 

Localidade também provê uma base firme para a 

prototipação ou prototipagem. Um protótipo é uma 

implementação inicial, rudimentar e incompleta de 

um programa a ser desenvolvido. Se mantivermos o 

princípio da localidade no desenvolvimento do 

protótipo, essa implementação inicial pode ir sendo 

completada ou substituída por implementações 

melhores sem grande esforço nem re-trabalho. 


Localidade também provê suporte para evolução. Abstrações 

podem ser utilizadas nesse caso para encapsular modificações 

potenciais no programa. Por exemplo, suponha que desejamos um 

programa para ser executado em diferentes máquinas. Podemos 

tratar esse problema inventando abstrações que escondam as 

diferenças entre as máquinas de forma que, para mover o 

programa para uma máquina diferente, apenas essas abstrações 

precisem ser reimplementadas. Um bom princípio de projeto é 

pensar sobre modificações esperadas e organizar o 

desenvolvimento utilizando abstrações que encapsulem as 

mudanças. 

Domínio da complexidade 

Os benefícios da localidade são particularmente 

importantes para a abstração de dados. Estruturas de 

dados são muitas vezes complicadas e a visão mais 

abstrata mais simples provida pela especificação torna o 

resto do programa mais simples. Ainda, mudanças nas 

estruturas de armazenamento são uma das principais 

formas de evolução de programas. Portanto, os efeitos 

dessas mudanças devem ser minimizados encapsulando 

essas estruturas de dados em abstrações de dados. 

Se avaliarmos um programa segundo o critério da abstração de 

dados, devemos observar os seguintes fatores: 

1. Os TADs estão realmente encapsulados? 

a. O entendimento de cada módulo do programa 

independe dos demais módulos? 

b. O efeito cascata é evitado na depuração? 

c. É possível reimplementar um módulo sem afetar os 

outros? 

2. Potenciais mudanças foram previstas no projeto do TAD? 

3. Os TADs oferecem abstrações suficientemente simples das 

estruturas de dados que encapsulam? 


Os códigos a seguir especificam as interfaces de dois 

módulos: Aluno e Turma. 



Página 27


Página 28 

/******** aluno.h ***********/ 

typedef struct aluno{ 

char nome[30]; 

int matricula; 

int cdgcurso; 

} Aluno; 

void leAluno(Aluno *); 

void imprimeAluno(Aluno); 

void AlteraAluno(Aluno *); 

/******** turma.h **********/ 

#include "aluno.h" 

#define MAXTURMA 100 

typedef struct turma { 

int nalunos; 

Aluno alunos[MAXTURMA]; 

}Turma; 

void insereAluno(Turma *,Aluno); /*insere o 

aluno passado como paramentro na turma */ 

void localizaAluno(Turma *, char *); /* 

localiza um aluno na turma pelo nome */ 

void imprimeTurma(Turma); 

void atualizaAlunoDaTurma(Turma *, char *); 

Agora, suponha que tenhamos o seguinte módulo principal, 

utilizando esses módulos: 

/************ Modulo Principal 

**************/ 

#include "turma.h" 

Turma turma1; 

void principal(){ 

int opcao,i; 

aluno a; 


do{ 

scanf("%d",&opcao); 

switch(opcao){ 

case 1: /* cadastrar aluno */ 

lealuno(&a); 

insereAluno(&turma1,a); 

break; 

case 2: 

scanf("%s",nome); 

a= localizaAluno(&turma1, nome); 

printf("%s - %d - %d",a.nome, 

a.matricula,a.cdgcurso); 

break; 

case 3: /* imprimir turma */ 

for (i=0;i

nome); 

} 

} 

scanf("%s",nome); 

atualizaAlunoDaTurma(&turma1, 

break; 

Tarefas: 

a) Critique a implementação do módulo acima com 

base nos critérios de avaliação de TADs discutidos 

acima. 

b) Faça uma implementação da operação 

atualizaAlunoDaTurma, respeitando os princípios de 

programação baseada em tipos abstratos de dados. 

Dijkstra (1930-2002) foi, sem dúvida, um dos 

cientistas que mais contribuíram para o 

desenvolvimento da Programação de Computadores. 

Terminamos este capítulo com uma frase dele, que 

resume o conceito de abstração: 

“O propósito da abstração não é ser vaga, mas sim, 

criar um novo nível semântico no qual ela possa ser 

absolutamente precisa”. 

Edsger. W. Dijkstra, The Humble Programmer (O 

programador Mediocre), Communications of the 

ACM, 15(10), 1972. 

Reflita sobre isso! 



Página 29


Página 30 

2. TIPOS ABSTRATOS DE DADOS 

FUNDAMENTAIS. 

Olá! Após o estudo e a compreensão dos conceitos 

que definem a técnica de Abstração de 

Dados, utilizaremos esses conceitos em nosso estudo 

até o final da disciplina. Portanto, se você não 

compreendeu ou não se sente ainda plenamente 

convencido de que deve utilzar Abstração de 

Dados em seus programas, recomendo que retorne 

ao Capítulo 2. O motivo disso é muito simples. 

Daqui para frente estudaremos problemas e soluções 

mais complexos, que exigem muito do estudante 

em sua capacidade de abstração. Neste 

Capítulo, em particular, iniciamos nosso estudo de 

um conjunto de TADs muito comuns e 

importantes: Os TAD Pilha e Fila. 

No decorrer da evolução da programação, padrões e práticas comuns 

têm sido observadas e transformadas em conceitos, modelos e mecanismos 

que podem ser utilizados em mais de uma situação diferente. 

Dentre esses elementos temos uma coleção de tipos abstratos de dados 

que são comuns a diversas situações e aplicáveis na solução de uma 

grande quantidade de problemas. Dois desses TADs são as Pilhas e as 

Filas, que estudaremos em profundidade neste capítulo. 

2.1 PILHAS 

No mundo real uma pilha corresponde a um agregado de objetos que 

são acomodados um sobre o outro. A Figura 1 ilustra uma pilha em 

que os objetos são caixas. 


Figura 1: Uma Pilha de Caixas 

Os números nas caixas indicam a ordem de empilhamento. Se 

quisermos agora remover as caixas da pilha (desempilhar), temos que 

remover a caixa 4 primeiro, depois a 3, a 2 e finalmente a 1. Não 

podemos remover as caixas abaixo da que está no topo da pilha sem 

antes remover a do topo. Esse comportamento pode ser definido pela 

estilo: O último a entrar é o primeiro a sair. 

No mundo real temos diversas situações em que esse comportamento 

deve ser respeitado. Assim, o uso de pilhas pode facilitar a solução 

de vários problemas. Um exemplo típico de uso de pilha é a 

operação desfazer, presente na maior parte dos editores de texto. 

Quando voce executa a operação desfazer, a última operação 

realizada é que deverá ser desfeita primeiro. Se você executar o 

desfazer novamente, a penúltima operação deverá ser desfeita, e assim 

sucessivamente. Concluindo, precisamos ter sempre a informação de 

qual foi a última operação realizada. Uma pilha é uma forma eficiente 

de obtermos esa informação. Se tivermos uma pilha em que 

empilhamos a operação que foi feita, teremos no topo da pilha sempre 

a operação que devemos desfazer. 

Realmente, editores texto que possuem a operação desfazer mantém 

uma pilha que guarda informações sobre as ações que vão sendo 

realizadas durante a edição. Por exemplo, no momento em que este 

texto era digitado, as informações passadas via teclado e mouse eram 

também empilhadas. 



Página 31


Página 32 

A aplicação de pilhas em editores de texto é um 

exemplo de uma funcionalidade muito comum de uso de 

pilha. Essa funcionalidade está presente em outros 

cenários, como em jogos, programas de logistica, 

robótica e redes de computadores. O que esses cenários 

têm em comum é a necessidade de retroceder por um 

caminho de dados ou ações que tenha realizado. Esse 

retocesso se dá também em algoritmos de backtracking, 

(algo como voltar na trilha) e é muito comum em 

algoritmos de busca e recuperação de informação. Veja 

a discussão sobre esses algoritmos em 

http://pt.wikipedia.org/wiki/Backtracking. 

2.1.1 Especificação do TAD Pilha 

O TAD Pilha pode ser descrito pela seguinte especificação 

apresentada na Figura 2. Nessa especificação são definidas as 

operações Empilha, que insere elementos na Pilha e Desempilha, que 

remove elementos da Pilha. São definidas também as pré-condições e 

pós-condições dessas operações. 

Figura 2: especificação do TAD Pilha. 

Além das operações empilha e desempilha, temos também a operação 

inicializaPilha, que coloca a Pilha em um estado inicial, com a pilha 

vazia. A Figura 3 ilustra uma possível implementação do TAD Pilha 

limitado a 5 (cinco) posições. Cada posição possui um índice. O topo 

mantém o índice do valor que está presente no topo. Nesse exemplo, 


temos o elemento do topo na posição de índice 5, conforme indica a 

figura. Se convencionarmos que os elementos foram inseridos na pilha 

na ordem L I C A F, temos que: 

O primeiro elemento empilhado foi o L, seguido do I, C, A e F. Logo, 

podemos concluir que nessa implementação de pilha a atualização do 

topo consiste em incrementar de 1 na operação empilha e decrementar 

de 1 na operação desempilha. As pré-condições também podem ser 

obtidas da implementação. A operação Pilha Vazia pode ser verificada 

por meio do teste do valor do topo. Por exemplo, se iniciarmos a pilha 

com topo valendo 0, podemos usar o teste topo == 0 para verificar se 

pilha está vazia. Já a pré-condição pilha cheia pode ser verificada 

considerando o limite da implementação. No nosso exemplo esse 

limite é 5. Se o topo == 5, a pilha está cheia. Com isso, fica definida 

também a operação inicializaPilha que deve fazer o topo valer 0 

(zero). 

Figura 3: Implementação de uma Pilha. 

É importante neste momento notar que existem muitas 

implementações possíveis para a especificação do TAD 

pilha (conforme discutido no Capitulo 1). Esse exemplo 

apresentado é apenas uma das possíveis soluções. 

Um outro detalhe é que, além das operações empilhar e 

desempilhar, as pré-condições de pilha Cheia e pilha 

Vazia podem também se tornar operações do TAD Pilha 

na implementação. Na próxima seção discutiremos 

algumas implementações de Pilha usando arranjos 

estáticos. 



Página 33


Página 34 


1. Na seqüência a seguir, uma letra significa 

empilha e um asterisco significa desempilha. 

Determine a seqüência de valores retornados 

pela operação desempilha quando essa 

seqüência de operações é realizada sob uma 

pilha inicialmente vazia. 

E A S * Y * Q U E * * * S T * * * I O * N * * * 

2. Suponha que uma seqüência misturada de 

operações empilha e desempilha é realizada. 

As operações empilha empilham inteiros de 0 

até 9 ordenadamente. A operação desempilha 

desempilha e imprime o valor desempilhado. 

Qual das seqüências abaixo não poderá ser 

impressa? 

(a) 4 3 2 1 0 9 8 7 6 5 

(b) 4 6 8 7 5 3 2 9 0 1 

(c) 2 5 6 7 4 8 9 3 1 0 

(d) 4 3 2 1 0 5 6 7 8 9 

2.1.2 Implementação de Pilhas em Arranjos 

A Figura 3 ilustra por meio de um diagrama uma implementação de 

Pilha. Usando arranjos estáticos (vetores) e fazendo algumas 

adaptações, podemos criar essa implementação em C. A 

implementação, conforme discutido na Seção 1.2.4, será formada de 

duas partes, a interface (arquivo com extensão .h) e a 

implementação das operações (arquivo com extensão .c). É 

recomendado primeiro a definição do arquivo de interface e depois a 

implementação das operações. A seguir discutiremos uma possível 

implementação do TAD Pilha, utilizando arranjos. 

A Figura 4 mostra o arquivo de interface tadpilha.h. Foi definido 

um novo tipo chamado Pilha, formado por dois elementos 

principais: Uma variável inteira topo e o vetor itens, que servirá 

de contêiner para a pilha. O vetor itens é do tipo Elemento, que é 

apenas uma redefinição do tipo char. A definição desse tipo 

Elemento facilita posteriores modificações no tipo básico da pilha. Se 

quisermos, por exemplo, alterar a pilha para que esta empilhe e 

desempilhe valores inteiros, basta redefinir o tipo Elemento como 


int. Foram definidas assinaturas (protótipos) das funções 

correspondentes às operações inicializaPilha, empilha, 

desempilha e aos testes das pré-condições, pilhaCheia e 

pilhaVazia. Observe que estamos seguindo a notação de 

protótipos padrão de C. Nessa notação, apenas os tipos dos 

argumentos (parâmetros das funções) são identificados, sendo os 

nomes mesmos desses argumentos apenas na implementação. Note 

também que a operação desempilha retorna um Elemento. Isso é 

bastante comum, pois normalmente se deseja fazer alguma coisa com 

o elemento desempilhado. 

Figura 4: Interface do TAD Pilha com arranjos estáticos. 

Na Figura 5, temos a implementação das operações feitas no arquivo 

tadPilha.c. A operação inicializaPilha faz o topo da Pilha 

receber 0 (zero). PilhaCheia verifica se topo igual a MAX 

(tamanho máximo que a pilha pode ter) e PilhaVazia verfica se 

topo igual a 0. Na operação empilha temos a seguinte ordem: insere 

o elemento e depois incrementa o topo. Isso é necessário porque em C 

a primeira posição de um arranjo é a 0 (zero) e com a Pilha vazia o 

topo está em zero. Assim, o topo estará sempre com um índice do 

elemento no topo + 1. Para compensarmos isso, na operação 

desempilha devemos decrementar o topo retornando o elemento 

somente após o topo ser decrementado. 



Página 35


Página 36 

Figura 5: Implementação das operações do TAD Pilha. 


1. Empilhamento decrescente. Uma empilhadeira 

carrega caixas de 7, 5 e 3 toneladas. Há três pilhas 

A, B e C. A pilha A é onde se encontram todas as 

caixas que chegam no depósito. Com um detalhe: 

caixas maiores não podem ser empilhadas sobre 

caixas menores. Elabore uma função 

chegaNoDeposito (Caixa* nova, 

Pilha* A) que efetue o controle das caixas, de 

forma que, caso uma caixa de maior peso do que 

uma que já está em A deva ser empilhada, então, 

todas as caixas que estão em A são movidas para as 

pilhas auxiliares B (contendo somente caixas de 5 


toneladas) e C (contendo somente caixas de 3 

toneladas) até que se possa empilhar a nova caixa. 

Depois, todas as caixas são movidas de volta para a 

pilha A. 

2. Implementar o TAD PilhaDupla, usando um 

arranjo de 100 posições. PilhaDupla deve usar 

um único arranjo para implementar as duas pilhas. 

Além disso, a ocupação da Pilha deve maximizar o 

uso do espaço do arranjo, ou seja, enquanto houver 

espaço no arranjo qualquer uma das duas pilhas 

pode utilizá-lo. 

2.2 FILAS 

Em nosso cotidiano nos deparamos constantemente com filas. Ou 

melhor, estamos constantemente entrando e saindo de filas! Muitas 

pessoas se aborrecem com as filas. Todavia, podemos dizer que elas 

são um mal necessário. Por exemplo, imaginem se, para entrarem em 

um ônibus em uma cidade, as pessoas não fizessem uma fila e 

simplesmente se amontoassem na porta. Seria um tumulto, as pessoas 

que estivessem no ponto há mais tempo poderiam não conseguir entrar 

ou ficar sem assento. O mais incrível é que isso acontecia há uns 20 

anos e ainda acontece em muitos lugares do Brasil e do mundo! 

Figura 6: Fila: O primeiro que chega é o primeiro a ser atendido. 

Esse exemplo ilustra a idéia de que o emprego de filas no dia-a-dia é 

fundamental para a organização das atividades feitas pelas pessoas, 

sempre que o número de clientes de um recurso é maior que a 

capacidade de atendimento desse recurso. No caso do ônibus, o 

recurso é a porta de entrada, que só atende uma pessoa por vez. Com 

mais de uma pessoa no ponto esperando para entrar, é necessário que 

elas formem uma fila. Um outro exemplo é fila em um banco, cujo 

recurso necessário é o caixa. Quando entram mais clientes do que o 

número de caixas, os clientes devem formar uma fila. 



Página 37


Página 38 

O comportamento de uma fila pode ser descrito pelo estilo: O 

primeiro que chega é o primeiro a ser atendido. Em uma Fila 

organizada e sem prioridades (Figura 6, por exemplo), essa regra é 

sempre obedecida. 

Na programação aplicamos o conceito de fila para tratar casos 

semelhantes ao do ônibus e ao do banco. Alguns exemplos de 

aplicação de filas são: 

Fila de espera de passagens aéreas – Suponha, por exemplo, 

que você esteja desenvolvendo um sistema de reservas de 

passagens aéreas. Nesse tipo de sistema, as pessoas fazem 

reservas até o recurso (número de assentos no vôo) se esgotar. 

Quando isso acontece, se houver mais pessoas que querem 

viajar naquele vôo, elas entram em uma fila de espera. Se 

houver uma desistência das reservas, a primeira pessoa dessa 

fila será atendida. 

Fila de mensagens – Suponha que você esteja desenvolvendo 

um programa A que envie constantemente mensagens a um 

programa B. O programa B precisa receber essas mensagens e 

processá-las. Se o número de mensagens que o programa A 

envia em um tempo x é maior do que a capacidade de 

processamento das mensagens no mesmo tempo x pelo 

programa B, o programa B deverá usar uma fila para guardar 

as mensagens até que elas possam ser processadas. Esse é um 

caso muito comum na Internet. Quando fazemos a requisição 

de uma página Web, o navegador (programa A) envia uma 

mensagem ao servidor Web (programa B). Esse servidor pode 

receber mais requisições (mensagens) do que a sua capacidade 

de processamento. Nesse caso, ele deve enfileirar as 

requisições para que elas não sejam perdidas e para que sejam 

atendidas na ordem de chegada. 

Teoria das Filas 

O estudo das Filas, do ponto de vista estatístico e 

probabilístico, denomina-se Teoria das Filas e 

compreende uma disciplina de grande interesse de 

diversas áreas da engenharia, computação e 

administração. Essa disciplina permite, dentre outras 

coisas, estimar a capacidade de recursos a serem 

construídos (p.exemplo, aeroportos, pontes, 

armazéns de estocagem), identificar gargalos 

(pontos de atraso) em sistemas e estimar o tempo 

para a realização de uma tarefa. Em nosso estudo, 

nos concentraremos apenas na implementação e 

emprego de filas em programação, e não na 

Teoria das Filas. 


2.2.1 Especificação do TAD FILA 

O tipo abstrato de dados fila pode ser descrito pela especificação da 

Figura 7. 

Figura 7: Especificação do TAD Fila. 

As operações fundamentais do TAD Fila são inserir e remover. 

Para garantir o comportamento esperado em uma fila, definimos que a 

inserção é feita no final da fila e a remoção é feita no começo da fila. 

Temos também a operação inicializaFila, que coloca a fila em um 

estado inicial, no qual a fila deve estar vazia. A partir dessas 

operações e de suas pré e pós-condições podemos deduzir que serão 

necessárias as operações de teste de fila cheia e teste de fila vazia. 

Assim como na implementação da pilha precisamos de alguma forma 

de identificar o topo, na fila iremos necessitar de alguma maneira de 

identificar o seu inicio e seu o fim. 



Página 39


Página 40 

Figura 8: Inserções e remoções em um TAD Fila. 

O diagrama da Figura 8 ilustra uma fila com capacidade para cinco 

elementos implementada em uma estrutura semelhante a um vetor. O 

digrama também ilustra a inserção de cinco elementos (M1..M5) e 

duas operações de remoção. Note que os valores de início e fim são 

usados para armazenar as posições atuais do início e do fim da fila. 

Inicialmente o valor de início está em zero. Podemos usar essa 

condição para detectarmos se a fila está vazia. Quando o elemento M1 

é inserido, este é colocado na posição 1 e o início e o fim são 

atualizados, ambos para 1. À medida que outros elementos são 

inseridos, o fim é atualizado. Quando o fim chega a 5, temos que a fila 

não comporta mais nenhuma inserção, isto é , a fila está cheia. Assim, 

podemos usar essa condição para detectarmos se a fila está cheia ou 

vazia. 


À medida que as remoções ocorrem, o inicio da fila é atualizado, de 

forma a identificar sempre o elemento a ser removido. Um problema 

dessa implementação é que uma vez que fim atingiu o valor máximo 

(5 neste caso), não são possíveis mais inserções, mesmo havendo 

outros espaços. Isso é ruim, pois torna a fila muito limitada. Para 

contornarmos esse problema veremos duas implementações 

diferentes: Remoção com deslocamento e Fila circular. Na remoção 

com deslocamento, à medida que os elementos são removidos, os 

elementos remanescentes são deslocados para o início do arranjo. 

Figura 9: Implementação com Deslocamento. 

A Figura 9 mostra a implementação com deslocamento. Note que, 

nessa implementação, após a remoção de todos os elementos, o valor 

de início permaneceu com 1 e o valor de fim passou a ser zero. Assim, 

a condição de fila vazia não pode ser verificada pelo teste de início = 

0. Um possível teste é fim = 0 ou fim menor que início. A seguir 

vamos ver uma implementação em C usando arranjos para essa fila. 

Posteriormente veremos a implementação utilizando fila circular. 



Página 41


Página 42 


Ordenar uma fila utilizando 2 pilhas como variáveis 

auxiliares. Ao final da ordenação o elemento no início da 

fila deve ser menor que o segundo da fila e assim 

sucessivamente. A ordenação deve ser feita apenas em 

termos das operações insere, remove, filaVazia, 

empilha, desempilha e pilhaVazia. A função 

deve ter a seguinte organização: 

void ordena_2p (Fila* f){ 

Pilha p1, p2; 

... 

} 

2.2.2 Implementação de Filas em arranjos com 

deslocamento 

De forma similar à da implementação de Pilha iremos definir um 

módulo em C para implementação da Fila. Na Figura 10 temos a 

definição da interface (arquivo filaecd.h) do TAD Fila. 

Figura 10: Interface do TAD Fila. 

A Figura 11 apresenta o arquivo filaecd.c, contendo a implementação 

das operações da Fila com deslocamento na remoção. 


Figura 11: Implementação do TAD Fila Com deslocamento. 



Página 43


Página 44 

O código está comentado e pretende ser auto-explicativo. A operação 

insereNaFila insere os elementos passados como parâmetro 

(elem). Para inserir na fila, inicialmente o valor de fim é 

incrementado, visto que este foi inicializado com valor –1. Dessa 

forma a primeira inserção insere na posição 0 do vetor, a segunda na 

posição 1 e assim sucessivamente. A operação mais complexa é a 

remoção. Para remover, inicialmente o elemento no início da fila é 

passado por referência por meio do parâmetro (elem *). 

Posteriomente os elementos remanescentes na Fila são deslocados de 

uma posição. Dessa forma o elemento do início da fila ocupa 

novamente a posição 0 do vetor. 

O código da Figura 12 (arquivo principal.c) permite testar a Fila. 

Figura 12: Módulo para teste do TAD Fila. 

A função testeFilaecd declara uma fila (q) inicializa a fila, insere os 

inteiros de 0 a 9 e depois remove os elementos e os imprime. Note que 

todo o processamento é feito usando as operações do Tad Fila. 


4. Implementar as operações imprimir Fila para o TAD Fila 

implementado anteriormente. 


2.2.3 Implementação de Filas com Arranjos circulares 

Analisando a implementação do TAD Fila da seção 

anterior podemos notar que, embora a fila esteja 

corretamente implementada, existe um problema de 

eficiência na remoção de um elemento. Estou me 

referindo aos deslocamentos necessários para que a 

remoção seja feita e os espaços vagos no vetor 

possam ser reaproveitados. Veremos agora outra 

maneira de implementar o TAD Fila, em que esses 

deslocamentos não são necessários. Essa 

implementação chama-se Fila Circular. 

Função Sucessor 

Em um arranjo simples, cujas posições vão de 0 a t, podemos 

identificar facilmente qual o elemento que sucede uma determinada 

posição i. Por exemplo, se i =0, o sucessor de i = 1, se i=1 sucessor de 

i = 2. Ou seja, o sucessor de i = i+1, para i variando entre 0 e t-1. 

Nesse caso, não existe o sucessor de t. 

Agora, se definimos que o sucessor de t = 0, temos então que todos os 

índices do arranjo possuem sucessor. A Figura 13 ilustra essa situação. 

Conforme pode ser observado, existe uma circularidade entre os 

índices. 

Figura 13: Fila Circular. 

Com vetores variando entre 0 a N-1, que é o caso da linguagem C, a 

função sucessor pode ser obtida elegantemente por meio da função: 

sucessor(i) = (i+1) mod n, onde mod é o operador 

resto. 

Quando utilizamos essa função para avançarmos o índice de um 

arranjo para a próxima, dizemos que estamos usando um arranjo 

circular. 

TAD FILA baseado em Arranjo Circular 

Com um arranjo circular, é possível deslocar o início e o fim da fila 

por todo o vetor, sem correr o risco da perda de espaço e sem a 

necessidade de realocar os elementos da fila. Nessa implementação as 



Página 45


Página 46 

operações de inserir e remover, bem como as condições de Fila Cheia 

e Fila vazia precisam ser baseadas na função sucessor. A Figura 14 

apresenta a lógica dessas operações, agora definida em termos da 

função sucessor. 

Figura 14: Especificação das operações de um TAD Fila Circular. 

A Figura 15 apresenta a implementação das operações. Note que não é 

necessário um novo arquivo header, pois este é o mesmo da 

implementação do módulo filaecd. Esse fato ilustra um aspecto 

importante da implementação de TADs: A implementação pode ser 

modificada sem necessidade de se alterar a interface. Outro aspecto da 

implementação com arranjo circular, é que uma das posições do 

arranjo é perdida. Isso é necessário para diferenciar as condições de 

Fila Vazia e Fila Cheia. 


1. Reimplemente a Fila Circular, considerando que o elemento a ser 

inserido é um paciente de hospital (pessoa). Os seguintes dados são 

importantes para o paciente: nome, idade, horário de chegada e 

enfermidade. 

2. Implemente também a operação imprimeFila para essa nova Fila. 


Figura 15: Implementação das operações de Fila em um arranjo Circular. 

2.3 IMPLEMENTAÇÃO DE TADS COM ALOCAÇÃO 

DINÂMICA DE MEMÓRIA 

2.3.1 Revisão de Alocação Dinâmica de Memória 

O objetivo da alocação dinâmica de memória é utilizar espaços da 

memória de tamanho arbitrário. Em adição, a alocação dinâmica de 

memória permite criar estruturas de dados encadeadas. A alocação de 

espaço sob demanda é utilizada quando o espaço de memória 

necessário para um conjunto de dados varia durante a execução do 

programa. Já o encadeamento provê um estilo eficiente de representar 

conjuntos de dados em C e de implementar as estruturas de 

armazenamento de Tipos Abstratos de Dados. 



Página 47


Página 48 

A alocação dinâmica de memória necessita de suporte da Linguagem 

de Programação. Em C, esse suporte é fornecido por um conjunto de 

funções disponíveis na biblioteca alloc. As principais funções dessa 

biblioteca são a função malloc, que aloca um espaço na memória e 

retorna um ponteiro para o espaço alocado e a função free, que 

libera espaços de memória alocados por meio da função malloc. 

Exemplo de uso de alocação de espaço sob demanda 

Uma das vantagens da alocação dinâmica é permitir a alocação de 

espaço de acordo com a necessidade. Por exemplo, suponha que um 

programa necessite de um arranjo para guardar N números inteiros. 

Usando alocação estática de memória, como não sabemos a 

quantidade precisa de números, devemos fazer uma estimativa do 

valor máximo de número e declarar o vetor com base nessa estimativa. 

A função alocEstatica da Figura 16 ilustra esta situação. 

Figura 16: Alocação Estática de memória. 

Note que o valor lido para n pode variar de 1 a 100. Quanto menor o 

valor de n, maior o desperdício de espaço alocado. 

Usando alocação dinâmica teremos o valor de n que, lido, pode ser 

usado como parâmetro da chamada da função malloc, para alocar um 

conjunto de n inteiros, ou seja, um vetor de n inteiros. A função 

alocDinamica na Figura 17 é idêntica em termos de 

funcionalidade à função alocEstatica. Contudo, esta utiliza 

alocação dinâmica. 


Figura 17: Vetor com Alocação dinâmica. 

Note que na alocação dinâmica não há limites para n, e este poderá 

assumir, em teoria, qualquer valor maior que zero (n>0). A função 

malloc possui apenas um parâmetro formal: o número de bytes a 

serem alocados. Normalmente esse número de bytes é determinado 

multiplicando o tamanho em bytes do tipo base a ser alocado pelo 

número de elementos. No exemplo, o tipo base é o int. Foi usada a 

macro sizeof para determinar o tamanho exato do tipo int, que 

pode variar entre diferentes máquinas, sistemas operacionais e 

linguagens. Qualquer tipo pode ser utilizado como parâmetro de 

sizeof, inclusive tipos definidos pelo usuário. 

Listas Simplesmente Encadeadas 

Uma outra finalidade do uso de alocação dinâmica e apontadores é 

permitir a implementação de estruturas encadeadas utilizando 

estruturas auto referenciadas.Uma estrutura auto referenciada 

possui, dentro seus campos, um campo que pode referenciar estruturas 

idênticas a ela mesma. Portanto, uma estrutura auto referenciada pode 

apontar para outra estrutura do mesmo tipo que ela. 

O código na Figura 18 define um tipo Ponto que é auto referenciável. 



Página 49


Página 50 

Figura 18: Estrutura auto referenciada. 

O tipo Ponto definido pelo typedef é um tipo ponteiro para a 

struct ponto. Essa struct por sua vez, possui dentro dela os 

campos x,y (coordenadas do ponto), cor (cor do ponto) e 

proximoPonto, que é uma variável do tipo ponteiro para struct 

ponto. A variável proximoPonto é que permite que uma variável 

do tipo struct ponto possa se ligar (apontar) a outra estrutura do 

tipo struct ponto. 

Figura 19: A struct ponto. 

Lista simplesmente Encadeada 

A estrutura de dados encadeada mais simples que temos 

é a lista simplesmente encadeada. Uma lista 

simplesmente encadeada é um agregado de elementos 

de um mesmo tipo, em que cada elemento é armazenado 

em um espaço alocado dinamicamente. À medida que 

elementos são inseridos na lista, esses espaços são 

criados e vão sendo encadeados de forma que: 

- O endereço do primeiro ou do último elemento da lista 

é mantido em uma variável do tipo ponteiro; 

- Os demais elementos são acessados a partir do seu 

início ou do seu fim. Isto é possível porque cada nodo 

da lista possui um campo que aponta para o próximo 

elemento da lista. 

A struct ponto pode servir para implementarmos uma lista. 

Visualmente, uma lista encadeada de pontos pode ser ilustrada pela 

Figura 20 a seguir: 


Figura 20: Exemplo de lista simplesmente encadeada. 

lPontos é uma variável do tipo ponteiro para struct ponto 

(Ponto com P maiúsculo). Inicialmente a lista está vazia. Assim é 

conveniente fazermos a variável lPontos apontar para um valor 

“Seguro”, evitando possíveis invasões de espaço de memória 

indevidos. Este valor seguro é NULL. 

Para inserirmos um nodo na lista de pontos, criamos o nodo, 

utilizando malloc e guardamos o endereço deste nodo em 

lPontos; 

Para manter o encadeamento, devemos fazer o proximoPonto do 

nodo alocado apontar para o endereço anteriormente contido em 

lPontos. O excerto de código apresentado na Figura 21 implementa 

esta operação de inserção. 

Figura 21: Inserindo um ponto na lista de pontos. 

Note que foi necessário guardar o valor de lPontos em aux, Isso 

ocorre porque, quando malloc é chamada para criar o novo Ponto, o 

endereço retornado é atribuído a lPontos fazendo com que o seu 

endereço anterior seja perdido. 

É conveniente implementar uma lista simplesmente encadeada como 

um TAD, encapsulando sua estrutura por meio de operações bem 

definidas. Essas operações compreendem a inserção, a remoção 

e outras que por ventura sejam necessárias (por exemplo, 

imprimeLista). A seguir, iremos implementar uma lista encadeada 

cujo objetivo é armazenar uma lista de pessoas. Cada pessoa é 

definida pelo seu nome, seu código e seu telefone. Na implementação 

definimos um módulo elemento e o módulo Tadlista. As Figuras 22 e 

23 apresentam a definição da interface desses dois módulos: 



Página 51


Página 52 

Figura 22: Interface do TAD Elemento. 

Figura 23: Interface do TAD Lista. 

A implementação da operação inicializaLista (Figura 24) 

consiste em atribuir o valor NULL a Lista passada por referência. 

Segue essa implementação: 

Figura 24: Implementação da operação inicializaLista. 

A implementação da inserção (Figura 25) segue exatamente o mesmo 

procedimento usado no exemplo da lista de pontos. 

Figura 25: Implementação da operação insereNaLista. 

A operação de remoção visa remover um elemento da lista tendo sido 

informado o código do elemento. Esse procedimento deve também 

retornar o elemento a ser removido. A remoção deve usar a função 

free para liberar o espaço alocado pelo nodo removido. Além disso, 

deve ser também preservado o encadeamento da lista. De acordo com 

esses objetivos temos que realizar uma pesquisa na lista com o 

objetivo de encontrar o nodo a ser eliminado. Como resultado dessa 

pesquisa existem duas possibilidades: 


* O elemento está na lista. A pesquisa pára quando encontrar o 

elemento. 

* O elemento não está na lista. A pesquisa chega até o fim da lista 

(NULL). 

Formulamos então o algoritmo recursivo apresentado na Figura 26. 

Figura 26: algoritmo para remoção de um elemento na Lista. 

A Figura 27 apresenta uma implementação para a operação de 

remoção baseada no algoritmo da Figura 26. 

Figura 27: Implementação da operação removeDaLista. 

A operação pesquisaNaLista visa retornar um elemento cujo 

código é passado como parâmetro. Essa pesquisa é feita por meio de 

um loop, que percorre a lista até encontrar o elemento ou chagar ao 

seu final. Temos novamente duas situações: busca com sucesso ou 

busca sem sucesso. Na Figura 28, temos a implementação desta 

operação. 



Página 53


Página 54 

Figura 28: Implementação da operação pesquisaNaLista. 

A Figura 30 apresenta a implementação da operação 

imprimeLista, que utiliza a operação imprimeElemento do 

TAD elemento (Figura 29). A operação imprimeLista deve 

percorrer a lista até o final imprimindo o conteúdo de seus elementos. 

Seguem as implementações das operações imprimeElemento 

arquivo elemento.c) e imprimeLista (arquivo tadLista.c). A 

operação imprimeLista é recursiva. A cada chamada da 

recursividade, é passado um apontador para o próximo elemento da 

lista. A condição de parada da recusividade é chegar ao final da Lista 

(NULL). 

Figura 29: Implementação da operação imprimeElemento do TAD Elemento. 

Figura 30: Implementação da operação imprimeLista. 



1. Implementar uma operação para o TAD Lista 

que insira os elementos no seu final. 

2. Implementar uma operação para o tadLista 

que transforme a lista em uma lista ordenada. 

Essa operação deve inserir os elementos de 

modo que a lista permaneça sempre em ordem 

crescente a partir de seu inicio. A chave de 

ordenação a ser utilizada deve ser o código do 

elemento. 

2.3.2 Implementação do TAD Pilha 

A implementação do TAD Pilha com alocação dinâmica de memória 

possui como vantagem principal o fato de podermos considerar a sua 

capacidade de armazenamento como sendo infinita. Ou seja, usando 

alocação dinâmica não precisamos testar se a Pilha está cheia para 

fazer um empilhamento. Outra vantagem está na simplicidade da 

implementação. O quadro abaixo ilustra a definição do tipo Pilha 

como uma estrutura dinâmica encadeada. Podemos afirmar que uma 

pilha é uma lista onde os elementos são inseridos no início e 

removidos do início. Para efeitos de implementação da pilha, 

chamamos o início de topo. 

A Figura 31 apresenta o arquivo de interface TadPilhaAD.h com a 

definição da estrutura de dados Pilha e das operações. Note 

novamente que as operações são as mesmas apresentadas no módulo 

Pilha.h visto anteriormente. 



Página 55


Página 56 

Figura 31: Interface do TAD Pilha com alocação dinâmica 

Para a definição da Pilha dinâmica, é definido o tipo Nodo que é um 

tipo ponteiro para struct nodo (em minúsculo). Pilha é uma estrutura 

que contém apenas uma variável: o topo. Esse topo, por sua vez, é do 

tipo Nodo. 

Uma variável do tipo Pilha é uma variável estática. Essa variável é 

uma estrutura contendo como único campo o topo. O topo, por sua 

vez, é que é um apontador. 

Pilha p; 

p.topo=NULL; 

NULL 

topo 

Figura 32: Representação do da estrutura de dados dinâmica Pilha. 

Topo é uma variável do tipo ponteiro para struct nodo. Assim 

topo pôde ser inicializado com NULL. Essa condição pode ser 

utilizada para detectarmos se a Pilha está vazia. A Figura 33 apresenta 

as operações inicializaPilha e pilhaVazia seguindo exatamente essas 

decisões de implementação. 

p 


Figura 33: Implementação das operações inicializaPilha e pilhaVazia. 

A operação empilha pode ser especificada da seguinte forma: 

1. Cria uma nova estrutura do tipo struct nodo; 

2. Faz o prox da nova estrutura apontar para a estrutura para a 

qual o topo da Pilha aponta; 

3. Faz o topo da pilha apontar para o novo nodo. 

Seguindo os passos acima, após inserirmos o primeiro elemento na 

pilha (valor 1), e supondo que o nodo foi alocado a partir do 

endereço 300h da memória, teremos a configuração apresentada na 

Figura 34. 

300h 

topo 

NULL 

prox 

1 

item 

p 

300h 

Figura 34: Diagrama da Pilha com um nodo (um elemento empilhado). 

Se empilharmos agora um segundo elemento (valor 2), e supondo que 

o novo nodo foi alocado na posição 400h, teremos a seguinte 

configuração apresentada na Figura 35. 



Página 57


Página 58 

Inserindo agora o elemento 3 e supondo a alocação no endereço 500h 

teremos a configuração da Figura 36. 

500h 

topo 

p 

400h 

topo 

p 

NULL 

prox 

1 

item 

Figura 36: inserindo o elemento 3. 

300h 

prox 

A remoção de um elemento na pilha dinâmica implica nos seguintes 

passos: 

1. se a pilha não está vazia: 

a. guarda o valor que está no topo; 

b. salva o endereço que está no topo em uma variável 

auxiliar; 

c. atribui o endereço do prox do topo ao topo; 

d. libera o espaço ocupado pelo nodo que estava no topo. 

Executando esses procedimentos, a regra fundamental da pilha, o 

último que chega é o primeiro que sai, é sempre respeitada. A Figura 

37 apresenta a implementação das operações empilha e desempilha: 


2 

item 

300h 

400h 

Figura 35: Empilhando o elemento 2. 

NULL 

Prox 

1 

item 

300h 

300h 

prox 

2 

item 

400h 

400h 

prox 

3 

item 

500h

Figura 37: Implementação das operações empilha e desempilha. 




Reimplementar o TadPilha, usando o TAD Lista, (visto na 

revisão de Alocação Dinâmica), como cliente. Nessa nova 

implementação o tipo Pilha deve ser definido em termos do 

tadLista e as implementações de empilha e desempilha e 

filaVazia devem ser feitas com base nas operações de 

remoção e inserção. 

2.3.3 Implementação do TAD Fila 

A Figura 38 presenta o arquivo TadFilaAD.h. Assim como na 

implementação da Pilha, foi utilizada uma estrutura chamada nodo 

contendo um campo item do tipo Elemento e um campo prox para 

estabelecer o encadeamento dos nodos. O tad Fila por sua vez é uma 

estrutura contendo os campos inicio e fim que são apontadores para struct 

nodo (Nodo). Uma variável to tipo TadFila é uma estrutura contendo esses 

dois campos. Por exemplo, a seqüência: 

Página 59


Página 60 

TadFila q; 

q.inicio=NULL; 

q.fim=NULL; 

Figura 38: Interface do TAD Fila com alocação dinâmica. 

NULL 

inicio 

NULL 

fim 

q 

Figura 39: diagrama de memória da estrura dinâmica Fila. 

A Figura 39 ilustra a variável q. Analogamente a uma Pilha, podemos 

inicializar a Fila colocando o Valor NULL em inicio e fim. Além 

disso, podemos usar a condição início = NULL para detectar se a Fila 

está vazia. A Figura 40 apresenta a implementação destas operações. 

Figura 40: Implementação das operações inicializaFila e filaVazia. 


Após a inserção de um elemento (1) na Fila, supondo que o nodo vai 

ser alocado na posição 300h, temos a configuração apresentada na 

Figura 41. 

300h 

inicio 

300h 

fim 

NULL 

prox 

1 

item 

300h 

Figura 41: Inserindo o elemento 1 na Fila. 

Inserindo mais um elemento (2) e supondo que o nodo foi alocado no 

endereço 400h, temos a inserção apresentada na Figura 42. 

300h 

inicio 

400h 

fim 

q 

Figura 42: Inserindo o elemento 2. 

Note que o conteúdo do apontador fim foi atualizado. Essa operação 

deve ser cuidadosa para que os ponteiros não fiquem perdidos. 

Existem duas situações que devem ser tratadas diferentemente: 

quando a Fila está vazia e quando não está vazia. A seguinte 

seqüência de passos deve ser utilizada: 

1. aloca o novo nodo 

2. atribui os valores ao novo nodo 

3. Se a fila está vazia 

a. início = novonodo 

b. fim = novonodo 

4. Se não 

a. o prox do nodo apontado por fim recebe o novonodo 

b. fim=novonodo 


q 

400h 

prox 

1 

item 

300h 


NULL 

prox 

2 

item 

400h 

Página 61


Página 62 

O código que implementa a operação insere é apresentada na 

Figura 43. 

Figura 43: Implementação da operação insereNaFila. 

A remoção deve guardar o valor que está no fim da Fila, atualizar o 

ponteiro de Fim e liberar o nodo que estava no fim. Os seguintes 

passos devem ser seguidos: 

1. Se a Fila não está vazia 

a. guarda o valor contido no nodo a ser eliminado (que 

está no inicio da Fila) 

b. guarda o endereço do nodo a ser eliminado (inicio) em 

uma variável auxiliar (aux) 

c. inicio recebe o próximo de inicio 

d. libera a área apontada por aux 

O código que implementa a operação removeDaFila é apresentado 

na Figura 44. 

Figura 44: Implementação da operação removeDaFila. 


O código apresentado na Figura 45 ilustra a utilização do TadFila. 

Note que, fora a mudança nos arquivos de inclusão, este programa é o 

mesmo que foi usado para testar a implementação da fila com 

deslocamento. 




1. Adicionar a operação imprimeFila ao 

TadFila. 

2. Adicionar a operação removePrioritario ao 

TadFila. Esta operação deve permitir a remoção 

com prioridade na Fila. A prioridade vai se basear 

no valor inserido no campo item. A execução de 

removePrioritario deve remover o nodo da 

fila cujo item for o maior. 

Figura 45: Módulo para teste do TAD Fila. 

Página 63

3. LISTAS E ÁRVORES. 

Olá, Neste Capítulo continuaremos o nosso estudo 

de Tipos Abstratos de Dados, focalizando 

implementações que utilizam alocação dinâmica de 

memória. Iremos estudar mais sobre listas 

encadeadas e também sobre estruturas chamadas de 

Árvores. Nosso estudo de Listas baseia-se em 

variações do TAD Lista estudado no Capítulo 2. Da 

mesma forma como fizemos para a lista 

simplesmente encadeada, para cada variação iremos 

especificar e implementar as operações para 

inicializar a lista, inserir um elemento na lista, 

remover e recuperar um elemento existente na lista. 

3.1 LISTAS CIRCULARES 

A primeira variação que estudaremos chama-se Lista Circular. Nessa 

Lista, não existe o último elemento. Aquele elemento da lista 

simplesmente encadeada que antes apontava para NULL irá agora 

apontar para o início da Lista, criando então um conjunto circular de 

nodos. 

e prox e prox e prox 

Figura 1: Lista Circular Simplesmente Encadeada 

Com essa estrutura, em uma lista circular não temos mais a noção de 

Fim de Lista (o nodo que apontava para NULL). A Figura 1 ilustra 

uma lista encadeada circular contendo três nodos. Conforme podemos 

observar, essa estrutura pode ser implementada com nodos idênticos 

aos de uma Lista simples. Entretanto a interface do TAD 

ListaCircular irá apresentar algumas mudanças. A Figura 2 

apresenta a implementação dessa interface. 



Página 65


Página 66 

Figura 2: Interface do TAD Lista (Circular). Similar a Lista simples. 

Em uma Lista circular irá ter sempre um elemento de acesso, apontado 

por uma variável do Tipo Lista, por exemplo: 

Lista l; 

A operação de inicialização atribui NULL à variável l. A Figura 3 

Apresenta essa implementação, que é idêntica à de uma lista 

simplesmente encadeada. 

Figura 3: Implementação de inicializaLista para lista circular. 

As inserções na lista poderão ser feitas de duas formas: à direita 

(depois do nodo apontado por l) e à esquerda (antes do nodo apontado 

por l). A Figura 4 ilustra as operações de inicialização e inserção em 

uma lista circular, supondo uma variável l do tipo Lista. Na Figura os 

valores 100h, 200h, .. representam os endereços de memória de cada 

nodo da lista. Inicialmente l é inicializada e não aponta para nenhum 

endereço de memória. Em seguida, é feita uma inserção, que pode ser 

tanto à direita quanto à esquerda. Nessa primeira inserção, l passa a 

apontar para o nodo inserido e o prox do nodo inserido aponta para ele 

mesmo. Em seguida é feita uma inserção à direita (depois) do nodo 

apontado por l. Nesse caso, o prox do novo nodo recebe o valor do 

prox de l e prox de l passa a ser o nodo inserido. 


NULL 

l 

100h 

l 

100h 

l 

300h 

l 

inicializa Lista l 

100h 

e prox 

1 

100h 

100h 

e prox 

1 

200h 



Inserção - à direita ou à esquerda 

e 

200h 

2 

prox 

300h 100h 

200h 

e prox 

e prox 

e prox 

3 100h 

1 200h 

2 

Figura 4: Seqüência de operações em uma Lista Circular 

A última operação é uma inserção à esquerda, (antes) do nodo 

apontado por l. Nessa operação, o procedimento se inicia de forma 

idêntica à inserção à direita: 

1. Cria novo nodo; 

2. Próximo de novo nodo recebe o próximo de l; 

3. Próximo de l recebe o endereço do novo nodo; 

No entanto, ao final da operação de inserção à esquerda o 

início da lista passa a apontar para o nodo recém criado 

(próximo dela). 

100h 

A Figura 5 apresenta as implementações dessas operações. 

Note que a operação insereaDireita é usada na operação 

insereaEsquerda. Após a sua chamada apenas o valor de 

l é atualizado passando a apontar para o nodo recém 

adicionado. 

Inserção à direita 

300h 

Inserção à esquerda 

Página 67


Página 68 

Figura 5: Implementação das operações de inserção 

Para a operação de remoção iremos considerar duas possibilidades: 

remoção à direita e Remoção de um elemento arbitrário. 

300h 

l 

300h 

l 

300h 

l 

NULL 

l 

300h 100h 

200h 

e prox 

e prox 

e prox 

3 100h 

1 200h 

2 

300h 

e prox 

3 

200h 

300h 

e prox 

3 

300h 

e 

200h 

2 

prox 

300h 

Figura 6: Seqüência de Remoções à Direita 

A remoção à direita implica em remover o elemento que está à direita 

(depois) do elemento inicial da lista. Esse elemento é exatamente o 

elemento apontado pelo prox de do nodo inicial. A Figura 6 ilustra 

uma seqüência de operações de remoção à direita sobre a lista l. 

Conforme podemos observar, o valor de l permanece o mesmo 

durante as remoções, mudando apenas quando a lista fica vazia. A 

seguintes alterações nos apontadores são necessárias: 

se (l é igual ao próximo de l) 

l recebe NULL 

senão 

próximo de l recebe o próx do nodo a ser 

eliminado. 

A implementação de removeaDireita é apresentada na figura 7. 


300h

Figura 7: Implementação da Remoção à direita 

Pergunta: Por que não optamos por remover sempre 

o elemento inicial da lista? Para responder a essa 

pergunta, tente implementar essa operação. Você 

verá que vai necessitar alterar o valor do prox do 

elemento que aponta para l. Como não temos acesso 

direto a esse elemento por meio de l, será necessário 

percorrer a lista inteira até encontrá-lo. Assim essa 

operação fica ineficiente. 

A remoção de um elemento arbitrário da lista é a operação de 

eliminação desse elemento, dada uma chave de busca do mesmo. Por 

exemplo, suponha que queiramos eliminar o nodo da lista l com valor 

2 (vide Figura 6) Nesse caso, o nodo que contém o elemento 2 deve 

ser inicialmente localizado. Além do nodo em si, é necessário 

encontrar o nodo cujo prox aponta para o nodo a ser eliminado. Para 

isso podemos usar dois apontadores auxiliares. 

Na exclusão, as seguintes situações devem ser consideradas: 

Remoção de um elemento genérico da lista que seja diferente 

do elemento apontado por l; 

Remoção do elemento da lista que é apontado por l (início da 

lista); 

Remoção do último elemento da lista. 

A Figura 8 ilustra esses casos. 



Página 69


Página 70 

300h 

l 

Remoção do elemento 2 

300h 

l 



300h 100h 

200h 

e prox 

e prox 

e prox 

3 100h 

1 200h 

2 

300h 

l 


300h 

300h 100h 

e 

3 

prox 

200h 

e 

1 

prox 

Situação 1: Remoção de um elemento Genérico da lista 

300h 100h 

200h 

e prox 

e prox 

e prox 

3 100h 

1 200h 

2 

200h 

l 

300h 

300h 

200h 100h 

e 

2 

prox 

100h 

e 

1 

prox 

Situação 2: Remoção de elemento apontado por l 

100h 

l 

100h 

e prox 

100h 

1 

NULL 

Situação 3: Remoção do último elemento da lista 

Figura 8: Situações para Remoção de um Elemento Arbitrário da Lista 

Na Situação 1, o elemento que se deseja eliminar é o 2. Esse caso 

pode ser considerado o caso normal da lista. Para eliminar esse 

elemento, o prox do nodo anterior a ele (100h) deverá apontar para o 

próximo dele (300h). Na segunda situação, temos que o nodo a ser 

eliminado é o mesmo apontado por l (início da lista). Nesse caso o 

valor de l precisa ser atualizado, apontando para o anterior do nodo 

que será eliminado. 

Na terceira situação o nodo a ser eliminado é o último. Logo, l precisa 

ser atualizado para NULL. O seguinte algoritmo pode ser utilizado 

para a remoção: 

l 

Elemento removeElemento(Lista l, int codigo){ 

se l está vazia 

1. retorna elemento vazio 

senão 

2. localizo elemento 

Se elemento procurado não existe 

retorno elemento vazio 

senão 

3. o próximo do anterior do elemento procurado 

recebe o próximo do elemento procurado 

4. guardo o elemento a ser retornado 

se o elemento procurado é o elemento apontado por 

l 

200h

se a lista possui mais de um elemento 

5. l recebe o anterior do elemento procurado 

senão 

6. l recebe NULL 

7. retorna elemento 

Figura 9: Implementação da operação removeElemento 

A Figura 9 apresenta a implementação da operação removeElemento, 

que remove um elemento arbitrário da lista circular. paux1 e 

paux2 são apontadores auxiliares utilizados para percorrer a lista, 

localizar o nodo que contém o elemento procurado (paux2) e o 

nodo anterior a ele (paux1). 

Inicialmente, paux1 recebe o valor de l e paux2 o próximo de l. O 

do{ ..}while(paux2!=*l); realiza a busca do elemento. Se o 

elemento é encontrado, a busca pára devido ao comando break. Se o 

elemento não existe, a lista toda é percorrida e a busca pára quando 

paux2 obtém o valor de *l. 

Ao terminar a busca, devemos verificar se o elemento foi realmente 

encontrado. Se não foi encontrado, a operação retorna um elemento 

vazio. Caso contrário, a eliminação se dá, fazendo o prox do paux1 

apontar para o prox de paux2. Em seguida as situações 2 e 3 (vide 



Página 71


Página 72 

Figura 8) de remoção são verificadas e, se necessário, o valor de l será 

atualizado. 

As demais operações do TAD (imprime e pesquisa) baseiam-se em 

varreduras na lista a partir do nodo inicial. Para essas operações, é 

sempre utilizado um apontador auxiliar, que ao final de cada repetição 

no laço de busca é atualizado recebendo o próximo nodo da lista. 

Esse apontador é inicializado com o valor do nodo inicial da lista e a 

condição de parada é ele voltar a ser igual ao endereço do nodo inicial. 

Por isso, utilizamos sempre o do{ .. }while(..); em vez de 

while(..){ .. }. Mesmo sendo iniciado com o valor do 

endereço inicial, quando o teste do laço é atingido, o apontador 

auxiliar é atualizado, passando a apontar para o seu próximo. Assim, 

somente depois de percorrer a lista inteira é que o apontador auxiliar 

valerá novamente o endereço do nodo inicial. As figuras 10 e 11 

apresentam as implementações das operações pesquisaNaLista, 

imprimeLista e imprimeListadeNomes, que utilizam essa 

técnica. 

Figura 10: Implementação da operação pesquisaNaLista 

A operação pesquisaNaLista visa procurar um elemento cujo 

código é igual ao valor de codigo (argumento da função). 

O TAD Elemento 

A estrutura do elemento armazenado na lista é a 

mesma do TAD elemento armazenado na lista 

simplesmente encadeada. Foi adicionada mais uma 

operação, chamada imprimeNome, que imprime 

apenas o nome do elemento. Assim, a interface do 

TAD Elemento utilizado nessa implementação de 

listas circulares possui a seguinte estrutura: 


Figura 11: Operações imprimeLista e imprimeListaDeNomes 

As duas operações de impressão adotam a mesma estratégia. A 

diferença entre elas é que a operação imprimeLista vai imprimir 

todos os dados de cada elemento. Já a operação 

imprimeListasDeNomes vai imprimir somente os nomes de cada 

elemento, usando uma formatação que facilita a depuração e o 

entendimento das operações. O programa módulo principal da 



Página 73


Página 74 

implementação de listas circulares utiliza essa operação e apresenta 

sua impressão. A Figura 12 apresenta a função testeListaCircular. 

Figura 12: Implementação do Módulo Principal para Testar a ListaCircular. 


Após a execução de testeListaCircular a seguinte saída é 

gerada: 

Cada linha da saída é o resultado de uma chamada de 

imprimeListaDeNomes. 




a) Implementar uma operação insere 

ordenado. Utilizando essa operação para inserir 

elementos, a partir do nodo inicial da lista, o 

próximo de cada elemento deve ser maior que o 

seu antecessor; 

b) Implementar uma operação para concatenar duas 

listas circulares A e B. O resultado deve ser uma 

lista contendo todos os elementos das duas listas, 

de forma alternada. Ou seja: o primeiro da lista A, 

o primeiro da lista B, o segundo da lista A, o 

segundo da lista B, e assim sucessivamente. 

3.2 LISTA CIRCULAR DUPLAMENTE ENCADEADA 

Muitas operações envolvendo listas encadeadas podem ser facilitadas 

se cada nodo conhecer o seu antecessor. Uma lista circular duplamente 

encadeada possui exatamente essa característica. Além do apontador 

para o próximo elemento, cada nodo da lista vai ter um apontador para 

o elemento anterior. 

Página 75


Página 76 

NULL 

l 

100h 

l 

200h 

l 

300h 

l 

inicializaLista 

ant 

100h 

ant 

100h 

300h 

e prox 

3 200h 

ant 

100h 

e prox 

100h 

e prox 

1 100h 

200h 100h 

ant 

2 100h 

200h 1 

ant 

300h 

e prox 

e prox 

Insere(1) 

200h 

2 100h 

200h 1 

Insere(2) 

200h 100h 

ant 

Figura 13: lista duplamente encadeada 

e prox 

300h 

Insere(3) 

A Figura 13 ilustra uma seqüência de inserções em uma lista circular 

duplamente encadeada. Inicialmente a lista está vazia: l possui o valor 

NULL. Os campos ant e prox são respectivamente os apontadores 

para os nodos anterior e próximo de cada nodo da lista. No modo de 

inserção adotado, temos duas situações distintas ao inserir um 

elemento: A lista está vazia ou a lista não está vazia. Quando a lista 

está vazia, l, o próximo e o anterior do novo nodo recebem todos o 

mesmo valor: o endereço do novo nodo. Isto é mostrado na inserção 

do elemento 1 (um) na lista). Quando a lista não está vazia, além dos 

apontadores do prox e ant do novo nodo, os apontadores do nodo 

anterior e posterior ao nodo apontado por l (além do próprio l) deverão 

também ser atualizados. Observe as inserções dos elementos 2 e 3 na 

lista e veja como os ponteiros são modificados. Para manter o 

encadeamento correto, as seguintes atualizações são necessárias: 

1. O próximo do anterior a l recebe o novo 

nodo; 

2. O próximo do novo nodo recebe l; 

3. O anterior do novo nodo recebe o 

anterior de l; 

4. O ponteiro anterior de l recebe p; 

5. l recebe o endereço do novo nodo. 

Esses passos estão identificados com os número de 1 a 5 na 

implementação da inserção (Figura 15). 


Atenção: Na Figura 13, a variável l é do tipo ponteiro 

para o nodo da lista. Na implementação que iremos 

apresentar, essa variável irá sempre apontar para o 

último nodo inserido na lista. Contudo, outras 

implementações são possíveis. 

Como de costume, implementaremos a lista circular duplamente 

encadeada como um Tipo Abstrato de Dados. A Figura 14 apresenta a 

interface desse TAD. 

Figura 14: Interface do TAD Lista Circular Duplamente Encadeada 

A inicialização segue o mesmo princípio de uma lista simplesmente 

encadeada. O apontador inicial da lista aponta para NULL. A 

implementação da operação inicializaLista é idêntica à da lista 

Circular (Figura 3). Na implementação da operação de inserção, 

iremos considerar o modo apresentado na Figura 13. A Figura 15 

apresenta a implementação das operações inicializaLista e 

insereNaLista. Iremos considerar uma lista de elementos do tipo 

Elemento definido para a lista circular (vide TAD Elemento, pag. 59). 



Página 77


Página 78 

Figura 15: Implementação das operações inicializa e insere 

Iremos apresentar duas formas de remoção: Remoção do elemento 

apontado por l e remoção de um elemento arbitrário. 

Figura 16: Eliminação do nodo apontado por l 

A Figura 15 apresenta a implementação da operação de remoção do 

nodo apontado por l. Para tornar a implementação mais simples foram 

usados dois apontadores (do tipo Lista) auxiliares: proximo e 

anterior. O elemento a ser removido (apontado por l) é o 

elemento entre o próximo e o anterior. Assim, para manter o 

encadeamento, próximo e anterior deverão apontar um para o outro. 

Como o nodo apontado por l vai ser eliminado, o valor contido em l 

deve ser atualizado, passando a apontar para proximo. 


300h 

l 

200h 

l 

ant 

100h 

300h 

e prox 

3 200h 

ant 

100h 

ant 

300h 

e prox 

e prox 

2 100h 

200h 1 

200h 

proximo 



200h 100h 

2 100h 

200h 1 

ant 

200h 100h 

ant 

Figura 16: Remoção do nodo apontado por l 

e prox 

200h 

e prox 

300h 

100h 

anterior 

Novamente, caso a lista não esteja vazia, duas situações são possíveis 

e necessitam de tratamentos diferentes: A lista possui apenas um (1) 

nodo ou a lista possui mais de um nodo. Caso a lista possua apenas 

um nodo, basta guardar o conteúdo do elemento a ser eliminado, 

liberar o nodo e atribuir NULL a variável l. 

Já quando a lista possui mais de um nodo, a seguinte seqüência de 

atualizações dos apontadores deve ocorrer: 

1. anterior recebe o anterior de l; 

2. próximo recebe o próximo de l; 

3. próximo de anterior recebe próximo; 

4. Anterior de próximo recebe anterior; 

5. Libera o nodo apontado por l; 

6. Faz l apontar para próximo. 

Na Figura 15 essa seqüência é enumerada com os número de 1 a 6. 

A operação de remoção de um elemento arbitrário é semelhante à 

eliminação em uma lista circular simplesmente encadeada. O nodo 

contendo o elemento procurado deve ser localizado na lista por meio 

de uma busca seqüencial. Em caso de sucesso (se o elemento existir 

na lista), tanto os apontadores do nodo anterior ao eliminado quanto os 

do nodo posterior devem ser atualizados também. A Figura 17 

apresenta a implementação dessa operação. São consideradas as 

seguintes situações: 

1. A lista está vazia; 

2. O elemento procurado não existe; 

3. Só existe um nodo na lista (a lista vai ficar vazia!); 

4. O nodo a ser eliminado é o nodo apontado por l. 

Página 79


Página 80 

Figura 17: Operação de remoção de um elemento arbitrário 

Para imprimir a lista, implementamos duas operações: 

imprimeSentidoHorario e 

imprimeSentidoAntiHorario. A Figura 18 apresenta essas 

operações. 


Figura 18: Operações de Impressão da Lista. 

Por último, temos a operação pesquisaNaLista. Essa operação 

pode ser feita de forma idêntica à operação pesquisaNaLista 

para listas circulares simplesmente encadeadas (Figura 10). Assim, 

não iremos repetir seu código aqui. No entanto, esse código pode ser 

encontrado no módulo ListaDupla, implementado e 

disponibilizado no ambiente de aprendizado. 


2. Implementar uma operação para remover os elementos 

de uma lista cujo código é maior que 10. 

Implementar uma função removeEntrePares que 

remove os elementos que são pares da lista. Ou seja, o 

anterior e o próximo do elemento são elementos cujo 

código é um número par. 



Página 81


Página 82 

3.3 ÁRVORES BINÁRIAS 

Até o presente momento, focalizamos o estudo de 

estruturas de dados encadeadas lineares ou 

seqüenciais. Nessas estruturas, existe a noção de 

antecessor e próximo, para cada nodo. Nesta Seção 

iremos estudar uma nova estrutura encadeada 

denominada Árvore. Essas estruturas são chamadas 

assim pela semelhança de sua estrutura com as 

ramificações de uma árvore. 

Conceitualmente, uma árvore é um tipo especial de um modelo 

matemático denominado grafo. Em termos de estrutura de dados, 

uma árvore é um conjunto de nodos ligados. Um desses nodos é 

denominado raiz. Os demais nodos da árvore são acessados a partir 

do nodo raiz. 

Árvore Binária 

Uma árvore binária é um tipo especial de árvore que 

possui uma estrutura formada por: 

Um nodo raiz 

Uma sub árvore esquerda 

Uma sub árvore direita 

A Figura 20 apresenta uma árvore binária. O nodo contendo o valor 

10 é o nodo raiz. Esse nodo permite o acesso as subárvores esquerda e 

direita. Note que a definição é recursiva. Assim como o nodo raiz, o 

nodo 5 também possui ligações para as suas subárvores esquerda e 

direita. Os nodos que não possuem nenhuma subárvore são chamados 

de nodos folha. Na Figura 20, os nodos 1, 3, 6, 8, 11, 14 e 20 são 

nodos folha. Um nodo pode também possuir apenas a subárvore 

esquerda ou a subárvore direita. Na Figura 20, o nodo 18 possui 

apenas a subárvore direita. Em árvores, usamos também a 

terminologia Filho e Pai para caracterizar os nodos. Um nodo pai em 

uma árvore binária pode possuir dois filhos, o filho esquerdo (raiz da 

subárvore esquerda) e o nodo direito (raiz da subárvore direita). 


3.3.1 Árvore Binária de Pesquisa 

Uma árvore binária pode ser usada como uma estrutura altamente 

eficiente para a busca de informações. Essa estrutura chama-se árvore 

binária de pesquisa. 

Árvore Binária de Pesquisa 

Uma Árvore Binária de Pesquisa é uma Árvore Binária 

na qual: 

Os nodos possuem uma chave de busca única; 

Considerando a chave de busca, os elementos da 

sub-arvore esquerda são menores que o 

elemento do nodo raiz e os elementos da 

subárvore direita são maiores que a do nodo 

raiz. 

A árvore da Figura 20 é uma árvore de binária de pesquisa. 

sub-árvore 

esquerda 

5 

Nodo RAIZ 

2 7 12 

18 


10 


15 

sub-árvore 

direita 

1 3 6 8 11 14 

NULL 

20 

Figura 20: Árvore Binária de Pesquisa 

Note que todos os elementos da subárvore esquerda do nodo raiz são 

menores que 10 e todos os elementos da subárvore direita são maiores 

que 10. Essa regra é aplicável em todas as ramificações das 

subárvores. Por exemplo, a subárvore esquerda do nodo 5 só possui 

elementos menores que 5. Já a subárvore direita desse nodo só possui 

elementos maiores que 5. 

Página 83


Página 84 


1. Desenhe uma árvore binária de busca cuja 

seqüência de inserções de elementos foi: 30 10 20 

50 35 e 44. 

2. Desenhe uma árvore binária de pesquisa, em que 

as chaves são letras para a inserção da seqüência 

de letras que compõem o seu nome e seu 

sobrenome, excluindo as repetições e partindo de 

uma árvore inicialmente vazia. 

3. Desenhe uma árvore resultante da retirada da 3ª e 

da 8ª letra da seqüência composta por seu nome + 

sobrenome. 

3.3.2 O TAD Árvore Binária de Pesquisa 

Para tornar a manipulação de árvores binárias de pesquisa mais 

simples, iremos definir um tipo abstrato de dados, considerando suas 

operações primitivas. Essas operações são apresentadas na Figura 21. 

Figura 21: especificação do TAD Árvore. 


A inicialização da árvore leva essa árvore para o estado de vazia, sem 

nenhum nodo. Essa operação só deve ser utilizada no início da 

operação da árvore. Após isto, uma árvore só se tornará vazia se todos 

os seus elementos forem excluídos. 

As operações de inserção devem respeitar a regra básica da árvore 

binária de pesquisa: Toda subárvore à esquerda de um nodo N só 

possui elementos com chaves de busca menores que a do nodo N; e 

toda subárvore à direita de um nodo N só possui elementos com 

chaves de busca maiores que a do nodo N. Assim, ao inserir um 

elemento na lista, deve-se definir a posição em que ele será inserido, 

com base nessa regra. 

A operação de pesquisa visa encontrar um elemento contido na árvore 

dada, um valor de chave de busca. Essa pesquisa deve se basear 

também nessa regra. Isso tornará a pesquisa extremamente eficiente se 

comparada com a pesquisa em uma lista seqüencial. Por exemplo, 

suponha que estejamos procurando o elemento 8 na árvore da Figura 

20. A pesquisa inicia-se pelo nodo raiz (10). As chaves são 

comparadas. Como 8 é menor que 10, sigo a pesquisa pela árvore 

esquerda e comparo 8 agora com o nodo (5). Dessa vez (8) é maior e 

agora sigo pela subárvore direita, comparando com o nodo (7). Mais 

uma vez, 8 é maior e sigo procurando na subárvore direita onde 

finalmente o nodo 8 é encontrado. 

A remoção deve seguir o mesmo princípio da pesquisa para localizar o 

nodo a ser removido. A remoção em si também deve ser 

implementada de forma que a regra de árvores binárias de pesquisa 

não seja violada. 

3.3.3 Implementação do TAD árvore Binária de Pesquisa 

A Figura 22 apresenta a implementação da interface do TAD 

árvoreBinária. 

Figura 22: Interface do TAD Árvore Binária 

O nodo da árvore possui, como nas implementações anteriores, o 

campo de informação e o do tipo Elemento. Cada nodo da árvore 



Página 85


Página 86 

possui também dois apontadores, esq e dir, que apontam 

respectivamente para as subárvores à esquerda e à direita do nodo. 

Além das operações já previstas no TAD, incluímos a operação 

imprimeOrdemCrescente. 

Quando declaramos uma variável do tipo Arvore, estamos definindo 

uma variável capaz de armazenar um ponteiro para struct nodo. 

Usaremos essa variável para apontar para o nodo raiz da árvore. Se 

ainda não existe nenhum nodo na árvore, esse ponteiro deve apontar 

para NULL. A operação de inicialização é idêntica às operações de 

inicialização de listas encadeadas e atribui NULL ao ponteiro que 

aponta para a raiz da árvore. A Figura 23 apresenta está operação 

Figura 23: Implementação da operação de inicicalização da árvore. 

Recursividade 

Árvores são estruturas definas recursivamente. Dessa 

forma, a recursividade será um mecanismo 

fundamental para simplificar a implementação das 

operações sobre essas estruturas. Caso você não esteja 

se sentido seguro quanto à recursividade, recomendo 

que volte ao material de programação II e estude o 

assunto. 

Inserção em Árvores Binárias de Pesquisa 

A operação de inserção pode ser descrita pelo seguinte algoritmo: 


Esse algoritmo tenta inserir o elemento em uma subárvore ainda vazia. 

O algoritmo se inicia recebendo um ponteiro para o nodo raiz da 

árvore. Se o ponteiro não apontar para NULL, a árvore não estará vazia 

e “a raiz já está ocupada”. Assim, existem duas opções: Inserir o 

elemento à esquerda da raiz ou à direita. Essa decisão é tomada 

comparando-se a chave de busca (código) do nodo a ser inserido com 

a chave de busca do nodo da raiz. Se a chave do nodo a ser inserido é 

menor que a do nodo raiz, o algoritmo tenta inserir na sub arvore à 

esquerda. Se for maior tenta-se inserir na subárvore à direita. Lembrese 

de que na árvore binária de pesquisa as chaves de busca são únicas. 

Ou seja, não pode haver dois ou mais nodos com a mesma chave. 

Assim se o código do nodo a ser inserido for igual ao código do nodo 

raiz, o algoritmo termina e não corre a inserção. 

Por exemplo, suponha a inserção de um elemento com código igual a 

4 na árvore da Figura 20. Nesse caso, o algoritmo se inicia 

comparando 4 com 10 (raiz da árvore). Como 4 é menor, a operação 

é novamente executada (recursivamente), agora tentando inserir o 4 na 

subárvore à esquerda da raiz. Esse processo se repete recursivamente 

até que a subárvore à direita do nodo 3 seja atingida. Essa subárvore é 

vazia. Conseqüentemente, o ponteiro dir do nodo 3 está apontando 

para NULL. O algoritmo então aloca o nodo para o elemento com 

código igual a 4 e atribui o endereço desse novo nodo ao ponteiro 

dir do nodo 3. 

A Figura 24 ilustra a Árvore da Figura 20, agora com o nodo 4 

inserido. A linha pontilhada mostra o “percurso” das chamadas 



Página 87


Página 88 

recursivas até a inserção do elemento. A Figura 25 apresenta a 

implementação da função de inserção. Essa operação recebe como 

parâmetros um ponteiro para Árvore (*t) e o elemento a ser inserido 

(e). 

sub-árvore 

esquerda 

5 

Nodo RAIZ 

2 7 12 

18 

10 

15 

sub-árvore 

direita 

1 3 6 8 11 14 

NULL 

20 

4 

Figura 24: Inserção do elemento 4 na árvore. 

O primeiro if testa se o valor de *t é NULL. Nesse caso o elemento 

é inserido. Caso contrário, ocorrem chamadas recursivas da função 

insere, para a esquerda ou para a direita, conforme algoritmo. É ainda 

possível que o elemento já exista na árvore. Nesse caso a mensagem 

Já existe um nodo com esta chave! é impressa. 

As chamadas recursivas são feitas passando o endereço dos 

apontadores: insere(&(*t)->esq,e); ou insere(&(*t)- 

>dir,e); Isso é necessário, pois o conteúdo desses apontadores 

deverá ser alterado na inserção. 


Figura 25: TAD Arvore Binária: implementação da operação Insere. 

Figura 26: TAD Arvore Binária: implementação da operação Pesquisa 


4. Desenhar a inserção dos elementos 13, 0 e 16 na 

árvore da Figura 24. 

Pesquisa em Árvores Binárias de Pesquisa 

A operação pesquisa visa retornar um elemento contido na árvore 

t, sendo passado um valor de código (chave de busca). O Elemento 

encontrado deve ser passado por meio do parâmetro ret, que é um 

ponteiro para Elemento. Essa operação também é implementada de 

forma recursiva e deve receber o endereço da raiz da árvore. Como a 

árvore não sofre alterações na pesquisa, apenas o valor do endereço do 

nodo raiz e (e das subárvores nas chamadas recursivas) é suficiente. 



Página 89


Página 90 

Eficiência da Pesquisa 

A eficiência da pesquisa em uma árvore binária de 

pesquisa é a sua maior vantagem. Para localizar um 

elemento em uma árvore com N elementos e construída 

aleatoriamente, são necessárias aproximadamente log2 

N consultas. Para se ter um idéia do que isso representa, 

uma pesquisa seqüencial em uma lista linear contendo 

1,000,000 de elementos realiza em média 500,000 

consultas para encontrar um elemento. Em uma árvore 

essa mesma pesquisa gastaria log2 1,000,000 20 

consultas. 

Isso acontece porque, a cada verificação, metade dos 

dados a serem pesquisados é descartada 

(correspondente a subárvore à direita ou à esquerda do 

elemento verificado). 

A pesquisa só é degradada quando a árvore é construída 

de tal forma que a sua estrutura se torna uma lista 

linear. Isso acontece, por exemplo, se os elementos da 

árvore forem inseridos em ordem, de acordo com a 

chave de busca. Por Exemplo, a construção de uma 

árvore com a seqüência 1, 2,3,20,30, 40,41,42, vai 

produzir uma lista linear. 

Remoção em Árvores Binárias de Pesquisa 

Para a remoção de um elemento da árvore devemos considerar dois 

casos distintos: 

1. O elemento a ser removido está em um nodo que possui, no 

máximo, uma subárvore; 

Nesse caso, a remoção é mais simples, podendo ocorrer: 

a) quando esq do nodo aponta para NULL; 

b) quando dir do nodo aponta para NULL; 

c) quando esq e dir apontam para NULL. 

2. O elemento a ser removido está em um nodo que possui as 

duas subárvores. 

A Figura 27 apresenta a remoção do elemento 11 que não possui 

filhos, ou seja, não possui nem subárvore à direita nem à esquerda. 


12 

11 14 

15 


18 

20 


12 


14 

Figura 27: Removendo Elemento sem Filhos. 

Nesse caso a remoção é simples, bastando que o elemento seja 

encontrado e o nodo removido. 

12 

11 14 

15 

18 

20 


12 

11 14 

Figura 28: Removendo um Elemento com Apenas um Filho 

A Figura 28 apresenta a remoção do elemento 18, que possui 

subárvore à direita. Nesse caso, como o nodo não possui subárvore à 

esquerda, basta que o filho direito (20) ocupe o lugar do elemento 18. 

Isso pode ser realizado fazendo o apontador dir do nodo 15 apontar 

para o filho direito do nodo 18. Quando o nodo só possui subárvore à 

esquerda, essa operação ocorre de maneira simétrica. Ou seja, o nodo 

a ser eliminado é substituído por seu filho esquerdo. 

A Figura 29 apresenta agora a remoção de um nodo que possui as 

duas subárvores. Nessa situação, a remoção pode ser feita de duas 

maneiras: substituindo o elemento removido por seu sucessor ou 

substituindo o nodo removido por seu antecessor. 

Sucessor e antecessor de um nodo em uma árvore 

binária de busca 

Sucessor - Filho mais à esquerda de sua subárvore 

direita. 

Antecessor - Filho mais à direita de sua subárvore 

esquerda. 

15 

15 

18 

20 

20 

Página 91


Página 92 

12 

11 14 

15 

18 

20 


Troca pelo sucessor 

Troca pelo antecessor 

12 

11 14 

Figura 29:Remoção de um Nodo que Possui as Duas Subárvores. 

O sucessor do nodo 15 é o nodo 18 e representa o elemento que 

sucede o 15, considerando a ordenação dos elementos na árvore, pela 

chave de busca. Considerando a árvore do exemplo, temos a seguinte 

ordem de sucessão: [11,12,14,15,18,20]. O antecessor, por outro lado, 

é o nodo que possui o elemento imediatamente maior que o elemento 

a ser removido. No caso, o antecessor de 15 é o elemento 14. 

11 

Por que sucessor e antecessor? 

Devemos substituir o nodo por seu sucessor ou seu 

antecessor para não violar a regra de formação da 

árvore binária de pesquisa, em que devemos ter 

elementos menores à esquerda de cada nodo e 

elementos maiores à direita de cada nodo. 

Para implementar a remoção, primeiramente temos que localizar o 

nodo a ser removido. Para isso utilizamos recursividade. A 

Figura 30 apresenta o início da operação de remoção. O elemento a ser 

eliminado é o elemento com chave de busca igual a código. A 

operação faz a busca pelo elemento a ser eliminado na árvore, 

posicionando t na variável ponteiro (*t) que aponta para o nodo a 

ser eliminado. Por exemplo, no caso da remoção do nodo 11, essa 

variável corresponde ao ponteiro esq do nodo 12. 

12 


14 

18 

18 

20 

20

Figura 30: Início da Operação de Remoção: o Nodo é Localizado. 

Caso o nodo com o código procurado não exista, a pesquisa segue até 

achar um apontador que aponte para NULL. Enquanto isso não ocorre 

e o elemento não é encontrado, a busca segue ou para a subárvore à 

esquerda ou para a subárvore à direita. Quando o elemento é 

encontrado (o último else é executado) , a operação precisa verificar 

se o elemento a ser eliminado está no caso 1 (um nodo que possui, no 

máximo, uma subárvore) ou no caso 2 (em um nodo que possui duas 

subárvores) . 

Vamos discutir separadamente os casos 1 e 2. 

A Figura 31 apresenta o excerto de código de que trata o caso 1. Para 

esse caso, basta verificar que uma das subárvores é vazia. O Fato das 

duas serem vazias é indiferente. Optamos por testar primeiro se a 

subárvore à esquerda é vazia. Nesse caso, uma variável auxiliar (aux) 

é usada para guardar o valor do endereço do nodo a ser eliminado. O 

ponteiro que antes apontava para o nodo a ser eliminado (t) passa a 

apontar para o nodo à direita. Caso a subárvore à esquerda não seja 

vazia, verificamos se a subárvore à direita é vazia. Nesse caso, o 

ponteiro t passa a apontar para o nodo à esquerda do nodo a ser 

eliminado. Em ambos os casos, o nodo eliminado é liberado por meio 

da função free. 



Página 93


Página 94 

Figura: 3.31: Remoção: é verificado se o nodo possui no máximo uma subárvore. 

Figura 32: Remoção quando o nodo possui as duas subárvores. 

A Figura 32 apresenta a implementação do caso 2 (o nodo possui as 

duas subárvores). Para facilitar essa operação, em vez de eliminarmos 

o nodo que contém o elemento a ser eliminado, o conteúdo do nodo a 

ser eliminado será substituído pelo seu antecessor e o nodo antecessor 

é que será eliminado. Esse procedimento é realizado pela operação 

antecessor, chamada pela função remove. 

Figura 33: Implementação da Operação Antecessor. 

A Figura 33 apresenta a implementação dessa operação, que também 

utiliza recursividade para a localização do nodo antecessor. Veja na 

Figura 32 que a chamada de antecessor passa: 


o endereço do nodo a ser eliminado (*t), no lugar do 

parâmetro q; 

o ponteiro para subárvore à esquerda do nodo a ser eliminada 

((*t)->esq), no lugar do parâmetro r; 

Conforme a definição de antecessor (pag. 76), a partir da raiz da 

subárvore à esquerda, são feitas chamadas recursivas passando sempre 

o ponteiro para a subárvore à direita, até que o nodo mais à direita seja 

encontrado. Quando isso ocorre, a recursividade determina a execução 

das seguintes ações: 

r 

1. Substituir o elemento do nodo a ser eliminado pelo elemento 

de seu antecessor : q->e=(*r)->e; 

2. Guardar o endereço do antecessor em uma variável auxiliar: 

paux = *r; 

3. Fazer a referência para o antecessor receber o endereço do 

filho esquerdo do antecessor: *r= (*r)->esq; 

4. Remover o nodo que possuía o antecessor: free(paux); 

q 

12 

11 14 

13 

15 


18 

*t 

20 

antecessor(*t,&((*t)->esq)); 

q 

12 

11 14 

13 

14 

r 

*r= (*r)->esq; 

paux 

18 

*t 

20 

q 

12 

11 14 

11 

13 

14 

r 


18 

paux 

*t 

20 

antecessor(q,&(*r)->dir); 

.. 

q->e=(*r)->e; 

paux = *r; 

q 

12 

13 

14 

r 

18 

free(paux); 

Figura 33: Remoção do elemento 15 da lista. O antecessor é o elemento 14. 

A Figura 34 ilustra a execução da operação antecessor desde a sua 

chamada para eliminar o elemento 15. Nessa árvore, veja que o 

antecessor é o nodo 14, que possui subárvore à esquerda. Assim, ao 

*t 

20 

Página 95


Página 96 

final da remoção, o ponteiro dir do nodo que contém o elemento 12 

vai ter que apontar para o nodo à esquerda de 14. 


5. Implementar a função sucessor, equivalente a 

antecessor usada na operação remove. Depois, 

modificar a operação remove para que o elemento a ser 

removido seja substituído por seu sucessor. 

Impressão em Árvores de Pesquisa Binária 

Para imprimir os elementos de uma árvore binária de busca, basta 

percorrer a árvore usando recursividade. É possível, inclusive, 

imprimir os elementos da árvore em ordem, crescente ou decrescente. 

O Código da Figura 34 apresenta a implementação da impressão em 

ordem crescente. 

Figura 34: impressão dos elementos em ordem crescente. 

Essa operação visita todos os nodos da árvore, fazendo chamadas 

recursivas à esquerda e à direita de cada nodo. Quando um nodo folha 

à esquerda é encontrado: 

a recursividade é interrompida; 

o elemento desse nodo é impresso; 

a recursividade é ativada, chamando o nodo à direita do nodo 

impresso; 

Essa forma de impressão baseia-se no caminhamento central, no qual 

os elementos serão visitados ordenadamente. 


12 

11 14 


18 

20 

imprime(18)// esq 

imprime(12)//esq 

imprime(11)//esq 

fim da recursao 

printf(11) 

printf(12) 

imprime(14) // dir 


printf(14) 

printf(18) 

imprime(20)//dir 


printf(20) 

Figura 35: Seqüência de impressão para o Caminhamento Central. 

A Figura 35 ilustra a execução da operação de impressão utilizando 

caminhamento central. A ocorrências de imprime correspondem à 

ordem das chamadas recursivas da operação imprimeElemento 

da Figura 34. Veja que essa representação é meramente algorítmica 

(não usamos ponteiros). O comando printf corresponde ao 

printf na implementação da Figura 34. 

Implementamos, além do TAD ArvoreBinaria, um módulo 

(principal) para teste. Não apresentamos esse módulo aqui, mas o 

mesmo se encontra disponível no material on-line. 

Análise da Árvore Binária de Pesquisa 

Conforme citamos no início dessa seção, árvores 

binárias de pesquisa são excelentes estruturas para o 

armazenamento e a recuperação de informações. Isso 

se deve à eficiência de suas operações de inserção, 

remoção e pesquisa. Já comentamos a eficiência da 

pesquisa. A inserção e a remoção eficientes tornam o 

custo de manutenção dos dados baixo. Ou seja, novos 

dados podem ser inseridos e outros removidos sem 

comprometer a eficiência do sistema. Outra facilidade é 

a listagem ordenada dos dados (impressão), que nem 

sempre é possível em estruturas de pesquisa. Usando 

Hashing (Cap. 4) por exemplo, não é possível listar os 

dados ordenadamente. 


Página 97


Página 98 


6. Implementar a operação imprime de forma que os 

elementos da árvore sejam impressos: 

em ordem decrescente 

na ordem em que foram inseridos 

Utilize o TAD Árvore Binária para implementar uma 

agenda telefônica de celular. Veja as funções de agenda 

existentes em um telefone celular e tente implementá-las. 

Enfim, terminamos este capítulo. Como é comum no 

estudo de estruturas de dados dinâmicas, este capítulo 

deve ter exigido de você um grande esforço de 

concentração e de raciocínio lógico. Espero que tenha 

realizado todas as tarefas e estudado de forma 

complementar o livro texto, pois, somente assim, o 

estudo terá o efeito desejado. Até o próximo capítulo! 


4. PESQUISA EM MEMÓRIA PRIMÁRIA. 

Olá! Iremos neste Capítulo tratar do assunto 

pesquisa. A palavra pesquisa, aqui, tem o 

significado estrito de busca. Iremos buscar objetos 

de informação. Você certamente já pesquisou 

muitas coisas na sua vida: brinquedos, roupas, 

chaves, livros e pessoas estão entre as “coisas” que 

mais procuramos! Se você já fez isso, já deve ter 

se aborrecido ao não encontrar (ou demorar muito 

para encontrar) o objeto ou pessoa que procura. 

Mas, ao demorar a encontrar um objeto, você já se 

perguntou se está procurando da maneira correta? 

Normalmente,, é difícil encontrar algo em um 

conjunto de elementos se não usarmos a estratégia 

de busca apropriada para o modelo de organização 

do conjunto? Neste Capítulo iremos discutir e 

aprender sobre essas estratégias de busca e discutir 

aspectos da pesquisa de diferentes organizações do 

conjunto onde procuramos. Mão à obra então! 

A pesquisa em memória primária envolve a busca por objetos de 

informação armazenados em estruturas de dados instanciadas na 

memória primária do computador. Não iremos tratar aqui da pesquisa 

em memória secundária, que envolve outras técnicas. 

Nosso estudo vai compreender a pesquisa simples, onde sabemos 

exatamente qual o objeto que queremos. Normalmente sabemos qual é 

esse objeto por meio de uma informação que o diferencia de todos os 

demais objetos. Chamaremos essa informação de chave de pesquisa. 

Chave de Pesquisa 

A pesquisa em memória primária será feita com 

base em uma CHAVE DE PESQUISA. A chave 

de pesquisa pode ser um elemento de dado do 

objeto. Por exemplo, o RG de uma pessoa, o CNPJ 

de uma empresa ou o número de matrícula de um 

estudante. Pode ser também o nome de um país, ou 

o ISBN de um livro. O importante da chave de 

pesquisa é que ela seja única, de forma a permitir 

que cada elemento do conjunto seja unicamente 

identificável pela sua chave de pesquisa. 

A idéia básica da pesquisa, portanto, é: dado um conjunto de dados e 

uma chave, localizar um elemento nesse conjunto cujo valor da chave 

de pesquisa seja o mesmo da chave usada. A chave de pesquisa é 



Página 99


Página 100 

escolhida e definida pelo programador com base no problema 

específico que ele está tratando. Por exemple, em um conjunto de 

dados que cataloga os computadores de uma empresa, a chave de 

pesquisa pode ser o número de série do computador ou de seu 

patrimônio. 

O conjunto pode ser organizado e armazenado usando diferentes 

estruturas e tipos abstratos de dados: Vetores, listas encadeadas, 

árvores. Já estudamos no capítulo anterior o algoritmo de pesquisa em 

listas e em árvores binárias de pesquisa. Neste capítulo iremos analisar 

em maiores detalhes esses e outros algoritmos. 

Em uma pesquisa, o conceito de eficiência é muito importante. A 

eficiência pode ser medida pelo número de inspeções realizadas até 

encontrar o objeto procurado. Evidentemente, quanto menos inspeções 

forem feitas, mais eficiente será a pesquisa. 

Inspeção 

Uma inspeção consiste na operação de comparação 

da chave procurada com a chave de busca de um 

objeto, visando verificar se o objeto em questão é 

que procuramos. 

Iremos estudar algoritmos de pesquisa para as três seguintes situações: 

1. Os dados estão dispostos de forma desordenada e desconhecida 

em uma lista linear (um vetor ou uma lista encadeada). Esse 

cenário pode ser comparado a uma busca onde não há pistas 

sobre em que lugar o objeto está. Dessa forma, a única 

alternativa que temos é realizar uma busca exaustiva visitando 

todos os lugares até o objeto ser encontrado. A única forma de 

determinar se o objeto não está presente é inspecionar todos os 

lugares. 

2. Os dados estão dispostos de forma ordenada em uma lista 

linear (um vetor ou uma lista encadeada). Nesse cenário, a 

busca é facilitada porque os objetos foram guardados usando 

alguma forma de ordenação baseada na chave de busca. Se os 

objetos forem armazenados, por exemplo, colocando os 

objetos em uma seqüência iniciando pelo menor e terminando 

pelo maior, a busca poderá ser feita sem a necessidade de 

inspecionar todos os objetos. 

3. Os dados estão dispostos em de forma não ordenada, porém as 

posições onde os dados estão localizados podem ser 

calculadas usando a chave de pesquisa. Essa situação é a que 

acontece nas chamadas tabelas Hash onde os elementos são 

inseridos em posições calculadas a partir de sua chave de 

pesquisa. 


Iremos estudar a aplicação de três métodos de ordenação aplicáveis a 

esses cenários. Os métodos consistem em Pesquisa Seqüencial, 

Pesquisa Binária e Hashing. As seções a seguir detalham esses 

métodos. 


Suponha um baralho contendo 40 cartas todas 

diferentes, distribuídas de forma totalmente aleatória. 

Pense em uma carta específica e responda: 

a) Qual a propobilidade da primeira carta do 

baralho ser a que você pensou? 

b) Qual a propobilidade da segunda carta ser a 

que você pensou? E da terceira? 

c) Qual a probabilidade de encontrar a carta após 

4 tentativas? 

d) Em média quantas cartas terão que ser 

inspecionadas para você encontrar a carta que 

pensou? 

4.1 PESQUISA SEQÜENCIAL 

A pesquisa seqüencial é realizada inspecionando-se o conjunto de 

objeto seqüencialmente, do início para o fim ou vice-versa. Duas 

situações podem ocorrer: 

Pesquisa com sucesso: O elemento é encontrado em uma das 

posições do conjunto 

Pesquisa sem sucesso: O conjunto e completamente percorrido e o 

elemento não é encontrado. 

Normalmente fazemos dois testes: verificamos se o elemento 

procurado corresponde ao objeto inspecionado e verificamos se o 

limite do conjunto de objetos foi atingido. Por exemplo, o código 

abaixo faz isso: 

Para melhorar essa implementação, iremos apresentar um algoritmo 

de pesquisa seqüencial que utiliza uma sentinela. O uso de sentinelas 

torna a pesquisa seqüencial mais eficiente. 



Página 101


Página 102 

Sentinela 

Sentinela é um valor conhecido que é inserido em 

uma posição específica de um arranjo ou de uma 

lista. O objetivo é usarmos o valor do sentinela 

para pararmos um processamento ou uma busca. 

Por exemplo, quando buscamos um valor x em um 

vetor que vai de 0 a n, e inserimos o valor x como 

sentinela na posição n+1. Assim, a busca pode ser 

feita até encontrarmos o valor do sentinela, sem a 

necessidade de testarmos se chegamos até o limite 

do arranjo. O código abaixo ilustra este cenário: 

// buscando x 

v[n+1] = x; // atribui o sentinela 

i = 0; 

while (v[i] != x) { 

} 

i++; 

4.1.1 Implementação da Pesquisa Seqüencial 

Continuaremos a apresentar nossas implementações respeitando o 

conceito de TAD. Neste capitulo, iremos usar o TAD Tabela, que 

nada mais é conjunto do tipo Elemento (já visto em listas encadeadas). 

O tipo tabela é apresentado na Figura 1. 

Figura 1: Interface do TAD Tabela 

As implementações das operações inicializaTabela, tabelaCheia e 

insereElemento são apresentadas na Figura 2. A Figura 3 apresenta a 

implementação da operação de pesquisaSeqElemento. Essa operação 

possui como parâmetro a tabela onde pesquisar e o valor da chave 

utilizada para a pesquisa. A função retorna -1 em caso de pesquisa 

sem sucesso e o índice da posição do elemento procurado, em caso de 


pesquisa sem sucesso. Note que foi usado o sentinela (inserido na 

posição n+1 da tabela). 

Figura 2: Implementação das operações do TAD Tabela 

Figura 3: Implementação da operação pesquisaSequencial 

4.1.2 Tempo de execução de algoritmos 

Os métodos de pesquisa são um bom tópico em nosso curso para 

introduzirmos algumas noções sobre desempenho de algoritmos. Para 

iniciar esta discussão, vamos nos reportar a uma pergunta? É possível 

determinar quanto tempo à operação de pesquisa seqüencial leva 

para encontrar um elemento? 



Página 103


Página 104 

Existem importantes elementos estão envolvidos nesta pergunta. A 

saber: 

1. A Máquina que será usada para executar o programa. 

2. O tamanho total dos dados 

Evidentemente, o tempo de uma pesquisa vai mudar dependendo do 

computador que for utilizado. Quanto mais rápido o computador, mais 

rápida será a pesquisa. A mudança de desempenho de um computador 

para outro pode ser expresso por uma constante C. Assim diremos que 

o tempo gasto por um programa para executar pode ser expresso por 

uma função. 

T f(n).C 

Em que C é a constante associada ao computador. n, por sua vez, é o 

tamanho da entrada de Dados. Ou seja, o tempo de execução da 

função de pesquisa é uma função do tamanho da entrada de 

dados. 

Função de complexidade de tempo 

Quando analisamos o tempo de execução é comum 

deixarmos a constante C de lado e nos concentramos na 

função f(n). Essa função é importante, pois ela nos dá 

uma medida de tempo de execução independente do 

computador que será utilizado para executar a operação. 

A função f(n) é denominada de função de complexidade 

de tempo. 

Um outro aspecto importante na análise de desempenho de algoritmos 

são os diferentes casos ou cenários de execução possíveis. São 

geralmente considerados os seguintes casos: 

Melhor Caso: Compreende a melhor situação para o 

algoritmo. A situação em que a resposta será obtida de forma 

mais rápida. 

Caso Médio: Compreende a média de todos os casos 

considerando as distribuições de probabilidade típicas para os 

dados em questão. 

Pior Caso: Compreende a pior situação para o algoritmo em 

questão. 

Podemos determinar a função de complexidade de tempo para estes 

três casos para o algoritmo de pesquisa seqüencial: 

Melhor caso: f(n) = 1, ocorre quando o elemento procurado é o 

primeiro a ser inspecionado. 


Pior caso: f(n) = n, ocorre quando o elemento procurado é o último 

elemento do conjunto a ser inspecionado. 

Caso médio: f(n) = (n+1)/2 

O caso médio é obtido da seguinte forma: seja x o elemento procurado 

e C = {c1,c2,c3..cn}, o conjunto de elementos a ser pesquisado. 

Considera-se para este cálculo que a possibilidade de encontrar o 

elemento procurado é igualmente provável para qualquer posição do 

conjunto de elementos pesquisado. Ou seja, P(x=c1) = P(x=c2) = ... 

P(x=cn) = 1/n. 

Temos ainda que, para encontrar o elemento procurado na i-ésima 

posição do conjunto, são necessárias i inspeções. Por exemplo, para 

encontrar o elemento na primeira posição é necessária uma 

comparação. Para encontrar o elemento na segunda posição são 

necessárias duas comparações. E assim por diante. 

Sendo assim, temos: 

f(n) = 1 * P(x=c1) +2 * P(x=c2)+3* P(x=c3) + .. + n* P(x=cn) f(n) = 1 * 1/n + 2 * 1/n + 3 * 1/n + ... + n * 1/n 

f(n) = (1+2+3+...+n) *1/n 

f(n) = n*(n+1)/2 *1/n 

f(n) = (n+1)/2 




1. Desenvolva um programa utilizando o TAD 

Tabela que meça o tempo de execução da pesquisa 

seqüencial. Altere o código da tabela para aceitar 

um conjunto de até 100.000 itens. Pesquise por 

alternativas para medir o tempo de execução de 

um programa. Planeje sua estratégia para medir o 

tempo. 

2. No estudo da pesquisa seqüencial, a busca não 

leva em conta a organização dos dados no 

conjunto. Caso os dados se encontrem ordenados, 

por exemplo, em ordem crescente, a pesquisa 

seqüencial pode tirar partido desta ordenação 

interrompendo a busca ao encontrar um elemento 

maior que o que foi procurado. Implemente um 

nova operação no TAD Tabela que realize esta 

pesquisa considerando que os dados estão 

ordenados em ordem crescente. Para testar esta 

operação os dados devem ser inseridos ordenadamente 

na tabela. 

Página 105


Página 106 

4.2 PESQUISA BINÁRIA 

Caso o conjunto de dados de pesquisa esteja ordenado, podemos 

utilizar a pesquisa binária para encontrar elementos no conjunto. A 

Pesquisa binária consiste em uma técnica do tipo Dividir para 

Conquistar (Divide to Conquer), na qual o conjunto de dados 

pesquisado é sistematicamente reduzido à metade a cada inspeção 

realizada. 

Figura 4: Divisão dos dados na Pesquisa Binária 

A Figura 4 representa o método de divisão dos dados que ocorre na 

pesquisa binária. O quadro inteiro representa o conjunto completo dos 

dados. As inspeções são feitas no elemento central dos dados. Se o 

elemento inspecionado é menor que procurado, o algoritmo descarta 

todos os elementos que são maiores que o elemento inspecionado. Ou 

seja, a metade dos dados é descartada (parte amarela). O algoritmo 

segue o mesmo procedimento agora inspecionando o elemento central 

dos elementos que sobraram, até encontrar o elemento ou não 

restarem mais elementos a serem inspecionados. Utilizando este 

método, a pesquisa binária consegue localizar o elemento desejado 

com desempenho muito melhor que a pesquisa seqüencial. As divisões 

sucessivas levam a localização de elemento em tempo logarítmico, 

conforme veremos a seguir. 

Vejamos agora a pesquisa binária usando como exemplo um vetor 

ordenado de elementos a seguir: 

0 1 2 3 4 5 6 7 8 

A D E F G J M N O 

Suponha que o elemento procurado seja o ‘D’. 

Suponha também que os limites inferior e superior do vetor sejam 

denotados pelas variáveis inicio e fim. 

No começo da pesquisa inicio = 0 e fim = 8 


A pesquisa é iniciada inspecionando o elemento central do Vetor. Este 

elemento determinado pela média entre inicio e fim: 

3. meio = (inicio+fim)/2 = 4 

Para primeira inspeção meio = 4; Como ‘D’ é menor que ‘G’, toda a 

metade superior do vetor é descartada. No algoritmo este descarte é 

feito recalculando o valor de fim: 

4. fim = meio-1 = 3 

O valor de meio é recalculado agora para determinar o meio da 

metade inferior: 

5. meio = (inicio+fim)/2 = 1 

Agora, com meio = 1, o item procurado é encontrado. 

O algoritmo completo da pesquisa binária é mostrado na 

implementação da operação pesquisaBinária para o TAD Tabela 

(Figura 5). 

Figura 5: Implementação da operação pesquisaBinária 

Conforme já mencionado, a pesquisa binária apresenta 

comportamento logarítmico. A Função de complexidade de tempo é 

dada por: 

f(n) = log2(n) Para ilustrar o que significa esta eficiência logarítmica, suponha que 

você esteja procurando registros em uma tabela com 1.000.000 de 

registros. Se você utiliza a pesquisa seqüencial, vai levar em média 

(n+1)/2 = ~ 500.000 inspeções para cada pesquisa. Utilizando a 

pesquisa binária, cada pesquisa vai ter um custo de log2 1.000.000 = ~ 

20. 



Página 107


Página 108 

Ou seja, usando pesquisa seqüencial realiza-se em media 500.000 

inspeções para encontrar um elemento; ao passo que com a pesquisa 

binária serão necessárias, em média, apenas 20 (vinte) inspeções! 


1. Desenvolva um programa utilizando o TAD 

Tabela que meça o tempo de execução da pesquisa 

seqüencial. Altere o código da tabela para aceitar 

um conjunto de até 100.000 itens. Pesquise por 

alternativas para medir o tempo de execução de 

um programa. Planeje sua estratégia para medir o 

tempo. 

2. Implemente uma versão recursiva da pesquisa 

binária. 

4.3 TABELAS HASH 

Até o momento, discutimos métodos de pesquisa baseados na 

comparação explícita da chave de busca. Nesses métodos, se 

pesquisamos algum objeto com chave de pesquisa igual a X, 

procuramos até encontrar o objeto com o valor de identificador igual a 

X. Nesta seção iremos estudar uma abordagem completamente 

diferente. Trata-se das tabelas Hash, método também conhecido como 

espalhamento. 

Embora diferente, o método de espalhamento é bastante simples e 

intuitivo. A fixação dos conceitos de endereço e função hash vai 

facilitar o entendimento do método. 

Tabela Hash: O método de espalhamento permite o 

armazenamento e recuperação de dados em 

estruturas onde cada posição possui um índice 

como, por exemplo, um vetor. Chamaremos estas 

estruturas simplesmente de tabela hash. 

Endereço: Corresponde ao valor de um índice na 

tabela. Os endereços irão variar de 0 até N-1, onde 

N é o tamanho máximo da tabela hash. 

Função hash: é uma função aritmética que tem 

como entrada uma chave e que calcula um valor 


inteiro de um endereço válido na tabela Hash. 

A função a seguir é um exemplo de função hash. 

int h (char * chave){ 

int tam, i,soma=0; 

tam = strlen(chave); 

for(i=0;i


Página 110 

O princípio básico do método de espalhamento é a geração de 

endereços dentro da tabela por meio da função Hash. Esta geração 

ocorre nas seguintes situações: 

(1) Inserção de um registro: Para inserir um registro, a chave (que 

deve se única) é usada para calcular o endereço de 

armazenamento do registro. 

(2) Recuperação de um registro: Para recuperar um registro 

armazenado, com base em um valor chave de pesquisa. Neste 

caso a chave informada é usada para determinar o possível 

endereço de armazenamento do registro procurado. 

Figura 6: A função hash determina o índice com base na chave de pesquisa. 

Um problema que fatalmente ocorre em funções Hash é o cálculo de 

um mesmo endereço para dois valores de chave diferentes. Este 

problema é chamado de colisão. 

Colisão 

A colisão em tabelas hash ocorre quando o mesmo 

endereço na tabela é calculado para diferentes 

valores de chave. Por exemplo, a função Hash 

int h (char * chave){ 

int tam, i,soma=0; 

tam = strlen(chave); 

for(i=0;i

A colisão não pode ser evitada, mas deve ser tratada. A seguir 

veremos como tratar colisões em implementações de tabelas Hash. 

4.3.1 Operações de Inserção e Pesquisa em Tabelas Hash 

Veremos como é feita a inserção e a pesquisa em uma tabela Hash. 

Veremos primeiro uma versão sem tratamento de colisão. 

Implementaremos estas funções como operações do TAD tabelaHash. 

Figura 7: TAD TabelaHash sem tratamento de colisão 

A Figura 7 apresenta o TAD TabelaHash sem tratamento de colisão. 

A tabela utilizada consiste de um vetor de registros do tipo 

Elemento. Apenas lembrando, o tipo Elemento possui os seguintes 

campos: 


int codigo; 

char telefone[10]; 

O campo nome será usado como chave de pesquisa. Assim, fica 

convencionado que os registros armazenados na tabela não 

poderão ter o mesmo nome. 

Usaremos o campo codigo para determinar se um endereço da 

tabela está ocupado ou não. Para tanto, na inicialização da tabela, 

atribuiremos o valor -1 ao código. O valor -1 no campo código 

indicará que o endereço está desocupado. 

O código da operação inicializaTabela é mostrado na Figura 8. 

Conforme pode ser observado, a tabela possui também um contador n 

que mantém o número de elementos da tabela. Implementamos 

também uma função lógica chamada de enderecoOcupado, que 

retorna TRUE se um endereço (end) estiver ocupado e FALSE, caso 

contrário. Esta função é apresentada na Figura 8. 



Página 111


Página 112 

Figura 8: Inicialização da Tabela Hash e função enderecoOcupado. 

A função Hash utilizada é baseada na função h, já apresentada. No 

entanto, para calcular o valor da soma, cada caractere foi multiplicado 

pela sua posição (i+1), evitando a colisão de nomes com mesmo 

conjunto de caracteres. A Figura 9 apresenta esta implementação. 

Figura 9: implementação da função hash 

A inserção de elementos na tabela segue o seguinte algoritmo: 

A implementação da operação de inserção é mostrada na Figura 10. 


Figura 10: Implementação da operação insereElemento. 

Note que, se o endereço calculado já estiver ocupado, ocorre uma 

colisão que não é tratada. Um aviso de colisão é enviado ao usuário e 

a inserção do novo elemento simplesmente não ocorre. 

Conforme já mencionado, colisões em tabelas Hash são inevitáveis, 

mesmo para uma tabela 10 vezes maior que o número de registros a 

ser armazenado, a probabilidade de colisões é ainda muito grande. 

Este comportamento é ilustrado pelo paradoxo do aniversário. 

Paradoxo do aniversário: Se tomarmos um grupo 

de mais de 25 pessoas de forma totalmente aleatório, 

a probabilidade de que haja entre estas pessoas pelo 

menos duas que fazem aniversário na mesma data 

do ano é maior que 50%. Esta medida é 

curiosamente verdadeira, considerando-se que a data 

de aniversário de uma pessoa é uma variável 

aleatória, estas datas deveriam ser uniformemente 

distribuídas entre os dias do ano. 

O paradoxo do aniversário está associado com tabelas Hash. 

Considere uma tabela Hash com 365 endereços disponíveis. Cada 

endereço corresponde a um dia do ano. Ao inserirmos 25 registros 

nesta tabela, usando uma função h totalmente aleatória, a chance de 

haver uma colisão é de 50%. 

Na pesquisa por um elemento, um valor de chave deve ser informado. 

Com base neste valor o endereço é calculado. Se o endereço estiver 

ocupado, o valor do campo nome do elemento é comparado com a 

chave de pesquisa para verificar se o elemento que lá está é realmente 

o elemento procurado. Neste caso o valor de end é retornado. Caso 

contrário o elemento procurado não existe na tabela. A operação de 

pesquisa é apresentada na Figura 11. 



Página 113


Página 114 

Figura 11: Implementação da operação pesquisa. 

4.3.2 Tratamento de Colisões 

Na implementação que realizamos até agora, quando uma colisão 

ocorre, o dado simplesmente não é inserido. Evidentemente este não é 

o comportamento esperado de nenhum sistema de armazenamento de 

informações. Assim, ao invés de simplesmente abortar a inserção, 

iremos tratar o evento da colisão permitindo a inserção de vários 

elementos com chaves diferentes que mapeiam para o mesmo 

endereço. 

Conforme observado na TAD TabelaHash apresentado, na inserção, 

quando o endereço vazio é obtido, o elemento é inserido no mesmo. 

A tabela itens é um vetor de Elemento e cada endereço se refere 

a apenas um elemento. 

Veremos duas formas de tratar a colisão: 

(1) Com listas encadeadas 

(2) Com endereçamento aberto 

No tratamento de colisões com listas encadeadas, a estrutura da tabela 

e alterada. Ao invés de uma tabela de registros é definida uma tabela 

de listas encadeadas, onde cada lista encadeada será o conjunto de 

registros inseridos cujas chaves de pesquisa foram mapeadas para o 

mesmo endereço. A Figura 12 ilustra esta abordagem. 

Figura 12: Tratamento de Colisão com Listas Encadeadas 


A Tabela é formada de um vetor de ponteiros para N listas 

encadeadas. Agora, na inserção, o endereço end é calculado e o 

elemento é inserido na lista encadeada apontada pelo ponteiro da 

posição end. 

A Figura 13 apresenta a implementação da interface do TAD 

tabelaHash com com tratamento de colisão por meio de lista 

encadeada. Este TAD utiliza como cliente o tadLista implementado no 

Capítulo 3. A única modificação neste Tad foi na operação pesquisa 

que agora utiliza o campo nome do registro Elemento como chave e 

recebe a string chave como parâmetro para realizar a pesquisa. O 

TadLista é reapresentado na Figura 14. 

Figura: 13: Interface do TAD Tabela Hash 

Figura 14: Interface do TAD Lista Encadeada 

A Figura 15 apresenta a implementação das operações do TAD 

TabelaHash. 



Página 115


Página 116 

Figura 15: operações inicializaTabela, insereElemento e pesquisaElemento 

4.3.3 Tratamento de Colisão usando endereçamento Aberto 

Outra abordagem para tratar as colisões é o uso de endereçamento 

aberto (open addressing). Nessa abordagem, a estrutura de dados da 

tabela é a mesma originalmente estabelecida (um vetor de registros). 

A técnica de endereçamento aberto consiste nos seguintes 

procedimentos: 

Inserção: 

(1) Calcular o endereço usando a função Hash para o valor de 

chave do registro; 

(2) Se o endereço estiver ocupado, procurar nas posições vizinhas 

ao endereço calculado uma posição vazia. 

Pesquisa: 

(1) Calcular o endereço usando a função Hash e a chave de 

pesquisa fornecida; 

(2) Procurar, a partir do endereço até: 

a. Encontrar o elemento procurado (pesquisa com 

sucesso); 

b. Encontrar uma posição vazia ou o fim da tabela 

(pesquisa sem sucesso). 



8. Modificar a implementação inicial de Hash (sem 

tratamento de colisão) para suportar colisões com a técnica 

de endereçamento aberto. 



Página 117


Página 118 

5. ORDENAÇÃO EM MEMÓRIA PRIMÁRIA. 

Olá. Neste capítulo chegaremos ao fim de nosso 

estudo na disciplina de TPA. Reservei para a 

última etapa o tema Ordenação. A ordenação em 

computação reúne um conjunto de algoritmos que 

permite ordenar um conjunto de dados segundo 

uma determinada chave de ordenação. Neste 

capítulo iremos estudar alguns desses principais 

algoritmos. Se você vasculhar a Internet vai 

encontrar a maioria desses algoritmos 

implementados. Assim você poderá se perguntar: 

para que estudamos esses mecanismos se as suas 

implementações já estão prontas? E mais, porque 

estudar vários métodos de ordenação se existe um 

particularmente que é mais rápido que os outros? 

A resposta é simples: Porque estes algoritmos e 

suas variações reúnem técnicas de programação 

que são de muita valia na resolução de outros 

problemas, alem de tocarem em aspectos 

complexos que, ao serem absorvidos pelo 

estudante são capazes de aprofundar sua 

capacidade de raciocínio e habilidades em 

desenvolver programas. Vamos a ele então. 

5.1 CONCEITOS BÁSICOS DE ORDENAÇÃO 

A ordenação consiste em rearranjar um conjunto de objetos em ordem 

crescente ou decrescente, levando-se em conta uma chave ordenação. 

A ordenação possui motivações óbvias. Em geral, colocamos dados de 

forma ordenada para: 

Facilitar a obtenção de uma informação ao se observar um 

conjunto de dados. Por exemplo, a visualização da 

classificação de candidatos em um concurso fica mais fácil se 

a lista de candidatos estiver ordenada pelo número de pontos 

que fizeram. 

Facilitar a recuperação de uma informação. Por exemplo: obter 

os pontos que um candidato em um concurso fez, sabendo o 

seu nome, fica mais fácil se a lista de candidatos estiver 

ordenada por nome. 


A ordenação pode ser feita considerando diferentes tipos de dados 

para a chave, inteiros, reais, strings. O que importa é estabelecer as 

comparações nos algoritmos de acordo com o tipo de dado da chave 

de ordenação. Na ordenação de um arranjo de registros, com a tabela 

de elementos usada no capítulo anterior, apenas a chave de ordenação 

é usada. Os demais campos do registro são irrelevantes. 

5.1.1 Operações Típicas de processos de Ordenação 

Nos diferentes métodos de ordenação, algumas operações ocorrem 

com mais freqüência e o desempenho dos métodos está geralmente 

associado com a realização dessas operações. As duas operações que 

mais afetam o desempenho dos algoritmos de ordenação são as 

operações de troca e de comparação: 

Troca: Consiste na troca de valores entre duas posições do 

arranjo que está sendo ordenado. Esta operação tem custo 

elevado e é a que mais afeta o desempenho dos algoritmos. A 

operação de troca geralmente é suportada por uma função. A 

Figura 1 apresenta uma implementação da função troca; 

Comparação: consiste nas comparações entre dois valores 

contidos em posições do arranjo com o objetivo de saber qual 

dentre as duas é menor. Embora de menor custo, esta operação 

também afeta bastante o desempenho dos algoritmos devido ao 

fato de serem feitas muitas comparações nos processos de 

ordenação. 

Figura 1: Implementação da função troca 

5.2 MÉTODOS DE ORDENAÇÃO 

Iremos estudar 5 métodos de ordenação diferentes neste capítulo. 

A saber: 

1. Seleção 

2. Inserção 

3. Bolha 

4. Shell 

5. Quicksort 

Dependendo da aplicação e situação, o uso de um método pode ser 

mais conveniente que o outro. Em geral, o quicksort apresenta-se com 

melhor desempenho na maioria das situações. O Método da bolha é o 



Página 119


Página 120 

menos eficiente. Porem a sua simplicidade o torna conveniente para 

ordenar pequenos vetores (com tamanho menor que 20). A seguir 

discutimos cada um destes algoritmos individualmente. 

5.2.1 Ordenação por Seleção 

Este método tem como estratégia selecionar o menor elemento 

remanescente do conjunto não ordenado e mover este elemento para 

sua posição correta. Por exemplo, suponha um arranjo com 4 

elementos. 

O processo de ordenação por seleção determina quem é o menor 

elemento e o insere na primeira posição do vetor. Para tanto, o 

elemento que estava na posição inicial precisa ser colocado na posição 

onde estava o menor. Em seguida o segundo menor é encontrado e 

inserido na segunda posição do arranjo. O Algoritmo segue assim 

sucessivamente até encontrar o último elemento e inseri-lo na última 

posição. 

A Figura 2 apresenta a implementação do algoritmo de seleção. 

Implementação: 

Figura 2: Implementação da Ordenação por Seleção 

Tomando como exemplo o arranjo 

int B[] = {10,3,7,20,1,2,11,0,5,4}; 

a execução da função seleção irá imprimir a seguinte seqüência de 

valores intermediários para o arranjo B até a sua ordenação completa: 

10 3 7 20 1 2 11 0 5 4 

0 3 7 20 1 2 11 10 5 4 (fim da interação i=0) 










O algoritmo de seleção utiliza o índice i como limite inferior da parte 

do arranjo que ainda não está ordenado (de i até n-1). À medida que o 

arranjo vai sendo ordenado este limite vai avançando (laço mais 

externo). O laço mais interno tem como objetivo encontrar o menor 

elemento dentre os elementos que ainda não foram ordenados. min é 

iniciado sempre com o valor de i. Em seguida o laço mais interno (do 

j) se encarrega de verificar se no restante do vetor (posições de i+1 até 

n-1) existe um valor menor que a[min]. Toda vez que isso ocorre, o 

valor de min é atualizado. Ao final de um laço mais interno, a 

variável min vai conter o índice do menor valor no arranjo dentre os 

elementos que não foram ainda ordenados. 

Conforme pode ser visto na saída do programa, na primeira interação 

de i, i=0, o menor elemento contido no vetor é localizado e inserido 

na posição 0. Esta inserção é feita pela operação de troca que ocorre 

ao final de cada iteração do laço mais externo. 

Note que as trocas ocorrem independentemente de haver sido 

encontrado um valor menor que a[i]. Neste caso haverá uma troca 

entre duas posições idênticas, pois o valor de min vai ser igual a i. 

Isso ocorreu nas iterações 6,7 e 8. Caso seja importante melhorar o 

desempenho do algoritmo esta troca entre posições iguais pode ser 

evitada comparando-se o valor de min com i. Se estes forem iguais a 

troca não precisa ser feita. 

5.2.2 Método da Inserção 

Este método é similar ao que o jogador de cartas utiliza: Cada 

elemento a ser ordenado é reposicionado entre os ordenados 

movendo-se os elementos maiores que ele uma posição para a direita e 

posteriormente inserindo-o na posição vaga. 

A Figura 3 apresenta a implementação do algoritmo de Inserção. 

Figura 3: Implementação do método de ordenação por Inserção 



Página 121


Página 122 

A função imprimevetor é chamada a cada iteração do laço while 

(mais interno) e ao fim de cada laço mais externo também. A 

execução desta função sobre o arranjo 

int B[] = {10,3,7,20,1,2,11,0,5,4}; 

produz a seguinte saída: 

10 3 7 20 1 2 11 0 5 4 

10 10 7 20 1 2 11 0 5 4 

3 10 7 20 1 2 11 0 5 4 (fim da iteração i=1) 

3 10 10 20 1 2 11 0 5 4 



3 7 10 20 20 2 11 0 5 4 

3 7 10 10 20 2 11 0 5 4 

3 7 7 10 20 2 11 0 5 4 

3 3 7 10 20 2 11 0 5 4 


1 3 7 10 20 20 11 0 5 4 

1 3 7 10 10 20 11 0 5 4 

1 3 7 7 10 20 11 0 5 4 

1 3 3 7 10 20 11 0 5 4 


1 2 3 7 10 20 20 0 5 4 


1 2 3 7 10 11 20 20 5 4 

1 2 3 7 10 11 11 20 5 4 

1 2 3 7 10 10 11 20 5 4 

1 2 3 7 7 10 11 20 5 4 

1 2 3 3 7 10 11 20 5 4 

1 2 2 3 7 10 11 20 5 4 

1 1 2 3 7 10 11 20 5 4 


0 1 2 3 7 10 11 20 20 4 

0 1 2 3 7 10 11 11 20 4 

0 1 2 3 7 10 10 11 20 4 

0 1 2 3 7 7 10 11 20 4 


0 1 2 3 5 7 10 11 20 20 

0 1 2 3 5 7 10 11 11 20 

0 1 2 3 5 7 10 10 11 20 

0 1 2 3 5 7 7 10 11 20 

0 1 2 3 5 5 7 10 11 20 


Na execução da função o laço mais externo é usado para delimitar os 

elementos do arranjo ainda não inspecionados. A variável x é usada 

para guardar o valor do elemento a ser inserido (a[i]). Na primeira 

iteração este elemento é o 3. Na segunda é o 7. Na terceira é o 10 e 

assim por diante. Nem sempre o elemento em x será substituído. Por 

exemplo, na iteração i=3, o elemento x é igual a 10 e não terá a sua 

posição alterada. O laço while tem a finalidade de percorrer o 

arranjo nas posições entre (i-1 e 0) procurando valores menores que 

x. À medida que estes valores são encontrados eles vão sendo 


deslocados para a direita. O laço while termina quando é 

encontrado um elemento menor que x ou o limite do vetor é atingido. 

5.2.3 Método da Bolha 

O Método da Bolha consiste em percorrer o vetor trocando os 

elementos adjacentes caso necessário. Por este motivo, este método 

realiza muitas trocas. 

A implementação desse método é apresentada na Figura 4. 

Figura 4: Método da Bolha 

A execução do método da bolha sobre o vetor 

int B[] = {10,3,7,20,1,2,11,0,5,4}; 

produz a seguinte saída: 

10 3 7 20 1 2 11 0 5 4 

3 10 7 20 1 2 11 0 5 4 (troca 10 e 3) 

3 7 10 20 1 2 11 0 5 4 (troca 10 e 7) 

3 7 10 1 20 2 11 0 5 4 (troca 20 e 1) 

3 7 10 1 2 20 11 0 5 4 (troca 20 e 2) 

3 7 10 1 2 11 20 0 5 4 (troca 20 e 11) 

3 7 10 1 2 11 0 20 5 4 (troca 20 e 0) 

3 7 10 1 2 11 0 5 20 4 

3 7 10 1 2 11 0 5 4 20 

3 7 1 10 2 11 0 5 4 20 

3 7 1 2 10 11 0 5 4 20 

3 7 1 2 10 0 11 5 4 20 

3 7 1 2 10 0 5 11 4 20 

3 7 1 2 10 0 5 4 11 20 

3 1 7 2 10 0 5 4 11 20 

3 1 2 7 10 0 5 4 11 20 

3 1 2 7 0 10 5 4 11 20 



Página 123


Página 124 

3 1 2 7 0 5 10 4 11 20 

3 1 2 7 0 5 4 10 11 20 

1 3 2 7 0 5 4 10 11 20 

1 2 3 7 0 5 4 10 11 20 

1 2 3 0 7 5 4 10 11 20 

1 2 3 0 5 7 4 10 11 20 

1 2 3 0 5 4 7 10 11 20 

1 2 0 3 5 4 7 10 11 20 

1 2 0 3 4 5 7 10 11 20 

1 0 2 3 4 5 7 10 11 20 

0 1 2 3 4 5 7 10 11 20 

5.2.4 Desempenho dos métodos de Seleção, Inserção e 

Bolha 

Para a análise de desempenho de métodos de ordenação deve levar em 

contar o número de comparações e o número de trocas realizadas. 

O Método da Seleção realiza aproximadamente n 2 /2 comparações e n 

trocas, pois para cada i de 1 até n-1 ocorre uma troca e n-1 

comparações. Assim temos que no final ocorrem n-1 trocas e (n-1 + 

(n-2) + ... 2 +1 = n(n-1)/2 comparações. 

O método da Inserção realiza aproximadamente n 2 /4 comparações e 

n 2 /8 trocas no caso médio. No entanto, esse método é linear para 

arranjos parcialmente ordenados, o que o torna um método 

conveniente para estes casos. 

O método da Bolha realiza n 2 /2 comparações e n 2 /2 trocas no caso 

médio e no pior caso. 

Realize testes de mesa para os métodos de seleção, 

inserção e bolha para os seguintes vetores: 

A = {10,0,3,2,5}, B={5,4,3,2,1}, C={1,1,2,2,0,0}. 

5.2.5 Método de Shell 

O método que estudaremos agora foi inventado por Criado por Donald 

Shell em 1959. Conforme comentado na Seção 5.2.4, o método da 

Inserção é bastante eficiente ao ordenar arranjos que já estão 

parcialmente ordenados. Shell observou esta característica e criou um 

método onde o método de inserção é aplicado sucessivamente. 

Em seu método, o algoritmo de inserção é aplicado para ordenar 

subconjuntos do arranjo completo. Estes subconjuntos são pegos 

considerando uma distância entre os elementos. Para cada execução 

do método de Inserção é considerada um distância d. d é iniciado com 

um valor que vai sendo decrementado até chegar a 1. Para cada valor 

de d, os elementos do arranjo localizados a uma distância d entre si 

são ordenados. 


Por exemplo, em um arranjo, 

6. a = {a0,a1,a2,a3,a4,a5,a6,a7,a8,a9} 

E considerando uma série de distâncias d = {5,3,1}. Nas iterações com 

distância d = 5, o método da inserção será aplicado aos elementos do 

arranjo localizados a uma distância 5 entre si. Os elementos são pegos 

do arranjo a partir da posição a0, na primeira iteração, a1 na segunda, 

a2 na terceira e assim sucessivamente. 

Assim para a distância 5 teremos a ordenação dos elementos: 

{a0,a5} (primeira iteração) 

{a1,a6} (segunda iteração) 

{a2,a7} (terceira iteração) 

{a3,a8} (quarta iteração) 

{a4,a9} (quinta iteração) 

Para a distância 3 teremos a ordenação dos elementos: 

{a0,a3,a6,a9} (primeira iteração) 

{a1,a4,a7} (segunda iteração) 

{a2,a5,a8} (terceira iteração) 

{a3,a6,a9} (quarta iteração) 

{a4,a7} (quinta iteração) 

{a5,a8} (sexta iteração) 

{a6,a9} (sétima iteração) 

Para a distância 1, teremos a ordenação do arranjo completo 

7. {a0,a1,a2,a3,a4,a5,a6,a7,a8,a9} 

iteração) 

8. 

(primeira 

A cada iteração à distância d é reduzida de acordo com alguma 

seqüência. Na utiliza iteração esta distância é reduzida a 1. Este passo 

corresponde ao método de inserção original. 

Vejamos um exemplo concreto, considerando o arranjo a = {35, 

28, 16, 07, 12, 08,04} e utilizando a seqüência de 

distâncias {3,1}: 

Para d = 3 o método ordena os elementos que estão a uma distância 3 

entre si. Na tabela abaixo estes elementos estão em negrito: 



Página 125


Página 126 

35 28 16 07 12 08 04 35 está 

ordenado, 7 

é comparado 

07 28 16 35 12 08 04 {07,35} está 

ordenado, 4 

é comparado 

04 28 16 07 12 08 35 {04,07,35} 

está 

ordenado 

04 28 16 07 12 08 35 28 está 

ordenado, 

12 é 

comparado 

04 12 16 07 28 08 35 {12,28} está 


04 12 16 07 28 08 35 16 está 

ordenado, 

35 é 

comparado 

04 12 08 07 28 16 35 {08,16} está 


Após a ordenação parcial feita com d=3, a distância é reduzida a 1 e o 

vetor é completamente ordenado. 

Para implementação do método de Shell, implementa-se uma função 

(Shell) que corresponde ao método de inserção parametrizado pela 

distância. Esta implementação é apresentada na Figura 5. 

Figura 5: Implementação da função Shell 

Note que a função shell corresponde exatamente à função 

insercao, se substituirmos o d pelo valor 1. 


Para concluirmos a implementação do método de Shell, basta agora 

implementarmos uma função que gere a seqüência de distâncias e a 

chave a função Shell para cada distância da série. A Figura 6 apresenta 

uma implementação da função shellSort, que executa o método com a 

série {5,2,1}. 

Figura 6: Implementação do método de Shell com distâncias 5,2 e 1 

A execução de shellsort1 sobre o vetor 

int B[] = {10,3,7,20,1,2,11,0,5,4}; produz a 

seguinte saída: 

10 3 7 20 1 2 11 0 5 4 

Distancia d= 5 

10 3 7 20 1 10 11 0 5 4 

2 3 7 20 1 10 11 0 5 4 

2 3 7 20 1 10 11 0 5 4 

2 3 7 20 1 10 11 7 5 4 

2 3 0 20 1 10 11 7 5 4 

2 3 0 20 1 10 11 7 20 4 

2 3 0 5 1 10 11 7 20 4 

2 3 0 5 1 10 11 7 20 4 


2 3 2 5 1 10 11 7 20 4 

0 3 2 5 1 10 11 7 20 4 

0 3 2 5 1 10 11 7 20 4 

0 3 2 5 2 10 11 7 20 4 

0 3 1 5 2 10 11 7 20 4 

0 3 1 5 2 10 11 7 20 4 

0 3 1 5 2 10 11 7 20 4 

0 3 1 5 2 10 11 10 20 4 

0 3 1 5 2 7 11 10 20 4 

0 3 1 5 2 7 11 10 20 4 

0 3 1 5 2 7 11 10 20 10 

0 3 1 5 2 7 11 7 20 10 

0 3 1 5 2 5 11 7 20 10 

0 3 1 4 2 5 11 7 20 10 


0 3 1 4 2 5 11 7 20 10 

0 3 3 4 2 5 11 7 20 10 

0 1 3 4 2 5 11 7 20 10 

0 1 3 4 2 5 11 7 20 10 

0 1 3 4 4 5 11 7 20 10 

0 1 3 3 4 5 11 7 20 10 

0 1 2 3 4 5 11 7 20 10 

0 1 2 3 4 5 11 7 20 10 

0 1 2 3 4 5 11 7 20 10 

0 1 2 3 4 5 11 11 20 10 



Página 127


Página 128 

0 1 2 3 4 5 7 11 20 10 

0 1 2 3 4 5 7 11 20 10 

0 1 2 3 4 5 7 11 20 20 

0 1 2 3 4 5 7 11 11 20 

0 1 2 3 4 5 7 10 11 20 

Conforme pode ser observado, a seqüência de distâncias pode variar. 

A única restrição é que termine com 1. Não existe uma seqüência 

ideal. Donald Knuth (vale a pena ver 

http://pt.wikipedia.org/wiki/Donald_Knuth), mostrou empiricamente 

que a seqüência ( 1,4, 13,40,121,364,1093..) apresenta eficiência 20 % 

maior que outras seqüências. 

A Figura 7 apresenta a função shellsort2 que executa a função Shell 

usando esta seqüência. 

Figura 7: Implementação do método de Shell usando a seqüência de Knuth 

5.2.6 O Método Quicksort 

Até o momento, foram estudados métodos de ordenação cuja função 

de complexidade é próxima de n 2 . Ou seja, complexidade quadrática. 

Nos melhores casos, o método da inserção e Shell podem chegar 

próximo de um comportamento linear. O método quicksort baseia-se 

em uma estratégia de dividir para conquistar (vide pesquisa binária), 

tornando-o assim um método que apresenta complexidade logarítmica 

(sublinear), no caso médio. Este comportamento do quicksort o torna 

um método de ordenação extremamente rápido. 


O algoritmo Quicksort foi inventado por C.A.R. Hoare em 1960, 

durante visita a Universidade de Moscou (Russia), ainda como 

estudante. 

A idéia fundamental do quicksort consiste em: 

Primeiro dividir: a seqüência a ser ordenada a é particionada em duas 

partes b e c, de tal modo que todos os elementos da primeira parte b 

são menores ou iguais a todos os elementos da segunda parte c. Em 

seguida conquistar: as duas partes são ordenadas separadamente por 

meio da aplicação recursiva do mesmo procedimento. Por último 

recombinar. A recombinação das duas partes ordenadas em separado 

produz uma seqüência também ordenada, dado que os elementos da 

primeira parte b são menores ou iguais a todos os elementos da 

segunda parte c. 

O processo de particionamento da seqüência é feito por meio da 

escolha de um elemento pivô. Por exemplo, Seja o arranjo 

{f,e,d,h,a,c,g,b} e o valor d como o elemento escolhido para 

fazer a primeira partição. O elemento escolhido é chamado de pivô. 

Após a primeira iteração com o valor d como pivô, teremos a seguinte 

configuração para o vetor: {b,c,a,d,h,e,g,f} 

Neste passo o processo é repetido para cada sub vetor [b,c,a] e 

[h,e,g,f] 

A Figura 8 apresenta uma implementação da operação de 

particionamento. Nessa implementação o pivô é sempre o elemento do 

meio do vetor. 



Página 129


Página 130 

Figura 8: função particiona 

A Figura 9 apresenta a função ordenaQS que aplica o método sobre 

um arranjo com limites esq e dir. 

Figura 9: Implementação da função ordenaQS 

A implementação da função quicksort, apresentada na Figura 10 

consiste apenas no encapsulamento da função ordenaQS em uma 

função cujos parâmetros são apenas o arranjo e seu tamanho. 

Figura 10: implementação da função quicksort 



1. Realizar os experimentos com os 5 métodos de ordenação 

estudados. No caso do shellsort utilizar a seqüência de Knuth. 

a) Realizar testes com todos os métodos para vetores de tamanho 

20000, 40000, 60000, 80000, 100000, 150000, 200000, 250000, 

300000, 350000, 400000 e 500000. 

b) Utilizar um software que trace gráficos (Excel, por exemplo) e 

traçar um gráfico de desempenho dos métodos utilizados. O 

gráfico deve ter os seguintes eixos: eixo x: tamanho do vetor. Eixo 

y: tempo de execução. Colocar as curvas de todos os métodos no 

mesmo gráfico para facilitar a comparação. 

c) Fazer uma análise dos resultados obtidos (descritiva). 

2. Sabemos que a eficiência do Shellsort depende da seqüência de 

distâncias utilizada. Assim, neste exercício, primeiramente você 

deve inventar uma seqüência de distâncias sua para ser utilizada 

no Shellsort. Posteriormente, escreva uma função myShellsort que 

execute o Shellsort com uma seqüência produzida por você. 

Invente uma seqüência sua! Você pode utilizar a mesma estrutura 

que foi utilizada para as funções shelsort1 e shellsort2. Compare 

os resultados de tempo obtidos com a sua seqüência com os 

obtidos com a seqüência de Knuth. 



Página 131


Página 132 

Referências utilizadas na elaboração deste material 

1. LISKOV B. Data Abstraction and Hiararchy. In 

OOPSLA’87: Conference on Object Oriented Programming 

Systems Languages and Applications. Addendum to the 

proceedings on Object-oriented programming systems, 

languages and applications, 1987. 

2. TENENBAUM A. M. Data Structs using C. Prentice Hall Int. 

Editions, 1990. 

3. ZIVIANI N. Projeto de Algoritmos. Segunda Edição. 

Pioneira, 2003.

Técnicas de Programação Avançada

Create successful ePaper yourself

Delete template?

Save as template?