Вы находитесь на странице: 1из 248

ESTRUTURA DE DADOS

Autora: Lucy Mari Tabuti


Cursos: ADS / BD / RC / SI

Semestre: 2

Prezado aluno,
Este material compreende apenas o
contedo da disciplina. Assim, no
deve ser a nica fonte de consultas
em seus estudos. O contedo deve
ser complementado com outras obras,
indicadas por seu professor ou
encontradas em suas pesquisas.

Revises: Dezembro de 2005 por Lucy M. Tabuti

2 Edio 6 Impresso 2008


Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ndice
1. Estrutura de Dados ................................................................................................................... 1
2. Estrutura de Dados Heterognea Registros ....................................................................... 2
2.1. Definio de Registros ....................................................................................................... 2
2.2. Declarao de Registros .................................................................................................... 4
2.3. Atribuindo Valores ao Registro ........................................................................................... 5
2.4. Mostrando os Elementos de um Registro ........................................................................... 7
2.5. Uso de Vetores de Registros .............................................................................................. 8
2.6. Exemplos de Registros em Pseudocdigo ....................................................................... 10
2.7. Exemplos de Registros em Java ...................................................................................... 14
2.8. Exerccios de Registros .................................................................................................... 17
3. Arquivos .................................................................................................................................. 23
3.1. Definio de Arquivo ......................................................................................................... 23
3.2. Declarao de Arquivos .................................................................................................... 24
3.3. Manipulao de Arquivos ................................................................................................. 25
3.3.1. Abertura de Arquivo em Pseudocdigo e em Java ................................................ 25
3.3.2. Fechamento de Arquivo em Pseudocdigo e em Java ......................................... 26
3.3.3. Leitura de Elementos do Arquivo em Pseudocdigo e em Java ........................... 27
3.3.4. Gravando o Contedo para um Arquivo em Pseudocdigo e em Java ................. 28
3.4. Exemplo de Arquivos em Pseudocdigo .......................................................................... 29
3.5. Exemplo de Arquivos em Java ......................................................................................... 33
3.6. Exerccios de Arquivos ..................................................................................................... 38
4. Estrutura Recursiva ................................................................................................................ 43
4.1. Definio de Recurso ..................................................................................................... 43
4.2. Uso da Recurso em Pseudocdigo e em Java ............................................................... 44
4.3. Regras da Recurso ......................................................................................................... 48
4.4. Construo e Chamada da Recurso .............................................................................. 48
4.5. Exemplos de Recurso em Pseudocdigo ....................................................................... 52
4.6. Exemplos de Recurso em Java ...................................................................................... 54
4.7. Exerccios de Recurso .................................................................................................... 57
5. Estrutura de Ordenao ......................................................................................................... 59
5.1. Definio de Ordenao ................................................................................................... 59
5.2. Algoritmos de Ordenao ................................................................................................. 59
1
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

5.2.1. Ordenao bolha ou bubble sort ........................................................................... 60


5.2.2. Ordenao por Troca de Partio ou Quicksort .................................................... 61
5.2.3. Ordenao por Intercalao ou Mergesort ............................................................ 62
5.3. Ordenao em Pseudocdigo .......................................................................................... 63
5.3.1. Ordenao Bolha ou Bubble sort ........................................................................... 63
5.3.2. Ordenao por Troca de Partio ou Quicksort ................................................... 64
5.3.3. Ordenao por Intercalao ou Mergesort ............................................................ 65
5.4. Ordenao em Java ......................................................................................................... 66
5.4.1. Ordenao Bolha ou Bubble sort ........................................................................... 66
5.4.2. Ordenao por Troca de Partio ou Quicksort ................................................... 67
5.4.3. Ordenao por Intercalao ou Mergesort ............................................................ 67
5.5. Exemplo de Ordenao em Pseueocdigo ...................................................................... 68
5.5.1. Ordenao Bolha ou Bubble sort ........................................................................... 68
5.5.2. Ordenao por Troca de Partio ou Quicksort ................................................... 69
5.5.3. Ordenao por Intercalao ou Mergesort ............................................................ 70
5.6. Exemplo de Ordenao em Java ..................................................................................... 70
5.6.1. Ordenao Bolha ou Bubble sort ........................................................................... 70
5.6.2. Ordenao por Troca de Partio ou Quicksort ................................................... 71
5.6.3. Ordenao por Intercalao ou Mergesort ............................................................ 73
5.7. Exerccios de Ordenao ................................................................................................. 74
6. Estrutura de Pilhas ..................................................................................................................78
6.1. Definio de Pilha ..............................................................................................................78
6.2. Exemplo de Pilha ...............................................................................................................79
6.3. Operaes de Pilha ...........................................................................................................79
6.3.1. Operaes de Pilha em Pseudocdigo ..................................................................80
6.3.2. Operaes de Pilha em Java ..................................................................................82
6.4. Representao do Funcionamento das Operaes de Pilha ............................................85
6.5. Exemplo de Pilhas em Pseudocdigo ...............................................................................88
6.6. Exemplo de Pilhas em Java ..............................................................................................96
6.7. Exerccios de Pilhas ........................................................................................................103
7. Estrutura de Filas ..................................................................................................................109
7.1. Definio de Fila ..............................................................................................................109
7.2. Exemplo de Fila ...............................................................................................................110
7.3. Operaes de Fila ...........................................................................................................110
7.3.1. Operaes de Fila em Pseudocgido ...................................................................111

2
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

7.3.2. Operaes de Fila em Java ..................................................................................114


7.4. Representao do Funcionamento das Operaes de Fila ............................................117
7.5. Exemplo de Filas em Pseudocdigo ...............................................................................120
7.6. Exemplo de Filas em Java ...............................................................................................130
7.7. Exerccios de Filas ..........................................................................................................139
8. Estrutura de Lista Ligada ......................................................................................................145
8.1. Definio de Lista Ligada ................................................................................................145
8.2. Exemplo de Lista Ligada .................................................................................................145
8.3. Operaes de Lista Ligada ..............................................................................................146
8.3.1. Operaes de Lista Ligada em Pseudocgido .....................................................147
8.3.2. Operaes de Lista Ligada em Java ....................................................................152
8.4. Representao do Funcionamento das Operaes de Fila ............................................157
8.5. Exemplo de Lista Ligada em Pseudocdigo ....................................................................160
8.6. Exemplo ee Lista Ligada em Java ...................................................................................175
8.7. Exerccios de Lista Ligada ...............................................................................................188
9. Estrutura de rvores .............................................................................................................194
9.1. Definio de rvores .......................................................................................................194
9.2. Exemplo de rvores Binrias ..........................................................................................195
9.3. Caractersticas de rvores Binrias ................................................................................196
9.3.1. Altura de uma rvore Binria ................................................................................196
9.3.2. A rvores Binria Completa e o Seu Nmero de Ns ..........................................196
9.3.3. rvores Binrias Degeneradas .............................................................................197
9.4. Operaes de rvores Binrias .......................................................................................197
9.4.1. Operaes de rvores Binrias em Pseudocdigo ..............................................198
9.4.2. Operaes de rvores Binrias em Java .............................................................202
9.5. Exemplo de rvores Binrias em Pseudocdigo .............................................................205
9.6. Exemplo de rvores Binrias em Java ............................................................................220
9.7. Exerccios de rvores ......................................................................................................233

1
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

2
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

1. Estrutura de Dados
O estudo de Estruturas de Dados uma parte muito importante do estudo mais geral de
algoritmos. Segundo Niklaus Wirth, criador da linguagem Pascal, um programa resultante da
"soma" entre algoritmos e estruturas de dados. Do mesmo modo que nmeros podem ser
representados em sistemas diferentes, dados podem ser armazenados em estruturas diferentes.
Em outras palavras, o programador pode utilizar-se de diversos mtodos para armazenar os
dados na memria e no disco para serem processados.
Essas estruturas podem ser escolhidas dentre vrios tipos, e cada escolha vai afetar o algoritmo
do problema que se pretende resolver, tanto em termos de memria gasta como em tempo de
execuo despendido.
Assim sendo, estudar Estruturas de Dados consiste na anlise das diversas formas de armazenar
os dados, determinao da eficincia de cada tipo de estrutura e escolha do algoritmo mais
adequado para cada problema.
Se existe um conjunto de dados de tamanho N para ser processado, a escolha de uma estrutura
de dados A para armazenar este conjunto far que a memria gasta possa variar de um fator de 1
a muitas vezes a memria que seria necessria com outra estrutura B. O tempo de execuo, por
sua vez, pode variar de 1 a mais de N vezes o tempo gasto por outra estrutura. Portanto, a
escolha da estrutura de dados deve ser feita de acordo com a complexidade do problema a
resolver, com a memria disponvel e o tempo que se pode gastar para resolver o problema.
Deve-se, assim, aprender a determinar a estrutura de dados adequada para cada tipo de
problema.
As operaes bsicas que so feitas com os dados so: incluso de um dado novo, procura,
excluso e alterao de um dado j existente. Para que se possa fazer estas operaes, s
vezes, necessrio ordenar os dados, ou guard-los em estruturas auxiliares para uso posterior.
Para tanto, nosso estudo de estruturas de dados englobar a definio de cada estrutura, bem
como mtodos (algoritmos) para se operar com elas.
As estruturas que vermos podem ser divididas em dois blocos quanto sua disposio na
memria: as estruturas de alocao esttica, e as estruturas de alocao dinmica.
Quanto aos algoritmos, podem ser divididos em iterativos e recursivos. Para faz-los, usaremos a
linguagem Java.
Para representar as estruturas, interessante deixar de lado, num primeiro momento, as
declaraes especficas das vrias linguagens de programao, e procurarem-se definies
abstratas, ou seja, que no levem em considerao detalhes de implementao. Dessa maneira,
podem-se usar os conceitos de estruturas de dados independentemente de implementaes em
linguagens especficas. Em outras palavras, os detalhes de implementao no devem criar uma
dependncia no programa; dessa forma, o programa apenas invocar as rotinas que armazenam
ou recuperam os dados, sem se preocupar com os detalhes internos dessas rotinas. Dentro
dessas rotinas, o programador utilizar uma implementao especfica para a estrutura escolhida.
Para o programador de uma aplicao, pode ser indiferente se a estrutura em que armazena seus
dados uma rvore binria ou um vetor. Cada uma dessas estruturas possui suas peculiaridades,
suas limitaes e facilidades de uso, mas deve-se procurar separar os programas aplicativos da
complexidade de cada implementao especfica de uma estrutura de dados. O aplicativo apenas
invoca a rotina, passando e recebendo determinados parmetros, e o programa no se preocupa
com a estrutura em si. Uma mesma aplicao, feita por diferentes programadores, pode usar as
mesmas chamadas de rotinas, mas usando implementaes diferentes dessas rotinas. Assim, o
1
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

aplicativo A utiliza rotinas que implementam as estruturas como listas ligadas, enquanto o
programa B usa rotinas que implementam rvores. As rotinas chamadas sero, para A e B, por
exemplo, Incluir(Elemento), Excluir(Elemento), Pesquisa(Elemento, Onde). A implementao
especfica de cada biblioteca de rotinas que mudar, mas no a interface entre as rotinas e os
programas que as utilizam.
Como analogia, quando voc usa um nmero real em Clipper ou COBOL, ele tem uma forma de
armazenamento diferente de um nmero real em Pascal ou Java; no entanto, voc no precisa
saber como ele armazenado fisicamente. Basta utiliz-lo, e os detalhes de acesso e
representao ficam a cargo das rotinas que manipulam reais, em cada uma dessas linguagens.

2. Estrutura de Dados Heterognea - Registros


Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos usar
vrias informaes de diferentes tipos de dados. Podemos fazer isso criando vrias variveis:
uma para cada informao e cada tipo de dado. Mas isso invivel, pois demasiado complexo
desenvolvermos e manipularmos um algoritmo que utiliza vrias variveis para vrias informaes
de diferentes tipos de dados. Para solucionar este problema, podemos utilizar registros para
armazenar essas informaes, isto , uma estrutura de dados heterognea.
Uma estrutura de dados heterognea uma estrutura capaz de armazenar vrias informaes de
diferentes tipos de dados. Assim, com um nico nome declarado para esta estrutura, podemos
manipular vrias informaes de diferentes tipos de dados.
Uma estrutura de dados heterognea pode ser vista como qualquer outra varivel, podendo ser
manipulada dentro de uma estrutura de deciso, seja ela simples, composta ou encadeada,
dentro de uma estrutura de mltipla escolha, dentro das estruturas de repetio, bem como dentro
dos mdulos.
A estrutura de dados heterognea que estudaremos so os registros, e neste captulo veremos
como e quando trabalhar com um registro, bem como definir, declarar e manipular um registro.

2.1. Definio de Registros


Um registro uma das principais estruturas de dados, ou seja, uma estrutura de dados
heterognea que tem a capacidade de armazenar vrias informaes de diferentes tipos de
dados. Cada informao do registro ser considerada como um campo do registro.
Por exemplo, podemos definir um registro que armazena as seguintes informaes: nome do
aluno, registro do aluno, nota do primeiro bimestre, nota do segundo bimestre e mdia final. Para
este exemplo, note que cada uma das informaes possui tipos de dados diferentes, ou seja, o
campo nome do aluno do tipo alfanumrico, o campo registro do aluno do tipo
numrico_inteiro, os campos nota do primeiro bimestre, nota do segundo bimestre e mdia final
so do tipo numrico_real.
Para trabalharmos com registros, primeiramente, precisamos saber como definir um tipo registro.
Um tipo registro precisa ser definido para que todos os campos dentro do registro sejam
previamente declarados. Uma vez definido o tipo registro, ele pode ser usado como qualquer
outro tipo de dado, ou seja, ele precisa ser declarado e pode ser usado como qualquer outro tipo
de dado.

2
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Pseudocdigo
Na definio de um tipo registro, utilizaremos as palavras tipo e registro que representam as
palavras principais desta estrutura e a palavra fimregistro; para determinar o fim do bloco de
definio desta estrutura. A definio de um tipo registro para pseudocdigo segue a seguinte
regra sinttica:
tipo <nome do tipo registro> = registro
<varivel1> <tipo da varivel>;
<varivel2> <tipo da varivel>;
...
<varivel3> <tipo da varivel>;
fimregistro;
Por exemplo:
tipo RegistroAluno = registro // o tipo registro chama-se RegistroAluno
NAluno alfanumrico; // campo nome do aluno
RAluno numrico_inteiro; // campo registro do aluno
Nota1Bim numrico_real; // campo nota do primeiro bimestre
Nota2Bim numrico_real; // campo nota do segundo bimestre
MediaFinal numrico_real; // campo mdia final
fimregistro;
Neste exemplo, definimos o tipo registro RegistroAluno com o campos NAluno do tipo
alfanumrico, o campo RAluno do tipo numrico_inteiro e os campos Nota1Bim, Nota2Bim e
MediaFinal do tipo numrico_real.
Java
Na definio de um tipo registro, utilizaremos a palavra class para representar a palavra principal
desta estrutura e a chave aberta, {, e chave fechada, }, para representar o conjunto de comandos
que fazem parte desta estrutura. A definio de um tipo registro para Java segue a seguinte regra
sinttica:
class <nome do tipo registro>
{
<tipo da varivel> <varivel1> ;
<tipo da varivel> <varivel2> ;
...

3
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

<tipo da varivel> <varivel3> ;

// construtor do registro
<nome tipo registro> (<tipo da var> <var1> , <tipo da var> <var2> , ... , <tipo da var>
<var3>)
{
<varivel1> = <var1>;
<varivel2> = <var2>;
...
<varivel3> = <var3>;
} // fim do construtor do tipo registro
} // fim da definio do tipo registro
Por exemplo:
class RegistroAluno
{
String NAluno; // campo nome do aluno
int RAluno; // campo registro do aluno
double Nota1Bim; // campo nota do primeiro bimestre
double Nota2Bim; // campo nota do segundo bimestre
double MediaFinal; // campo mdia final
// construtor do tipo registro
RegistroAluno (String NA , int RA , double N1 , double N2 , double
Media)
{
NAluno = NA; // campo nome do aluno
RAluno = RA; // campo registro do aluno
Nota1Bim = N1; // campo nota do primeiro bimestre
Nota2Bim = N2; // campo nota do segundo bimestre
MediaFinal = Media; // campo mdia final
} // fim do construtor do registro
} // fim da definio do tipo registro
Neste exemplo, definimos o tipo registro chamado RegistroAluno com o campo NAluno do tipo
String, o campo RAluno do tipo int e os campos Nota1Bim, Nota2Bim e MediaFinal do tipo
double.

2.2. Declarao de Registros


A partir do momento que temos um tipo registro definido, devemos saber como declar-lo. A
declarao de um registro segue os mesmos padres da declarao de qualquer tipo de dado.

4
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Lembre-se de que um tipo registro pode ser considerado como um novo tipo de dado definido
pelo usurio.
Pseudocdigo
A declarao de um registro para pseudocdigo segue a seguinte regra sinttica:
<nome do registro> <nome do tipo registro>;
Por exemplo:
Aluno RegistroAluno;
Neste exemplo, declaramos um registro chamado Aluno do tipo RegistroAluno, ou seja, Aluno
uma varivel do tipo RegistroAluno que contm os campos NAluno, RAluno, Nota1Bim,
Nota2Bim e MediaFinal.
Java
A declarao de um registro para Java segue a seguinte regra sinttica:
<nome do tipo registro> <nome do registro> = new <nome do tipo registro>(<parmetros de
inicializao>);
Por exemplo:
RegistroAluno Aluno = new RegistroAluno ("" , 0 , 0.0 , 0.0 , 0.0);
Neste exemplo, declaramos um registro chamado Aluno do tipo RegistroAluno, ou seja, Aluno
uma varivel do tipo RegistroAluno que contm os campos NAluno, RAluno, Nota1Bim,
Nota2Bim e MediaFinal.
Quando declaramos o registro Aluno, precisamos inicializar as variveis de cada um dos seus
campos. Neste caso, o campo NAluno foi inicializado com vazio, o campo RAluno com um inteiro
0 e os campos Nota1Bim, Nota2Bim e Media foram inicializados com um real 0.0.

2.3. Atribuindo Valores ao Registro


A partir do momento que temos um registro declarado, devemos saber como atribuir valores para
cada campo deste registro. A atribuio de valores para cada campo de um registro segue os
mesmos padres da atribuio de valores para qualquer outra varivel, a nica diferena que
cada campo de um registro vem logo aps o nome do seu registro mais um ponto.

5
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Pseudocdigo
A atribuio de valores para cada campo de um registro em pseudocdigo segue a seguinte regra
sinttica:
<nome do registro>.<campo do registro><valor a ser atribudo>;
Por exemplo:
Aluno.NAluno "Clarisberta";
Aluno.RAluno 123456;
Aluno.Nota1Bim 9.5;
Aluno.Nota2Bim 8.5;
Aluno.MediaFinal (Aluno.Nota1Bim + Aluno.Nota2Bim) / 2;
Neste exemplo, atribumos o nome "Clarisberta" ao campo NAluno do registro Aluno, atribumos
o valor inteiro 123456 ao campo RAluno do registro Aluno, atribumos o valor real 9.5 ao campo
Nota1Bim do registro Aluno, atribumos o valor real 8.5 ao campo Nota2Bim do registro Aluno e
por fim atribumos a expresso aritmtica (Aluno.Nota1Bim + Aluno.Nota2Bim) / 2 ao campo
MediaFinal do registro Aluno.
Java
A atribuio de valores para cada campo de um registro em Java segue a seguinte regra sinttica:
<nome do registro>.<campo do registro> = <valor a ser atribudo>;
Por exemplo:
Aluno.NAluno = "Clarisberta";
Aluno.RAluno = 123456;
Aluno.Nota1Bim = 9.5;
Aluno.Nota2Bim = 8.5;
Aluno.MediaFinal = (Aluno.Nota1Bim + Aluno.Nota2Bim) / 2;
Neste exemplo, atribumos o nome "Clarisberta" ao campo NAluno do registro Aluno, atribumos
o valor inteiro 123456 ao campo RAluno do registro Aluno, atribumos o valor real 9.5 ao campo
Nota1Bim do registro Aluno, atribumos o valor real 8.5 ao campo Nota2Bim do registro Aluno e
por fim atribumos a expresso aritmtica (Aluno.Nota1Bim + Aluno.Nota2Bim) / 2 ao campo
MediaFinal do registro Aluno.

6
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

2.4. Mostrando os Elementos de um Registro


A partir do momento que temos um registro com valores atribudos a cada um dos campos,
podemos apresentar ou utilizar os de cada campo deste registro. A apresentao ou utilizao
dos valores de cada campo de um registro segue os mesmos padres da apresentao ou
utilizao de valores de qualquer outra varivel, a nica diferena que cada campo de um
registro vem logo aps o nome do seu registro mais um ponto.
Pseudocdigo
A apresentao dos valores de cada campo de um registro em pseudocdigo segue a seguinte
regra sinttica:
escrever(<nome do registro>.<campo do registro>);
Por exemplo:
escrever(Aluno.NAluno);
escrever(Aluno.RAluno);
escrever(Aluno.Nota1Bim);
escrever(Aluno.Nota2Bim);
escrever(Aluno.MediaFinal);
Neste exemplo, os valores armazenados em cada campo do registro Aluno so apresentados, ou
seja, "Clarisbela", 123456, 9.5, 8.5 e finalmente 8.0.
Java
A apresentao dos valores de cada campo de um registro em Java segue a seguinte regra
sinttica:
System.out.println(<nome do registro>.<campo do registro>);
Por exemplo:
System.out.println(Aluno.NAluno);
System.out.println(Aluno.RAluno);
System.out.println(Aluno.Nota1Bim);
System.out.println(Aluno.Nota2Bim);
System.out.println(Aluno.MediaFinal);
Neste exemplo, os valores armazenados em cada campo do registro Aluno so apresentados um
em cada linha, ou seja, "Clarisbela", 123456, 9.5, 8.5 e finalmente 8.0.

7
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

2.5. Uso de Vetores de Registros


Como j sabemos trabalhar com vetores e aprendemos a trabalhar com registros, podemos
trabalhar unificadamente com estas duas estruturas de dados. Como definimos um tipo registro e
como cada posio do vetor pode possuir informaes de um mesmo tipo de dados, ento
podemos atribuir, para cada posio do vetor, um tipo registro definido. Por exemplo, temos um
tipo registro Aluno definido, podemos definir um vetor do tipo registro Aluno, onde cada posio
do vetor pode receber todos os campos definidos no tipo registro Aluno. Dessa forma, cada
posio do vetor pode conter vrias informaes juntas; neste caso, um nome de aluno, um
registro de aluno, uma nota do primeiro bimestre, uma nota do segundo bimestre e uma mdia
final.
Pseudocdigo
Para exemplificar o uso de vetores de registros em pseudocdigo, vamos desenvolver um
algoritmo que cria um vetor de 20 posies do tipo registro Aluno, com os campos nome do aluno,
registro do aluno e mdia, de forma que, para cada posio do vetor, o usurio entra com as
informaes correspondentes e posteriormente o algoritmo apresenta estas informaes.
Algoritmo ExemploVetRegistro
incio_algoritmo
Definir
// definio do tipo registro RegistroAluno com os campos abaixo
tipo RegistroAluno = registro // o tipo registro chama-se RegistroAluno
NAluno alfanumrico; // campo nome do aluno
RAluno numrico_inteiro; // campo registro do aluno
Media numrico_real; // campo mdia
fimregistro;
Declarar
// declarao de um vetor de registros do tipo RegistroAluno
VetAluno[20] RegistroAluno;
a numrico_inteiro;
para a de 0 at 19 passo +1 faa // para cada posio do vetor de registros
escrever ("Digite o nome de um aluno"); // envia mensagem para o usurio
/* recebe o nome do aluno e armazena no campo NAluno do vetor VetAluno na posio a*/
ler (VetAluno[a].NAluno);
escrever ("Digite o registro do aluno"); // envia mensagem para o usurio
/* recebe o registro do aluno e armazena no campo RAluno do vetor VetAluno na posio a*/
ler (VetAluno[a].RAluno);

8
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

escrever ("Digite a mdia do aluno"); // envia mensagem para o usurio


// recebe a mdia do aluno e armazena no campo Media de VetAluno na posio a
ler (VetAluno[a].Media);
fimpara;
para a de 0 at 19 passo +1 faa // para cada posio do vetor de registros
// sada de resultados
escrever ("O aluno " , VetAluno[a].NAluno , " de RA " , VetAluno[a].RAluno , " tem mdia " ,
VetAluno[a].Media);
fimpara;
fim_algoritmo.
Java
Para exemplificar o uso de vetores de registros em Java, vamos desenvolver um programa que
cria um vetor de 20 posies do tipo registro Aluno, com os campos nome do aluno, registro do
aluno e mdia, de forma que, para cada posio do vetor, o usurio entra com as informaes
correspondentes e posteriormente o programa apresenta estas informaes.
class RegistroAluno
{
// definio do tipo registro RegistroAluno com os campos abaixo
String NAluno; // campo nome do aluno
int RAluno; // campo registro do aluno
double Media; // campo mdia
// construtor do tipo registro
RegistroAluno (String NA , int RA , double M)
{
NAluno = NA; // campo nome do aluno
RAluno = RA; // campo registro do aluno
Media = M; // campo mdia
} // fim do construtor do registro
} // fim da definio do tipo registro
class ExemploVetRegistro
{
public static void main (String args [ ])
{
// declarao de um vetor de registros do tipo RegistroAluno
RegistroAluno[ ] VetAluno = new RegistroAluno [20];
int a; // declarao de uma varivel inteira
/* inicializao dos campos de cada Registro do Vetor
VetAluno*/
for ( a = 0 ; a <=19 ; a++ )

9
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
VetAluno[a] = new RegistroAluno("" , 0 , 0.0);
}
for ( a = 0 ; a <=19 ; a++ )
{
// envia mensagem para o usurio
/* recebe o nome do aluno e armazena no campo NAluno
do vetor VetAluno na posio a*/
VetAluno[a].NAluno = JOptionPane.showInputDialog
("Digite o nome de um aluno");
// envia mensagem para o usurio
/* recebe o reg. do aluno e armazena no campo RAluno
do vetor VetAluno na posio a*/
VetAluno[a].RAluno = Integer.parseInt(
JOptionPane.showInputDialog(
"Digite o registro do aluno"));
// envia mensagem para o usurio
/* recebe a mdia do aluno e armazena no campo Media
do vetor VetAluno na posio a/*
VetAluno[a].Media = Double.parseDouble(
JOptionPane.showInputDialog(
"Digite a mdia do aluno"));
}
for ( a = 0 ; a <=19 ; a++ )
{
// sada de resultados
System.out.println ("O aluno " + VetAluno[a].NAluno +
" de RA " + VetAluno[a].RAluno +
" tem mdia " + VetAluno[a].Media);
}
System.exit(0);
} // fim do void main
} // fim da classe

2.6. Exemplos de Registros em Pseudocdigo


1. Desenvolva um algoritmo que defina um registro com os campos nome, idade e altura, receba
informaes do usurio relacionadas ao registro definido, com dados de uma pessoa membro
de sua famlia e mostre esses valores.
Algoritmo Exemplo1
incio_algoritmo
Definir
// definio do tipo registro RegistroFamilia com os campos abaixo
tipo RegistroFamilia = registro // o tipo registro chama-se RegistroFamilia
Nome alfanumrico; // campo nome
10
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Idade numrico_inteiro; // campo idade


Altura numrico_real; // campo altura
fimregistro;
Declarar
Membro RegistroFamilia; // declarao de um Registro do tipo RegistroFamlia
escrever ("Digite o nome"); // envia mensagem para o usurio
// recebe o nome e armazena no campo Nome do registro Membro
ler (Membro.Nome);
escrever ("Digite a idade"); // envia mensagem para o usurio
// recebe a idade e armazena no campo Idade do registro Membro
ler (Membro.Idade);
escrever ("Digite a altura"); // envia mensagem para o usurio
// recebe a altura e armazena no campo Altura do registro Membro
ler (Membro.Altura);
// sada de resultados
escrever ("A pessoa " , Membro.Nome , " de Idade " , Membro.Idade , " tem altura " ,
Membro.Altura);
fim_algoritmo.
2. Desenvolva um algoritmo que defina um registro com os campos nome, idade e altura,
recebainformaes do usurio relacionados ao registro definido, com dados de 5 pessoas
membros de sua famlia num vetor do registro definido e mostre esses valores.
Algoritmo Exemplo2
incio_algoritmo
Definir
// definio do tipo registro RegistroFamilia com os campos abaixo
tipo RegistroFamilia = registro // o tipo registro chama-se RegistroFamilia
Nome alfanumrico; // campo nome
Idade numrico_inteiro; // campo idade
Altura numrico_real; // campo altura
fimregistro;
Declarar
// declarao de um vetor de registros do tipo RegistroFamilia
Membro[5] RegistroFamilia;
i numrico_inteiro; // declarao de uma varivel inteira

11
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros


escrever ("Digite o nome"); // envia mensagem para o usurio
// recebe o nome e armazena no campo Nome do vetor Membro na posio i
ler (Membro[i].Nome);
escrever ("Digite a idade"); // envia mensagem para o usurio
// recebe a idade e armazena no campo Idade do vetor Membro na posio i
ler (Membro[i].Idade);
escrever ("Digite a altura"); // envia mensagem para o usurio
// recebe a altura e armazena no campo Altura do vetor Membro na posio i
ler (Membro[i].Altura);
fimpara;
para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros
// sada de resultados
escrever ("A pessoa " , Membro[i].Nome , " de Idade " , Membro[i].Idade , " tem altura " ,
Membro[i].Altura);
fimpara;
fim_algoritmo.
3. Desenvolva um algoritmo modularizado que defina um registro com os campos nome, idade e
altura, receba informaes do usurio relacionadas ao registro definido, com dados de 5
pessoas membros de sua famlia num vetor do registro definido e mostre esses valores.
Algoritmo_global
incio
Definir_globalmente
// definio do tipo registro RegistroFamilia com os campos abaixo
tipo RegistroFamilia = registro // o tipo registro chama-se RegistroFamilia
Nome alfanumrico; // campo nome
Idade numrico_inteiro; // campo idade
Altura numrico_real; // campo altura
fimregistro;
// funo chamada EntradaDados que recebe e retorna um vetor do tipo RegistroFamilia
RegistroFamilia [ ] EntradaDados (Vet[ ] RegistroFamilia)
incio
Declarar
i nmerico_inteiro; // declarao de uma varivel inteira
12
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros


escrever ("Digite o nome"); // envia mensagem para o usurio
// recebe o nome e armazena no campo Nome do vetor Vet na posio i
ler (Vet[i].Nome);
escrever ("Digite a idade"); // envia mensagem para o usurio
// recebe a idade e armazena no campo Idade do vetor Vet na posio i
ler (Vet[i].Idade);
escrever ("Digite a altura"); // envia mensagem para o usurio
// recebe a altura e armazena no campo Altura do vetor Vet na posio i
ler (Vet[i].Altura);
fimpara;
retornar Vet; // retorno do vetor Vet
fim_mdulo;
Algoritmo Exemplo3
incio_algoritmo
Declarar
Membro[5] RegistroFamilia; // declarao de um vetor de registros do tipo RegistroFamilia
i numrico_inteiro; // declarao de uma varivel inteira
// chamada da funo EntradaDados, enviando como parmetro o argumento Membro
// o retorno da funo EntradaDados ser armazenado no vetor Membro
Membro EntradaDados (Membro);
para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros
// sada de resultados
escrever ("A pessoa " , Membro[i].Nome , " de Idade " , Membro[i].Idade , " tem altura " ,
Membro[i].Altura);
fimpara;
fim_algoritmo.
fim_algoritmo_global.

13
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

2.7. Exemplos de Registros em Java


1. Desenvolva um algoritmo que defina um registro com os campos nome, idade e altura, receba
informaes do usurio relacionadas ao registro definido, com dados de uma pessoa membro
de sua famlia e mostre esses valores.
class RegistroFamilia
{
// definio do tipo registro RegistroFamilia com os campos abaixo
String Nome; // campo nome
int Idade; // campo idade
double Altura; // campo altura
// construtor do tipo registro
RegistroFamilia (String N , int I , double A)
{
Nome = N; // campo nome
Idade = I; // campo idade
Altura = A; // campo altura
} // fim do construtor do registro
} // fim da definio do tipo registro

class Exemplo1
{
public static void main (String args [ ])
{
// declarao de um Registro Membro do tipo RegistroFamlia
RegistroFamilia Membro = new RegistroFamilia ("" , 0 , 0.0 );
// envia mensagem para o usurio
/* recebe o nome e armazena no campo Nome do registro
Membro*/
Membro.Nome = JOptionPane.showInputDialog("Digite o nome");
// envia mensagem para o usurio
/* recebe a idade e armazena no campo Idade do registro
Membro*/
Membro.Idade = Integer.parseInt(
JOptionPane.showInputDialog("Digite a idade"));
// envia mensagem para o usurio
/* recebe a altura e armazena no campo Altura do registro
Membro*/
Membro.Altura = Double.parseDouble(
JOptionPane.showInputDialog("Digite a altura"));
// sada de resultados
System.out.println ("A pessoa " + Membro.Nome + " de Idade "
+ Membro.Idade + " tem altura " + Membro.Altura);
System.exit(0);
} //fim do void main
} // fim da classe
14
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

2. Desenvolva um algoritmo que defina um registro com os campos nome, idade e altura,
recebainformaes do usurio relacionadas ao registro definido, com dados de 5 pessoas
membros de sua famlia num vetor do registro definido e mostre esses valores.
class RegistroFamilia
{
// definio do tipo registro RegistroFamilia com os campos abaixo
String Nome; // campo nome
int Idade; // campo idade
double Altura; // campo altura
// construtor do tipo registro
RegistroFamilia (String N , int I , double A)
{
Nome = N; // campo nome
Idade = I; // campo idade
Altura = A; // campo altura
} // fim do construtor do registro
} // fim da definio do tipo registro
class Exemplo2
{
public static void main (String args [ ])
{
RegistroFamilia[ ] Membro = new RegistroFamilia [5];
int i;
// inicializao dos campos do Registro de vetor Membro
for (i=0 ; i<5 ; i++)
{
Membro[i] = new RegistroFamilia("" , 0 , 0.0);
}
for (i=0 ; i<5 ; i++)
{
// envia mensagem para o usurio
/* recebe o nome e armazena no campo Nome do vetor
Membro na posio i*/
Membro[i].Nome = JOptionPane.showInputDialog(
"Digite o nome");
// envia mensagem para o usurio
/* recebe a idade e armazena no campo Idade do vetor
Membro na posio i*/
Membro[i].Idade = Integer.parseInt(
JOptionPane.showInputDialog("Digite a idade"));
// envia mensagem para o usurio
/* recebe a altura e armazena no campo Altura do vetor
Membro na posio i*/
Membro[i].Altura = Double.parseDouble(
JOptionPane.showInputDialog(
"Digite a altura"));

15
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

}
for (i=0 ; i<5 ; i++)
{
// sada de resultados
System.out.println ("A pessoa " + Membro[i].Nome +
" de Idade " + Membro[i].Idade + "
tem altura " + Membro[i].Altura);
}
System.exit(0);
} //fim do void main
} // fim da classe
3. Desenvolva um algoritmo modularizado que defina um registro com os campos nome, idade e
altura, receba informaes do usurio relacionadas ao registro definido, com dados de 5
pessoas membros de sua famlia num vetor do registro definido e mostre esses valores.
class RegistroFamilia
{
// definio do tipo registro RegistroFamilia com os campos abaixo
String Nome; // campo nome
int Idade; // campo idade
double Altura; // campo altura
// construtor do tipo registro
RegistroFamilia (String N , int I , double A)
{
Nome = N; // campo nome
Idade = I; // campo idade
Altura = A; // campo altura
} // fim do construtor do registro
} // fim da definio do tipo registro
class Exemplo3
{
/* funo chamada EntradaDados que recebe e retorna um vetor do
tipo RegistroFamilia*/
static RegistroFamilia [ ] EntradaDados (RegistroFamilia Vet[ ])
{
int i; // declarao de uma varivel inteira
for (i=0 ; i<5 ; i++)
{
// envia mensagem para o usurio
/* recebe o nome e armazena no campo Nome do vetor Vet
na posio i*/
Vet[i].Nome = JOptionPane.showInputDialog(
"Digite o nome");
// envia mensagem para o usurio
/* recebe a idade e armazena no campo Idade do vetor
Vet na posio i*/
16
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Vet[i].Idade = Integer.parseInt(
JOptionPane.showInputDialog("Digite a idade"));
// envia mensagem para o usurio
/* recebe a altura e armazena no campo Altura do vetor
Vet na posio i*/
Vet[i].Altura = Double.parseDouble(
JOptionPane.showInputDialog("Digite a altura"));
}
return Vet; // retorno do vetor Vet
} // fim da funo EntradaDados
public static void main (String args [ ])
{
RegistroFamilia[ ] Membro = new RegistroFamilia [5];
int i;
/* chamada da funo EntradaDados, enviando como parmetro o
argumento Membro[ ]*/
/* o retorno da funo EntradaDados ser armazenado no vetor
Membro[ ]*/
Membro = EntradaDados (Membro);
for (i=0 ; i<5 ; i++)
{
// sada de resultados
System.out.println ("A pessoa " + Membro[i].Nome +
" de Idade " + Membro[i].Idade +
" tem altura " + Membro[i].Altura);
}
System.exit(0);
} //fim do void main
} // fim da classe

2.8. Exerccios de Registros


01. Desenvolva um algoritmo que receba quatro notas bimestrais de oito alunos, apresentando no
final os dados dos alunos classificados por nome.

02. Desenvolva um algoritmo que defina um registro para um cheque bancrio e de acordo com
essas informaes o algoritmo, usando um campo saldo de um registro conta bancria, imprima
um relatrio dos cheques sem fundos.

03. Desenvolva um algoritmo que efetua a leitura de uma tabela de cargos e salrios. Em seguida, o
algoritmo dever solicitar que seja fornecido o cdigo de um determinado cargo. Esse cdigo
dever estar entre 1 e 17. O operador do programa poder fazer quantas consultas desejar.
Sendo o cdigo vlido, o algoritmo dever apresentar o cargo e o respectivo salrio. Caso o

17
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

cdigo seja invlido, o algoritmo deve avisar o operador da ocorrncia. Para dar entrada no
cdigo de cargos/salrios, observe a seguinte tabela:
cdigo

cargo

salrio

analista de recursos humanos

1800,00

auxiliar de contabilidade

1250,00

chefe de contabilidade

1610,00

chefe de recursos humanos

1616,00

analista contbil

3120,00

gerente contbil

4580,00

escriturrio

1000,00

faxineiro

640,00

gerente administrativo

2060,00

10

gerente comercial

2080,00

11

gerente de pessoal

2058,00

12

gerente de treinamento

2136,00

13

gerente financeiro

3308,00

14

contnuo

492,00

15

digitador

1210,00

16

programador

1820,00

17

secretria

1462,00

04. Desenvolva um algoritmo que defina um registro para estoque e com base nessas informaes o
algoritmo deve imprimir o produto de menor sada, imprimir a diferena percentual entre a maior e
a menor sada e um relatrio com a semana de maior sada de cada produto.
05. Desenvolva um algoritmo que, considerando a necessidade de desenvolver uma agenda que
contenha nomes, endereos e telefones de dez pessoas, defina a estrutura de registro apropriada
e, por meio do uso de um menu de opes, execute as seguintes etapas:
a. Cadastrar os dez registros.
b. Pesquisar um dos dez registros de cada vez pelo campo nome.
c. Classificar por ordem de nome os registros cadastrados.
d. Apresentar todos os registros.
e. Sair do programa de cadastro.

06. Desenvolva um algoritmo para uma determinada biblioteca que possui obras de cincias exatas,
cincias humanas e cincias biomdicas, totalizando 1500 volumes, 500 de cada rea. O
proprietrio deseja que, na informatizao, as seguintes informaes sobre cada livro sejam
agrupadas: cdigo de catalogao, doado, nome da obra, nome do autor, editora, nmero de
pginas.

18
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

a. O algoritmo deve declarar tal estrutura e reunir todas as informaes de todas as obras em
trs vetores distintos para cada rea.
b. O algoritmo, utilizando como premissa o que foi feito no item a), deve realizar uma consulta s
informaes. O usurio fornecer o cdigo da obra e sua rea; existindo tal livro, informa seus
campos; do contrrio, envia uma mensagem de aviso. A consulta repete-se at que o usurio
introduza o cdigo finalizador com o valor -1.
c. Idem ao item b), porm o usurio simplesmente informa o nome e a rea do livro que deseja
consultar.
d. O algoritmo deve listar todas as obras de cada rea que representem livros doados.
e. Idem ao item d), porm obras cujos livros sejam comprados e cujo nmero de pginas se
encontre entre 100 e 300.
f. O algoritmo deve fazer a alterao de um registro; para tal, o usurio fornece o cdigo, a rea
e as demais informaes sobre o livro. Lembre-se de que somente pode ser alterado um livro
existente.
g. O algoritmo deve efetuar a excluso de algum livro; o usurio fornecer o cdigo da obra e a
rea. Lembre-se de que somente pode ser excludo um livro existente.

07. Desenvolva um algoritmo que armazene o nome e as notas bimestrais de 20 alunos do curso de
Lgica de Programao numa estrutura de registros apropriada e, por meio do uso de um menu
de opes, execute as seguintes etapas:
a. Cadastrar os 20 registros (aps o cadastro efetuar a classificao por nome).
b. Pesquisar os 20 registros, de cada vez, pelo campo nome. Nesta pesquisa, o algoritmo dever
tambm apresentar a mdia do aluno e as mensagens "aprovado", caso sua mdia seja maior
ou igual a 5 ou "reprovado", caso sua mdia seja abaixo de 5.
c. Apresentar todos os registros, mdias e a mensagem de aprovao ou reprovao.
d. Sair do programa de cadastro.
08. Desenvolva um algoritmo para o controle de veculos que circulam em uma determinada cidade,
com um registro padro que contm as seguintes informaes: proprietrio, combustvel, modelo,
cor, nmero do chassi, ano e placa. Nestes registros, o combustvel pode ser lcool, diesel,
gasolina ou gs natural e a placa possui os trs primeiros valores alfabticos e os quatro ltimos
valores numricos inteiros. Sabendo que o nmero mximo de veculos da cidade de 5000
unidades, e que os valores no precisam ser lidos:
a. O algoritmo deve listar todos os proprietrios cujos carros so do ano de 1980 ou posterior e
que sejam movidos a diesel.
b. O algoritmo deve listar todas as placas que comecem com a letra A e terminem com 0, 2, 4 ou
7 e seus respectivos proprietrios.
c. O algoritmo deve listar o modelo e a cor dos veculos cujas placas possuem como segunda
letra uma vogal e cuja soma dos valores numricos fornece um nmero par.
d. O algoritmo deve permitir a troca de proprietrio com o fornecimento do nmero do chassi
apenas para carros com placas que no possuam nenhum dgito igual a zero.

19
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

09. Desenvolva um algoritmo que armazene o nome e a altura de quinze pessoas, por meio do uso
de registros. O algoritmo dever ser manipulado por meio de um menu que execute as seguintes
etapas:
a. Cadastrar os quinze registros.
b. Apresentar os registros de nome e altura das pessoas menores ou iguais a 1,5 metro.
c. Apresentar os registros de nome e altura das pessoas que sejam maiores que 1,5 metro.
d. Apresentar os registros de nome e altura das pessoas que sejam maiores que 1,5 metro e
menores que 2 metros.
e. Apresentar todos os registros com a mdia extrada de todas as alturas armazenadas.
f. Sair do programa de cadastro.

10. Desenvolva um algoritmo com um vetor de 44 posies. Suponha que cada posio do vetor
tenha um registro com as seguintes informaes: nmero da viagem, se ou no fumante,
destino, origem, data da viagem, horrio da viagem, poltrona e distncia em quilmetros. Supondo
no ser necessrio suprir de informaes as estruturas de dados descritas, o algoritmo deve ser
capaz de responder as seguintes questes:
a. Quais os horrios de sada de cada linha, para uma linha fornecida?
b. Quais nibus esto lotados?
c. Qual o horrio estimado de chegada e durao da viagem de dado nibus que viaja numa
mdia de 80 km/h, num nibus fornecido?
d. Qual a porcentagem de ocupao e o nmero de poltronas livres para dado nibus fornecido
pelo usurio?
e. Fornea um relatrio contendo a porcentagem de ocupao de janelas e de corredores e o
nmero de poltronas disponveis por nibus.
11. Desenvolva um algoritmo que considera os registros de vinte funcionrios, contendo os campos:
matrcula, nome e salrio. O algoritmo, por meio de um menu, deve executar as seguintes etapas:
a. Cadastrar os vinte empregados.
b. Classificar os registros por nmero de matrcula.
c. Pesquisar um determinado empregado pelo nmero de matrcula.
d. Apresentar de forma ordenada os registros dos empregados que recebem salrios acima de
1000,00.
e. Apresentar de forma ordenada os registros dos empregados que recebem salrios abaixo de
1000,00.
f. Apresentar de forma ordenada os registros dos empregados que recebem salrios iguais a
1000,00.
g. Sair do programa de cadastro.

12. Desenvolva um algoritmo com um vetor de 50 posies. Suponha que cada posio do vetor
tenha um registro com as seguintes informaes: nmero de matrcula, nome, srie, turma, sexo,
20
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

mdia, se aprovado ou no, ano de nascimento e naturalidade. Supondo no ser necessrio


suprir de informaes as estruturas de dados descritas, o algoritmo deve ser capaz de responder
s seguintes questes:
a. Qual a porcentagem de alunos aprovados e reprovados por turma?
b. Qual a porcentagem de alunos do sexo masculino e do sexo feminino por turma?
c. Qual a porcentagem de alunos estrangeiros na escola?
d. Qual a porcentagem de alunos atrasados em cada turma?
e. Quais os cinco melhores alunos na ltima prova, em ordem crescente?
Obs.: Considerar que os registros esto organizados por srie, turma e nome.

13. Desenvolva um algoritmo modularizando que, a partir de um vetor de 100 inteiros, possibilite:
a. a digitao dos valores no vetor;
b. imprimir o valor do somatrio de seus itens;
c. imprimir a mdia dos valores fornecidos;
d. calcular o desvio padro;
e. substituir por zero todos os valores negativos;
f. substituir por zero todos os valores repetidos (maiores que zero).

14. Desenvolver um algoritmo que calcule o somatrio dos n primeiros termos da srie de Fibonnacci.

15. Desenvolva um algoritmo que imprima por extenso o valor de qualquer nmero inteiro com at 12
casas.

16. Desenvolva um algoritmo que defina um registro que possua as seguintes informaes: nmero
do cheque, nmero da conta corrente, dgito da conta corrente, agncia, nome e valor. O
algoritmo deve possuir:
a. mdulo para leitura do registro;
b. mdulo para validao do registro verificador;
c. mdulo para somar e imprimir a soma total dos cheques de uma mesma pessoa, acionado
cada vez que a leitura detecta outro cliente.

17. Desenvolva um algoritmo que, considerando a necessidade de desenvolver uma agenda que
contenha nomes, endereos e telefones de 10 pessoas, defina a estrutura de registro apropriada
e a codificao do algoritmo que, por meio do uso do conceito de mdulo, apresente um menu e
seus respectivos mdulos para a execuo das seguintes etapas:
a. Cadastrar os dez registros.
b. Pesquisar os dez registros, um de cada vez, pelo campo nome.

21
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

c. Classificar por ordem de nome os registros cadastrados.


d. Apresentar todos os registros.
e. Sair do programa de cadastro.

18. Desenvolva um algoritmo que, considerando a necessidade de um programa que armazene o


nome e as notas bimestrais de 20 alunos do curso de Lgica de Programao, defina a estrutura
de registro apropriada e a codificao de um algoritmo que, por meio do uso do conceito de
mdulo, apresente um menu e seus respectivos mdulos para a execuo das seguintes etapas:
a. Cadastrar os 20 registros (aps o cadastro, efetuar a classificao por nome).
b. Pesquisar os 20 registros, um de cada vez, pelo campo nome, apresentando mdia e a
mensagem de aprovao ou reprovao.
c. Apresentar todos os registros, mdias e a mensagem de aprovao ou reprovao.
d. Apresentar apenas os registros e mdia dos alunos aprovados.
e. Apresentar apenas os registros e mdias dos alunos reprovados.
f. Sair do programa de cadastro.

19. Desenvolva um algoritmo que armazene o nome e a altura de 15 pessoas com o uso de registros.
O algoritmo dever ser manipulado por meio do uso de mdulos tanto na apresentao do menu,
como de seus mdulos, para a execuo das seguintes etapas:
a. Cadastrar os 15 registros.
b. Apresentar os registros das pessoas menores ou iguais a 1,5 metro.
c. Apresentar os registros das pessoas que sejam maiores que 1,5 metro.
d. Apresentar todos os registros com a mdia extrada de todas as alturas armazenadas.
e. Sair do programa.
20. Desenvolva um algoritmo que considera os registros de 20 funcionrios, contendo os campos
matrcula, nome e salrio. O algoritmo deve utilizar o conceito de mdulo, apresente um menu e
seus respectivos mdulos para a execuo das seguintes etapas:
a. Cadastrar os 20 empregados.
b. Classificar os registros por nmero de matrcula.
c. Pesquisar um determinado empregado pelo nmero de matrcula.
d. Apresentar de forma ordenada os registros dos empregados que recebem salrios acima de
1000,00.
e. Apresentar de forma ordenada os registros dos empregados que recebem salrios abaixo de
1000,00.
f. Apresentar de forma ordenada os registros dos empregados que recebem salrios iguais a
1000,00.
g. Sair do programa de cadastro.

22
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

3. Arquivos
Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos usar
vrias informaes de diferentes tipos de dados cuja entrada no seja somente pelo usurio. Para
isso, podemos utilizar arquivos para fornecer essas informaes ao programa e tambm para
armazenar outras informaes do programa.
Um arquivo uma estrutura capaz de armazenar vrias informaes de diferentes tipos de dados,
alm de possuir uma capacidade de armazenamento de grandes quantidades de informaes.
Assim, com um nico arquivo, podemos manipular vrias informaes de diferentes tipos de
dados e em grandes quantidades.
Um arquivo pode ser manipulado dentro de uma estrutura de deciso, seja ela simples, composta
ou encadeada, dentro de uma estrutura de mltipla escolha, dentro das estruturas de repetio,
ou, ainda, dentro dos mdulos.
Um arquivo nada mais do que um conjunto de registros, ou seja, uma estrutura de dados sem
tamanho fixo para as informaes. Neste captulo, veremos como e quando trabalhar com um
arquivo, bem como declarar, abrir, fechar e manipular um arquivo.

3.1. Definio de Arquivo


Um arquivo um conjunto de registros e como tal precisamos definir o registro com os campos de
informaes que esto dentro do arquivo para, ento, definirmos o arquivo. Podemos definir, por
exemplo, um registro que armazena as seguintes informaes: nome do aluno, registro do aluno,
nota do primeiro bimestre, nota do segundo bimestre e mdia final. Para este exemplo, note que
cada uma das informaes possui tipos de dados diferentes, ou seja, o campo nome do aluno
do tipo alfanumrico, o campo registro do aluno do tipo numrico_inteiro, os campos nota do
primeiro bimestre, nota do segundo bimestre e mdia final so do tipo numrico_real.
tipo RegistroAluno = registro // o tipo registro chama-se RegistroAluno
NAluno alfanumrico; // campo nome do aluno
RAluno numrico_inteiro; // campo registro do aluno
Nota1Bim numrico_real; // campo nota do primeiro bimestre
Nota2Bim numrico_real; // campo nota do segundo bimestre
MediaFinal numrico_real; // campo mdia final
fimregistro;
RegistroAluno Aluno; // declarao da varivel Aluno do tipo RegistroAluno
Agora que temos um registro definido e declarado, podemos definir um arquivo que ser
composto pelo conjunto desses registros. Para isso, um tipo arquivo precisa ser definido para que
todos os conjuntos de campos dentro do arquivo sejam previamente definidos de acordo com os
campos definidos no registro. Uma vez o tipo arquivo definido, ele pode ser usado como qualquer
outro tipo de dado, ou seja, ele precisa ser declarado e pode ser usado como qualquer outro tipo
de dado.

23
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Pseudocdigo
Na definio de um tipo arquivo, utilizaremos as palavras tipo e arquivo de que representam as
palavras principais desta estrutura e a palavra fimarquivo; para determinar o fim do bloco de
definio desta estrutura. A definio de um tipo arquivo para pseudocdigo segue esta regra
sinttica:
tipo <nome do tipo arquivo> = arquivo de <nome do tipo registro>
fimarquivo;
Por exemplo:
tipo ArquivoAluno = arquivo de RegistroAluno
fimarquivo;
Neste exemplo, foi definido um tipo arquivo chamado ArquivoAluno, cujo contedo deve ser
composto pelos mesmos campos de informaes definidos no tipo registro chamado
RegistroAluno.

3.2. Declarao de Arquivos


A partir do momento em que temos um tipo arquivo definido, devemos saber como declar-lo. A
declarao de um arquivo segue os mesmos padres da declarao de qualquer tipo de dado.
Lembre-se de que um tipo arquivo pode ser considerado como um novo tipo de dado definido pelo
usurio.
Pseudocdigo
A declarao de um arquivo para pseudocdigo segue esta regra sinttica:
<nome do arquivo> <nome do tipo arquivo>;
Por exemplo:
ArqAluno ArquivoAluno;
Neste exemplo, declaramos um arquivo chamado ArqAluno do tipo ArquivoAluno, ou seja,
ArqAluno uma varivel, com o nome do arquivo, do tipo AquivoAluno que contm os campos
NAluno, RAluno, Nota1Bim, Nota2Bim e MediaFinal.

24
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Java
Para o tratamento de arquivo em java, utilizaremos a seguinte biblioteca: java.io. Assim, para
todos os programas que utilizam tratamento de arquivo em java, precisamos importar essa
biblioteca, no incio do programa e juntamente com as outras bibliotecas, da seguinte forma:
import java.io.*;
A declarao de um arquivo de gravao de dados para Java segue esta regra sinttica:
FileWriter <nome da varivel>;
Por exemplo:
FileWriter ArqAluno;
A declarao de um arquivo de leitura de dados para Java segue esta regra sinttica:
FileReader <nome da varivel>;
Por exemplo:
FileReader ArqAluno;
Neste exemplo, declaramos uma varivel chamada ArqAluno do tipo FileReader.

3.3. Manipulao de Arquivos


A partir do momento em que temos um registro declarado, devemos saber como manipular as
informaes com os arquivos. Os comandos para a manipulao de arquivos esto detalhados
abaixo.

3.3.1. Abertura de Arquivo em Pseudocdigo e em Java


A abertura de um arquivo em pseudocdigo segue esta regra sinttica:
abrir (<nome do arquivo>);
Por exemplo:
abrir(ArqAluno);

25
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Neste exemplo, o arquivo cujo nome est armazenado na varivel ArqAluno ser aberto para
manipulao.
A abertura de um arquivo para gravao de dados em Java segue esta regra sinttica:
<nome da varivel> = new FileWriter (<nome do arquivo>);
Por exemplo:
ArqAluno = new FileWriter ("ArquivoAluno.txt");
Neste exemplo, criamos e abrimos um arquivo chamado ArqAluno do tipo FileWriter, ou seja,
ArqAluno uma varivel, com o nome do arquivo, "ArquivoAluno.txt". Se este arquivo no existe,
ele ser criado para gravao de dados, se este arquivo j existe, suas informaes sero
apagadas para a gravao de novos dados.
Podemos abrir um arquivo existente e gravar um novo contedo logo abaixo do contedo
existente neste arquivo. Para isso, utilizamos a seguinte regra sinttica:
<nome da varivel> = new FileWriter (<nome do arquivo> , true);
Por exemplo:
ArqAluno = new FileWriter ("ArquivoAluno.txt" , true);
Neste exemplo, abrimos um arquivo existente e chamado ArqAluno, do tipo FileWriter, ou seja,
ArqAluno uma varivel, com o nome do arquivo, "ArquivoAluno.txt". Se este arquivo no existe,
ele ser criado para gravao de dados, se este arquivo j existe, suas informaes sero
mantidas e a gravao dos novos dados ocorrer aps essas informaes.
A abertura de um arquivo para leitura de dados em Java segue esta regra sinttica:
<nome da varivel> = new FileReader (<nome do arquivo>);
Por exemplo:
ArqAluno = new FileReader ("ArquivoAluno.txt");

Neste exemplo, abrimos um arquivo j existente chamado ArqAluno do tipo FileReader, ou seja,
ArqAluno uma varivel, com o nome do arquivo, "ArquivoAluno.txt". Este arquivo j existe e
ser manipulado para leitura dos dados.

3.3.2. Fechamento de arquivo em pseudocdigo e em Java


O fechamento de um arquivo em pseudocdigo segue esta regra sinttica:

26
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fechar (<nome do arquivo>);


Por exemplo:
fechar (ArqAluno);
Neste exemplo, o arquivo cujo nome est armazenado na varivel ArqAluno ser fechado para
manipulao.
O fechamento de um arquivo em Java segue esta regra sinttica:
<nome do arquivo>.close();
Por exemplo:
ArqAluno.close();
Neste exemplo, o arquivo cujo nome est armazenado na varivel ArqAluno ser fechado para
manipulao.

3.3.3. Leitura de Elementos do Arquivo em Pseudocdigo e em Java


A leitura de um contedo de um arquivo para um registro em pseudocdigo segue esta regra
sinttica:
lerarq (<nome do arquivo> , <nome do registro>);
Por exemplo:
lerarq (ArqAluno , Aluno);
Neste exemplo, o contedo do primeiro conjunto de dados do arquivo ArqAluno ser lido e
armazenado na varivel registro Aluno. Note que todas as informaes sero armazenadas
adequadamente em seus respectivos campos, ou seja, no campo Naluno, do registro Aluno, ser
armazenado o dado do campo NAluno do primeiro conjunto de dados do arquivo ArqAluno e
assim respectivamente para cada campo do registro.
Uma vez o arquivo aberto, sempre que o comando lerarq for utilizado, ele automaticamente
passa para o prximo conjunto de dados do arquivo, ou seja, na primeira vez em que o comando
lerarq for utilizado, o primeiro conjunto de dados ser lido, na segunda vez em que o comando
lerarq for utilizado, o segundo conjunto de dados ser lido, e assim por diante at que o arquivo
seja fechado ou at que todos os conjuntos de dados de dentro do arquivo j tenham sido lidos.
A leitura de um contedo de um arquivo em Java segue esta regra sinttica:

27
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

<nome da varivel> = <nome do arquivo>.readLine();


Por exemplo:
String campo;
Campo = ArqAluno.readLine();
Neste exemplo, o contedo da primeira linha do arquivo ArqAluno ser lido e armazenado na
varivel Campo. Note que a informao da linha inteira do arquivo ser armazenada na varivel
Campo, ou seja, para armazenar os dados de um arquivo em Java para um registro, as
informaes por linha em cada campo do registro devem ser manipuladas separadamente ou
cada informao em cada linha do arquivo deve ser um campo do registro.
Uma vez o arquivo aberto, sempre que o comando readLine() for utilizado, ele automaticamente
passa para a prxima linha do arquivo, ou seja, na primeira vez em que o comando readLine() for
utilizado, a primeira linha ser lida, na segunda vez que o comando readLine() for utilizado, a
segunda linha ser lida e assim por diante at que o arquivo seja fechado ou at que todas as
linhas de dentro do arquivo j tenham sido lidas.
A leitura de dados em disco torna-se mais eficiente se usarmos um buffer, ou seja, uma memria
local para entrada de dados. No Java, o fluxo BufferedReader usado como um fluxo de entrada
orientado a caracter e segue esta regra sinttica:
BufferedReader <nome do buffer> = new BufferedReader (<nome do arquivo>);
Por exemplo,
ArqAluno = new FileReader ("ArquivoAluno.txt");
BufferedReader BufferAluno = new BufferedReader (ArqAluno);

3.3.4. Gravando o Contedo para um Arquivo em Pseudocdigo e em Java


A gravao de um contedo de um registro para um arquivo em pseudocdigo segue esta regra
sinttica:
gravar (<nome do arquivo> , <nome do registro>);
Por exemplo:
gravar (ArqAluno , Aluno);
Neste exemplo, o contedo do registro Aluno ser gravado para o arquivo ArqAluno. Note que
todas as informaes sero armazenadas adequadamente em seus respectivos campos, ou seja,
no campo Naluno, do conjunto de dados do arquivo ArqAluno, ser armazenado o dado do
campo NAluno do registro Aluno e assim por diante para, respectivamente, cada campo do
arquivo.
28
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Uma vez o arquivo aberto, sempre que o comando gravar for utilizado, ele automaticamente
passa para o prximo conjunto de dados do arquivo, ou seja, na primeira vez em que o comando
gravar for utilizado, o primeiro conjunto de dados ser gravado, na segunda vez em que o
comando gravar for utilizado, o segundo conjunto de dados ser gravado e assim por diante at
que o arquivo seja fechado ou at que todos os conjuntos de dados j tenham sido gravados para
o arquivo.
A gravao de um contedo para um arquivo em Java segue esta regra sinttica:
<nome do arquivo>.write(<contedo a ser gravado>);
Por exemplo:
ArqAluno.write("Esta mensagem ser gravada para dentro do arquivo \n");
Neste exemplo, o contedo "Esta mensagem ser gravada para dentro do arquivo" ser
gravada para o arquivo ArqAluno. Note que o contedo ser armazenado numa linha do arquivo
e s pula de linha pelo uso do \n, dentro do contedo. Neste caso, para armazenar os dados de
um registro em um arquivo em Java, as informaes por linha de cada campo do registro devem
ser manipuladas separadamente ou cada informao em cada linha do arquivo deve ser um
campo do registro.
Uma vez o arquivo aberto, sempre que o comando write() for utilizado, ele no pula
automaticamente para a prxima linha do arquivo, ou seja, sempre que for necessrio pular de
linha dentro do arquivo, o uso do \n obrigatrio dentro do contedo a ser armazenado no
arquivo.
A sada de dados em disco torna-se mais eficiente se usarmos um buffer, ou seja, uma memria
local para sada de dados. No Java, o fluxo BufferedWriter usado como um fluxo de sada
orientado a caracter e segue esta regra sinttica:
BufferedWriter <nome do buffer> = new BufferedWriter (<nome do arquivo>);
Por exemplo,
ArqAluno = new FileWriter ("ArquivoAluno.txt");
BufferedWriter BufferAluno = new BufferedWriter (ArqAluno);

3.4. Exemplo de Arquivos em Pseudocdigo


1. Desenvolva um algoritmo que defina um registro com os campos nome, idade e altura e que
receba informaes de um arquivo relacionado ao registro definido, com dados de uma pessoa
membro de sua famlia. Alm disso, esse algoritmo deve mostrar esses valores.
Algoritmo Exemplo1
incio_algoritmo
Definir
29
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

// definio do tipo registro RegistroFamilia com os campos abaixo


tipo RegistroFamilia = registro // o tipo registro chama-se RegistroFamilia
Nome alfanumrico; // campo nome
Idade numrico_inteiro; // campo idade
Altura numrico_real; // campo altura
fimregistro;
// definio do tipo arquivo ArquivoFamilia
tipo ArquivoFamilia = arquivo de RegistroFamilia
fimarquivo;
Declarar
Membro RegistroFamilia; // declarao de um Registro do tipo RegistroFamlia
ArqFamilia ArquivoFamilia; // declarao de um Arquivo do tipo ArquivoFamilia
abrir (ArqFamilia); // abrindo o arquivo ArqFamilia
/* l registro com todos os campos do arquivo ArqFamilia e armazena no registro Membro*/
lerarq (ArqFamilia,Membro);
// sada de resultados
escrever ("A pessoa " , Membro.Nome , " de Idade " , Membro.Idade , " tem altura " ,
Membro.Altura);
fechar (ArqFamilia); // fechando o arquivo ArqFamilia
fim_algoritmo.
2. Desenvolva um algoritmo que defina um registro com os campos nome, idade e altura e que
receba informaes de um arquivo relacionado ao registro definido, com dados de 5 pessoas
membros de sua famlia num vetor do registro definido. Ademais, esse algoritmo deve mostrar
esses valores.
Algoritmo Exemplo2
incio_algoritmo
Definir
// definio do tipo registro RegistroFamilia com os campos abaixo
tipo RegistroFamilia = registro // o tipo registro chama-se RegistroFamilia
Nome alfanumrico; // campo nome
Idade numrico_inteiro; // campo idade
Altura numrico_real; // campo altura
fimregistro;
// definio do tipo arquivo ArquivoFamilia
30
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

tipo ArquivoFamilia = arquivo de RegistroFamilia


fimarquivo;
Declarar
// declarao de um vetor de registros do tipo RegistroFamilia
Membro[5] RegistroFamilia;
ArqFamilia ArquivoFamilia; // declarao de um Arquivo do tipo ArquivoFamilia
i numrico_inteiro; // declarao de uma varivel inteira
abrir (ArqFamilia); // abrindo o arquivo ArqFamilia
para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros
/* l registro com todos os campos do arquivo ArqFamilia e armazena no vetor de registro
Membro na posio i*/
lerarq (ArqFamilia,Membro[i]);
fimpara;
para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros
// sada de resultados
escrever ("A pessoa " , Membro[i].Nome , " de Idade " , Membro[i].Idade , " tem altura " ,
Membro[i].Altura);
fimpara;
fechar (ArqFamilia); // fechando o arquivo ArqFamilia
fim_algoritmo.
3. Desenvolva um algoritmo modularizado que defina um registro com os campos nome, idade e
altura e que receba informaes de um arquivo relacionado ao registro definido, com dados de
5 pessoas membros de sua famlia num vetor do registro definido. Alm disso, esse algoritmo
deve mostrar esses valores. Posteriormente, armazene esses dados num segundo arquivo.
// funo chamada EntradaDados que recebe e retorna um vetor do tipo RegistroFamilia
Algoritmo_Global
incio
Definir globalmente
// definio do tipo registro RegistroFamilia com os campos abaixo
tipo RegistroFamilia = registro // o tipo registro chama-se RegistroFamilia
Nome alfanumrico; // campo nome
Idade numrico_inteiro; // campo idade
Altura numrico_real; // campo altura
fimregistro;

31
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

RegistroFamilia [ ] EntradaDados (Vet[ ] RegistroFamilia)


incio
Definir
// definio do tipo arquivo ArquivoFamilia
tipo ArquivoFamilia = arquivo de RegistroFamilia
fimarquivo;
Declarar
i nmerico_inteiro; // declarao de uma varivel inteira
ArqFamilia ArquivoFamilia; // declarao de um Arquivo do tipo ArquivoFamilia
abrir (ArqFamilia); // abrindo o arquivo ArqFamilia
para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros
/* l registro com todos os campos do arquivo ArqFamilia e armazena no vetor de registro
Vet na posio i*/
lerarq (ArqFamilia,Vet[i]);
fimpara;
fechar (ArqFamilia); // fechando o arquivo ArqFamilia
retornar Vet; // retorno do vetor Vet
fim_mdulo;
SaidaDados (Vet[ ] RegistroFamilia)
incio
Definir
// definio do tipo arquivo ArquivoFamilia
tipo ArquivoFamilia = arquivo de RegistroFamilia
fimarquivo;
Declarar
i nmerico_inteiro; // declarao de uma varivel inteira
ArqFamilia ArquivoFamilia; // declarao de um Arquivo do tipo ArquivoFamilia
abrir (ArqFamilia); // abrindo o arquivo ArqFamilia
para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros
/* grava registro com todos os campos do vetor de registro Vet na posio i no arquivo
ArqFamilia*/
gravar (ArqFamilia,Vet[i]);
fimpara;
fechar (ArqFamilia); // fechando o arquivo ArqFamilia
32
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fim_mdulo;
Algoritmo Exemplo3
incio_algoritmo
Declarar
// declarao de um vetor de registros do tipo RegistroFamilia
Membro[5] RegistroFamilia;
i numrico_inteiro; // declarao de uma varivel inteira
// chamada da funo EntradaDados, enviando como parmetro o argumento Membro[ ]
// o retorno da funo EntradaDados ser armazenado no vetor Membro[ ]
Membro EntradaDados (Membro);
para i de 0 at 4 passo +1 faa // para cada posio do vetor de registros
// sada de resultados
escrever ("A pessoa " , Membro[i].Nome , " de Idade " , Membro[i].Idade , " tem altura " ,
Membro[i].Altura);
fimpara;
/* chamada do procedimento SaidaDados, enviando como parmetro o argumento Membro[ ]*/
SaidaDados(Membro[ ]);
fim_algoritmo.
fim_algoritmo_global.

3.5. Exemplo de Arquivos em Java


1. Desenvolva um algoritmo que defina um registro com os campos nome, idade e altura e que
receba informaes de um arquivo relacionadas ao registro definido, com dados de uma
pessoa membro de sua famlia. Finalmente, esse algoritmo deve mostrar esses valores.
class RegistroFamilia
{
// definio do tipo registro RegistroFamilia com os campos abaixo
String Nome; // campo nome
int Idade; // campo idade
double Altura; // campo altura
// construtor do tipo registro
RegistroFamilia (String N , int I , double A)
{
Nome = N; // campo nome
Idade = I; // campo idade
Altura = A; // campo altura
} // fim do construtor do registro
33
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

} // fim da definio do tipo registro


class Exemplo1
{
// void main com tratamento de erro de entrada e sada de dados
public static void main (String args [ ]) throws IOException
{
// declarao de um Registro Membro do tipo RegistroFamlia
RegistroFamilia Membro = new RegistroFamilia ("" , 0 , 0.0);
// declarao de uma varivel arquivo do tipo FileReader
FileReader ArqFamilia;
/* abre um arquivo de leitura e armazena o nome deste
arquivo na varivel ArqFamilia*/
ArqFamilia = new FileReader ("ArquivoFamilia.txt");
// abre um buffer de leitura de dados
BufferedReader BArqFamilia = new BufferedReader (ArqFamilia);
// L o nome do arquivo e armazena no campo Nome do registro
Membro.Nome = BArqFamilia.readLine();
/* L a idade do arquivo e armazena no campo Idade do
registro Membro*/
Membro.Idade = Integer.parseInt(BArqFamilia.readLine());
// L a altura e armazena no campo Altura do registro Membro
Membro.Altura = Double.parseDouble(BArqFamilia.readLine());
// sada de resultados
System.out.println ("A pessoa " + Membro.Nome + " de Idade "
+ Membro.Idade + " tem altura " + Membro.Altura);
ArqFamilia.close(); // fechando arquivo
System.exit(0);
} // fim do void main
} // fim da classe
2. Desenvolva um algoritmo que defina um registro com os campos nome, idade e altura e que
receba informaes de um arquivo relacionadas ao registro definido, com dados de 5 pessoas
membros de sua famlia num vetor do registro definido. Esse algoritmo deve, ainda, mostrar
esses valores.
class RegistroFamilia
{
// definio do tipo registro RegistroFamilia com os campos abaixo
String Nome; // campo nome
int Idade; // campo idade
double Altura; // campo altura
// construtor do tipo registro
RegistroFamilia (String N , int I , double A)
{
Nome = N; // campo nome
Idade = I; // campo idade
Altura = A; // campo altura
34
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

} // fim do construtor do registro


} // fim da definio do tipo registro
class Exemplo2
{
// void main com tratamento de erro de entrada e sada de dados
public static void main (String args [ ]) throws IOException
{
RegistroFamilia[ ] Membro = new RegistroFamilia [5];
// declarao de uma varivel arquivo do tipo FileReader
FileReader ArqFamilia;
int i;
for (i=0 ; i<5 ; i++)
{
Membro[i] = new RegistroFamilia("" , 0 , 0.0);
}
/* abre um arquivo de leitura e armazena o nome deste
arquivo na varivel ArqFamilia*/
ArqFamilia = new FileReader ("ArquivoFamilia.txt");
// abre um buffer de leitura de dados
BufferedReader BArqFamilia = new BufferedReader (ArqFamilia);
for (i=0 ; i<5 ; i++)
{
/* L o nome do arquivo e armazena no campo Nome do
registro Membro*/
Membro[i].Nome = BArqFamilia.readLine();
/* L a idade do arquivo e armazena no campo Idade do
registro Membro*/
Membro[i].Idade = Integer.parseInt(
BArqFamilia.readLine());
/* L a altura e armazena no campo Altura do registro
Membro*/
Membro[i].Altura = Double.parseDouble(
BArqFamilia.readLine());
}
for (i=0 ; i<5 ; i++)
{
// sada de resultados
System.out.println ("A pessoa " + Membro[i].Nome +
" de Idade " + Membro[i].Idade +
" tem altura " + Membro[i].Altura);
}
ArqFamilia.close(); // fechando arquivo
System.exit(0);
} // fim do void main
} // fim da classe

35
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

3. Desenvolva um algoritmo modularizado que defina um registro com os campos nome, idade e
altura e que receba informaes de um arquivo relacionadas ao registro definido, com dados
de 5 pessoas membros de sua famlia num vetor do registro definido. Alm disso, esse
algoritmo deve mostrar esses valores.
Para este programa, precisaremos das seguintes bibliotecas:
import java.text.*; // usado para formatao de decimais
import javax.swing.*; // usado para entrada e sada de dados ao usurio
import java.io.*; // usado para manipulao de arquivos
class RegistroFamilia
{
// definio do tipo registro RegistroFamilia com os campos abaixo
String Nome; // campo nome
int Idade; // campo idade
double Altura; // campo altura
// construtor do tipo registro
RegistroFamilia (String N , int I , double A)
{
Nome = N; // campo nome
Idade = I; // campo idade
Altura = A; // campo altura
} // fim do construtor do registro
} // fim da definio do tipo registro
class Exemplo3
{
// funo com tratamento de erro de entrada e sada de dados
/* funo chamada EntradaDados que recebe e retorna um vetor do
tipo RegistroFamilia*/
static RegistroFamilia [ ] EntradaDados (RegistroFamilia Vet[ ])
throws IOException
{
// declarao de uma varivel arquivo do tipo FileReader
FileReader ArqFamilia;
int i; // declarao de uma varivel inteira
/* abre um arquivo de leitura e armazena o nome deste
arquivo na varivel ArqFamilia*/
ArqFamilia = new FileReader ("ArquivoFamilia.txt");
// abre um buffer de leitura de dados
BufferedReader BArqFamilia = new BufferedReader (ArqFamilia);
for (i=0 ; i<5 ; i++)
{
/* L o nome do arquivo e armazena no campo Nome do
registro Membro*/
Vet[i].Nome = BArqFamilia.readLine();
36
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

// L a idade do arquivo e armazena no campo Idade


Vet[i].Idade = Integer.parseInt(
BArqFamilia.readLine());
/* L a altura e armazena no campo Altura do registro
Membro*/
Vet[i].Altura = Double.parseDouble(
BArqFamilia.readLine());
}
BArqFamilia.close(); // fechando arquivo
return Vet; // retorno do vetor Vet
} // fim da funo EntradaDados
/* procedimento com tratamento de erro de entrada e sada de
dados*/
/* procedimento chamado saidaDados que recebe um vetor do tipo
RegistroFamilia*/
static void SaidaDados (RegistroFamilia Vet[ ]) throws IOException
{
// declarao de uma varivel arquivo do tipo FileWriter
FileWriter ArqFamilia;
int i; // declarao de uma varivel inteira
/* abre um arquivo de gravao e armazena o nome deste
arquivo na varivel ArqFamilia*/
ArqFamilia = new FileWriter ("ArquivoFamiliaS.txt");
// abre um buffer de gravao de dados
BufferedWriter BArqFamilia = new BufferedWriter(
ArqFamilia);
for (i=0 ; i<5 ; i++)
{
/* L o contedo do campo Nome do registro Membro e
grava no arquivo*/
BArqFamilia.write(Vet[i].Nome);
BArqFamilia.newLine(); // pula linha
/* L o contedo do campo Idade do registro Membro e
grava no arquivo*/
DecimalFormat aux = new DecimalFormat("###,###.###");
BArqFamilia.write(aux.format(Vet[i].Idade));
BArqFamilia.newLine(); // pula linha
/* L o contedo do campo Altura do registro Membro,
converte para String no formato decimal desejado e grava no arquivo*/
BArqFamilia.write(aux.format(Vet[i].Altura));
BArqFamilia.newLine(); // pula linha
}
ArqFamilia.close(); // fechando arquivo
} // fim da funo EntradaDados
// void main com tratamento de erro de entrada e sada de dados

37
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public static void main (String args [ ]) throws IOException


{
RegistroFamilia[ ] Membro = new RegistroFamilia [5];
int i;
for (i=0 ; i<5 ; i++)
{
Membro[i] = new RegistroFamilia("" , 0 , 0.0);
}
/* chamada da funo EntradaDados, enviando como parmetro o
argumento Membro[ ]*/
/* o retorno da funo EntradaDados ser armazenado no vetor
Membro[ ]*/
Membro = EntradaDados (Membro);
for (i=0 ; i<5 ; i++)
{
// sada de resultados
System.out.println ("A pessoa " + Membro[i].Nome +
" de Idade " + Membro[i].Idade +
" tem altura " + Membro[i].Altura);
}
SaidaDados(Membro);
System.exit(0);
} // fim do void main
} // fim da classe

3.6. Exerccios de Arquivos


01. Desenvolva um algoritmo para criar um arquivo chamado alunos, no qual cada registro ser
composto pelos seguintes campos: nmero, nome, curso, nota1 e nota2.

02. Desenvolva um algoritmo para incluir alunos num arquivo j criado no exerccio 1, lembrando que
no podem existir dois alunos com o mesmo nmero.

03. Desenvolva um algoritmo para alterar as notas dos alunos do arquivo criado no exerccio 1.

04. Desenvolva um algoritmo para alterar o curso dos alunos do arquivo criado no exerccio 1.

05. Desenvolva um algoritmo para excluir os alunos do arquivo criado no exerccio 1.

06. Desenvolva um algoritmo para consultar o nmero, o nome e a mdia de todos os alunos
cadastrados no arquivo criado no exerccio 1.

38
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

07. Desenvolva um algoritmo para consultar o nmero, o nome e a mdia de todos os alunos
cadastrados no arquivo criado no exerccio 1 e que estejam aprovados, ou seja, com a mdia, no
mnimo, 7.

08. Desenvolva um algoritmo para consultar o nmero, o nome e o curso de todos os alunos
cadastrados no arquivo criado no exerccio 1 e que estejam reprovados, ou seja, com a mdia
inferior a 3.

09. Desenvolva um algoritmo para consultar o nome de todos os alunos cadastrados no arquivo
criado no exerccio 1 e que estejam de exame, ou seja, com mdia entre 3 (inclusive) e 7.

10. Desenvolva um algoritmo que utilize um arquivo de uma biblioteca, no qual cada livro
catalogado por meio de um registro e o conjunto desses registros compe um arquivo que
corresponde ao acervo de livros da biblioteca. Deve-se considerar que os dados do registro so:
cdigo do livro, ttulo, autor, assuntos, editora e ano. O algoritmo deve ser destinado:
a. ao usurio da categoria leitor, que almeja obter uma relao dos livros de que a biblioteca
dispe sobre determinado assunto;
b. ao usurio da categoria funcionrio, que precisa exercer qualquer espcie de manipulao dos
dados a partir de um cdigo de livro.

11. Desenvolva um algoritmo que realize a unio de dois arquivos dados. Os dois arquivos so
concebidos seqencialmente, de forma que o primeiro arquivo tenha as seguintes informaes:
nome, endereo e telefone; e o segundo tenha as seguintes informaes: nome, endereo, bairro,
cidade, CEP e data de nascimento. Essa unio implica criar um terceiro arquivo no qual constem
apenas informaes das pessoas que faziam parte de ambos os arquivos seqenciais;
informaes que no possuem correspondncia no devero existir no terceiro arquivo.

12. Desenvolva um algoritmo em que haja dois arquivos de nomes e telefones que sejam
inicialmente idnticos e que sejam entregues a pessoas diferentes, as quais freqentemente vo
atualizando-os, porm cada uma faz atualizaes em registros diferentes. Resultado: pouco
tempo depois, os arquivos esto diferentes, mas deseja-se unificar as alteraes, gerando um
novo arquivo que contemple as alteraes mais recentes. A estrutura do registro deve conter as
seguintes informaes: nome, telefone, data de alterao e tipo de operao. Observando que
deve existir um campo Tipo de Operao, que vale A para uma Alterao, E para uma Excluso e
I para uma Incluso. Consideremos tambm que os registros excludos no so eliminados (so
apenas marcados).

13. A partir da estrutura dos registros, desenvolva os algoritmos solicitados para administrar os
problemas cotidianos de um clube, cujas informaes esto em dois arquivos:

arquivo de associados com as seguintes informaes: nmero do scio, nome, endereo,


bairro, cidade, estado, nmero de dependentes, data da associao.

arquivo de mensalidades com as seguintes informaes: nmero do scio, data de


vencimento, valor e data de pagamento.

39
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

a. calcular o nmero total de possveis freqentadores do clube (titulares + dependentes);


b. apresentar a relao dos associados que aniversariam em determinado ms fornecido;
c. construir um nico algoritmo capaz de fazer incluses, alteraes e excluses no arquivo de
associados;
d. elaborar um algoritmo que crie uma nova mensalidade para cada scio, na data e valor
fornecidos;
e. apresentar a relao dos associados inadimplentes, junto com o respectivo valor total da
dvida, mostrando, ao final, o valor totalizado de todas as dvidas dos associados.

14. Com o arquivo de registros a seguir, desenvolva os algoritmos relacionados administrao de


contas correntes em um banco:

arquivo de correntistas com as seguintes informaes: conta corrente, correntista, data de


abertura e agncia;

arquivo de agncias com as seguintes informaes: nmero da agncia e nome da agncia.


arquivo de lanamentos com as seguintes informaes: conta corrente, data, valor,
documento e histrico.
a. imprimir relao com o nome e a quantidade de correntistas de cada agncia;
b. imprimir um ranking das dez agncias com maior montante de saldos;
c. calcular o saldo do dado correntista em uma data fornecida;
d. imprimir um extrato para um perodo (data inicial e data final) e conta corrente fornecida. O
extrato deve apresentar o saldo anterior e, para cada lanamento do perodo, deve apresentar
a data, histrico, nmero do documento e valor. Ao final, deve apresentar o saldo
remanescente

15. Dados trs arquivos com as informaes descritas abaixo, desenvolva os algoritmos
especificados que tm por objetivo suprir as necessidades de uma vdeo locadora:

arquivo de clientes com as seguintes informaes: cdigo, telefone, nome, endereo, RG e


CPF;

arquivo de fitas de vdeo com as seguintes informaes: cdigo, se possui Oscar ou no, ttulo,
assunto, data de compra e preo;

arquivo de movimento com as seguintes informaes: cdigo da fita, cdigo do cliente,


quantidade de dias fora e preo.
a. consultar quais nomes e assuntos dos filmes um cliente, fornecido, j locou;
b. consultar quais clientes (com nome e telefone) locaram determinada fita;
c. imprimir relatrio:
de gastos de cada cliente;
de relao de fitas que cada cliente locou mais de uma vez, com suas respectivas
quantidades;
de fitas por assunto;
40
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

de fitas premiadas com um Oscar.


d. consultar quais filmes j premiados com Oscar um determinado cliente j locou;
e. imprimir uma relao com todas as fitas j locadas e o total de tempo respectivo em que cada
uma foi locada;
f. imprimir um relatrio com as dez fitas mais locadas;
g. imprimir um relatrio com a rentabilidade acumulada das duas fitas que mais e das duas que
menos foram locadas.

16. Desenvolva um algoritmo que defina um registro que possua as seguintes informaes: nmero
do cheque, nmero da conta corrente, dgito da conta corrente, agncia, nome e valor. Esse
algoritmo deve receber informaes de um arquivo. O algoritmo deve possuir:
a. mdulo para leitura do registro;
b. mdulo para validao do registro verificador;
c. mdulo para somar e imprimir a soma total dos cheques de uma mesma pessoa, acionado
cada vez em que a leitura detecta outro cliente.

17. Considerando-se a necessidade de desenvolver uma agenda que contenha nomes, endereos e
telefones de 10 pessoas, desenvolva um algoritmo que defina a estrutura de registro apropriada
cuja informao ser recebida de um arquivo. Por meio do uso do conceito de mdulo, a
codificao do algoritmo deve apresentar um menu e seus respectivos mdulos para a execuo
das seguintes etapas:
a. cadastrar (do arquivo para um vetor de registro) os dez registros;
b. pesquisar um dos dez registros, pelo campo nome, informado pelo usurio;
c. classificar, por ordem de nome, os registros cadastrados;
d. apresentar todos os registros;
e. inserir um registro no arquivo sem apagar os registros existentes;
f. gravar todas as informaes do vetor de registro para um arquivo;
g. sair do programa de cadastro.

18. Considerando-se a necessidade de um programa que armazene o nome e as notas bimestrais de


20 alunos do curso de Lgica de Programao, desenvolva um algoritmo que defina a estrutura
de registro apropriada cujas informaes sero recebidas de um arquivo. Por meio do uso do
conceito de mdulo, a codificao de um algoritmo deve apresentar um menu e seus respectivos
mdulos para a execuo das seguintes etapas:
a. cadastrar os 20 registros (aps o cadastro, efetuar a classificao por nome);
b. pesquisar os 20 registros, um de cada vez, pelo campo nome, apresentando mdia e a
mensagem de aprovao ou reprovao;
c. apresentar todos os registros, mdias e a mensagem de aprovao ou reprovao;
d. apresentar apenas os registros e mdia dos alunos aprovados;

41
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

e. apresentar apenas os registros e mdias dos alunos reprovados;


f. sair do programa de cadastro.

19. Desenvolva um algoritmo que armazene o nome e a altura de 15 pessoas com o uso de registros
e arquivos. O algoritmo dever ser manipulado por meio do uso de mdulos tanto na
apresentao do menu, como de seus mdulos, para a execuo das seguintes etapas:
a. cadastrar os 15 registros;
b. apresentar os registros das pessoas menores ou iguais a 1,5 metro;
c. apresentar os registros das pessoas que sejam maiores que 1,5 metro;
d. apresentar todos os registros com a mdia extrada de todas as alturas armazenadas;
e. sair do programa.

20. Desenvolva um algoritmo que considere os registros de 20 funcionrios, contendo os campos


matrcula, nome e salrio e cujas informaes sero recebidas de um arquivo. O algoritmo deve
utilizar o conceito de mdulo, apresentar um menu e seus respectivos mdulos para a execuo
das seguintes etapas:
a. cadastrar os 20 empregados;
b. classificar os registros por nmero de matrcula;
c. pesquisar um determinado empregado pelo nmero de matrcula;
d. apresentar de forma ordenada os registros dos empregados que recebem salrios acima de
1000,00;
e. apresentar de forma ordenada os registros dos empregados que recebem salrios abaixo de
1000,00;
f. apresentar de forma ordenada os registros dos empregados que recebem salrios iguais a
1000,00;
g. sair do programa de cadastro.

42
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

4. Estrutura Recursiva
Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos repetir
um bloco de comandos vrias vezes. Podemos fazer isso utilizando as estruturas de repetio
vistas no Captulo 2. Apesar de as estruturas de repetio serem fundamentais para a construo
de algoritmos, possvel criar algoritmos inteiros sem a utilizao dessas estruturas,
substituindo-as por uma outra chamada estrutura recursiva ou simplesmente recurso.
Uma estrutura recursiva uma tcnica muito poderosa capaz de permitir que um mdulo funo
seja definido por meio dele mesmo. Assim, com um nico mdulo funo definido, podemos
execut-lo vrias vezes, fazendo sua chamada dentro dele mesmo.
Uma estrutura recursiva pode ser manipulada dentro de uma estrutura de deciso (seja ela
simples, composta ou encadeada), dentro de uma estrutura de mltipla escolha, dentro das
estruturas de repetio, bem como dentro dos mdulos.
Para a estrutura recursiva que estudaremos neste captulo veremos quando e como trabalhar com
recurso, bem como sua definio, seu uso, suas regras, construo e chamada de uma
recurso. Alm disso, veremos os dois tipos de recurso: com e sem cauda.

4.1. Definio de Recurso


A estrutura recursiva uma tcnica que consiste em aplicar uma funo como parte da definio
dessa mesma funo. Nesta, a chave do seu funcionamento a existncia de uma condio que
a termine, ou seja, a execuo de uma tarefa no recursiva pela mesma funo.
A estrutura recursiva, ou recurso, uma tcnica de controle de fluxo de algoritmo. Por essa
tcnica, um mdulo funo se chama a si mesmo, direta ou indiretamente. Se um mdulo funo
simplesmente se chamou a si mesmo durante a sua execuo, ento a execuo chamada
chamar a si mesma e assim por diante, sucessivamente e sem fim. Esta situao conhecida
como recurso infinita e similar aos erros em estruturas de repetio, pois uma condio de
controle da estrutura deve ser construda cuidadosamente para garantir que, em algum estgio , a
estrutura seja finalizada. Para evitar recurso infinita, o mdulo funo recursivo precisa ser
construdo de forma a garantir que, em algum estgio , o mdulo funo ser finalizado sem se
chamar a si mesmo.
Vejamos um exemplo simples: a funo fatorial matemtica definida como sendo o produto de
todos os nmeros at 1, incluindo um determinado argumento, ou seja o fatorial de 1 1.
Continuando o mesmo raciocnio, vemos que uma outra forma de apresentar este raciocnio
dizendo que o fatorial de N igual a N vezes o fatorial de (N-1). Ento:
1! = 1
2! = 1 * 2 = 1! * 2 = 2
3! = 1 * 2 * 3 = 2! * 3 = 6
4! = 1 * 2 * 3 * 4 = 3! * 4 = 24
N! = 1 * 2 * 3 * ... * (N-2) * (N-1) * N = (N-1)! * N

43
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Com este novo raciocnio, estamos utilizando o conceito de estrutura recursiva, de acordo com o
qual o fatorial de um nmero obtido pela chamada do fatorial do anterior deste nmero
multiplicado pelo nmero. O fim desta chamada recursiva termina quando o anterior do nmero
for 1, pois o fatorial de 1 1 e no faz chamada recursiva para a mesma funo.

4.2. Uso da Recurso em Pseudocdigo e em Java


Muitos problemas tm a seguinte propriedade: cada exemplo concreto do problema contm um
exemplo concreto menor do mesmo problema. Dizemos que esses problemas tm estrutura
recursiva. Para resolver esse tipo de problema, podemos aplicar o seguinte mtodo:

se o problema pequeno, resolva-o diretamente;


se o problema grande, reduza-o a uma verso menor do mesmo problema, aplique o mtodo
ao problema menor e volte ao problema original.
A aplicao desse mtodo produz um algoritmo recursivo e, para mostrar como isso funciona,
vamos analisar o seguinte problema:
Determinar o valor de um elemento mximo de um vetor v[0 .. n], de n posies.
claro que o problema s faz sentido se o vetor no vazio, ou seja, se n >= 1. Para preparar o
algoritmo recursivo, examine uma tradicional soluo interativa do problema em pseudocdigo:
numrico_inteiro maximo (n numrico_inteiro , v[ ] numrico_inteiro)
incio
j, x numrico_inteiro;
x v[0];
para j de 1 at n-1 passo +1 faa
se (x < v[j])
ento
x v[j];
fimse;
fimpara;
retornar x;
fimmdulo;
A soluo iterativa do problema em Java:
int maximo (int n , int v[ ])
{
int j, x;
x = v[0];
for (j = 1 ; j < n ; j++)
{
44
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

if (x < v[j])
{
x = v[j];
}
}
return x;
}
Eis uma funo recursiva, em pseudocdigo, que resolve o problema:
numrico_inteiro maximo1 (n numrico_inteiro , v[ ] numrico_inteiro)
incio
Declarar
x numrico_inteiro;
se (n = 1)
ento
retornar v[0]; /* problema pequeno */
seno
incio
x maximo1 (n-1, v); /* exemplo concreto menor do problema */
se (x > v[n-1])
ento
retornar x;
seno
retornar v[n-1];
fimse;
fim;
fimse;
fimmdulo;
A soluo recursiva em Java:
int maximo1 (int n , int v[ ])
{
if (n == 1)
{
return v[0]; /* problema pequeno */
}
else
{
int x;

45
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

x = maximo1 (n-1, v); /* exemplo concreto menor do problema */


if (x > v[n-1])
{
return x;
}
else
{
return v[n-1];
}
}
}
Se n igual a 1, ento, v[0] o nico elemento do nosso vetor, portanto v[0] o mximo.
Agora suponha que n vale mais que 1, neste caso, nosso vetor tem duas partes: v[0 .. n-2]
e v[n-1]. Portanto, o valor que procuramos o maior dentre v[n-1] e o mximo de
v[0 .. n-2].
Para verificar se a funo est correta, podemos seguir este roteiro:
1. escreva o que a funo deve fazer;
2. verifique que a funo de fato faz o que deveria, quando n pequeno, ou seja, quando n=1;
3. agora imagine que n grande, ou seja, n >= 1; suponha que a funo faria a coisa certa se,
no lugar de n, tivssemos algo menor que n. Em seguida, verifique que a funo faz o que
dela se espera.
Para que uma funo recursiva seja compreensvel, muito importante que o autor da funo
diga, explicitamente, o que a funo faz. Portanto, deveramos escrever o seguinte comentrio
antes do cdigo:
/* Ao receber v e n >= 1, a funo devolve o valor */
/* de um elemento mximo de v[0 .. n-1].

*/

Outra soluo recursiva em pseudocdigo:


A funo maximo1, discutida acima, "puxa para a esquerda" o fim do vetor, ou seja, troca
v[0..n-1] pelo vetor v[0..n-2]. possvel escrever uma verso que "empurre para a direita"
o incio do vetor?
/* Ao receber v e n >= 1, esta funo devolve o valor */
/* de um elemento mximo do vetor v[0..n-1].

*/

numrico_inteiro maximo2 (n numrico_inteiro , v[ ] numrico_inteiro)


incio
retornar mx (0, n, v);

46
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimmdulo;
/* Recebe v, ini e fim tais que ini < fim. Devolve o */
/* valor de um elemento mximo do vetor v[ini..fim-1]. */
numrico_inteiro mx (ini numrico_inteiro , fim numrico_inteiro, v[ ] numrico_inteiro)
incio
Declarar
x numrico_inteiro;
se (ini = fim-1)
ento
retornar v[ini];
seno
x mx (ini + 1, fim, v);
se (x > v[ini])
ento
retornar x;
seno
retornar v[ini];
fimse;
fimse;
fimmdulo;
Outra verso recursiva em Java:
/* Ao receber v e n >= 1, esta funo devolve o valor */
/* de um elemento mximo do vetor v[0..n-1].

*/

int maximo2 (int n , int v[ ])


{
return mx (0, n, v);
}
/* Recebe v, ini e fim tais que ini < fim. Devolve o */
/* valor de um elemento mximo do vetor v[ini..fim-1]. */
int mx (int ini , int fim , int v[ ])
{
if (ini == fim-1)
{
47
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

return v[ini];
}
else
{
int x;
x = mx (ini + 1, fim, v);
if (x > v[ini])
{
return x;
}
else
{
return v[ini];
}
}
}
Observe que maximo2 apenas uma funo auxiliar, pois a parte principal executada pela
funo recursiva mx. A funo mx resolve um problema mais geral que o original. Isso ocorre
freqentemente na construo de algoritmos recursivos, quando preciso generalizar o problema
para que uma soluo recursiva se torne possvel.

4.3. Regras da Recurso


Temos informalmente trs regras para a recurso:
1. saber quando parar;
2. decidir como fazer a prxima ao;
3. quebrar uma jornada recursiva em um passo mais uma jornada recursiva menor.
A primeira regra avisa que qualquer funo recursiva precisa ser checada se sua jornada chegou
ao fim antes de partir para outra jornada recursiva. Na funo maximo1, o primeiro comando
verifica se o parmetro um vetor com um nico elemento, ento encerra a funo e retorna o
nico contedo desse vetor, que ser o elemento mximo desse vetor.
A segunda regra sugere que quebremos o problema em peas menores que instantaneamente
podem resolver o problema. Na funo maximo1, checamos dois valores, x e v[n-1], retornando,
ento, o maior elemento dentre esses dois.
A terceira regra diz que podemos achar uma maneira para a funo chamar ela mesma
recursivamente em um problema ligeiramente menor, o qual resulta da quebra do problema em
pequenas peas. A funo maximo1 chama ela mesma tendo como parmetro o nmero de
elementos do vetor e o vetor de elementos.

4.4. Construo e Chamada da Recurso


Vamos construir um algoritmo recursivo para o seguinte problema: queremos calcular o fatorial de
um nmero inteiro. Podemos dividir o problema em dois casos especiais:

48
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

se n = 0, ento, o valor de n! 1
caso contrrio, n! = 1 * 2 * 3 * ... * (n-2) * (n-1) = (n-1)! * n
Podemos calcular o valor de n! calculando o valor de (n-1)! E, ento, multiplicando esse valor pelo
valor de n.
Matematicamente, essa definio pode ser escrita da seguinte forma:
fat(n) = 1 se n = 0
fat(n) = n * fat(n-1), caso contrrio.
Observe que a prpria funo fat encarrega-se de se "chamar", ou seja, foi definida em termos
dela mesma.
Pseudocdigo
O algoritmo completo para a resoluo deste problema, em pseudocdigo, o seguinte:
// mdulo funo recursivo
numrico_inteiro fat (n numrico inteiro )
incio
Declarar
f numrico _inteiro;
se (n = 0)
ento
retornar 1; // regra 1
seno
f n * fat(n-1); // regra 2 e 3
retornar f;
fimse;
fim_mdulo;
// mdulo principal
Algoritmo Fatorial
incio
Declarar
f, nro numrico_inteiro;
escrever("Digite um valor cujo fatorial voc deseja saber ");

49
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ler(nro);
se (nro < 0)
ento
escrever ("Valor invlido para clculo de fatorial, o valor precisa ser maior ou igual a
zero");
<sair do programa>;
seno
f fat(nro);
escrever("O fatorial de " , nro , " " , f);
fimse;
fim_algoritmo.
Suponha, por exemplo, que quisssemos saber o fatorial de 3. Primeiro, o algoritmo verifica se o
valor digitado menor que zero. Como no , o algoritmo faz a chamada da funo fat, passando
como parmetro o valor inteiro 3. (chamada 1)
Dentro da funo fat, o algoritmo verifica se o valor passado como parmetro igual a 0. Como
no , o algoritmo retorna o valor do clculo da multiplicao de 3 pela chamada da funo fat,
passando como parmetro o valor inteiro 2. (chamada 2)
Dentro da funo fat, o algoritmo verifica se o valor passado como parmetro igual a 0. Como
no , o algoritmo retorna o valor do clculo da multiplicao de 2 pela chamada da funo fat,
passando como parmetro o valor inteiro 1. (chamada 3)
Dentro da funo fat, o algoritmo verifica se o valor passado como parmetro igual a 0. Como
no , o algoritmo retorna o valor do clculo da multiplicao de 1 pela chamada da funo fat,
passando com parmetro o valor inteiro 0. (chamada 4)
Dentro da funo fat, o algoritmo verifica se o valor passado como parmetro igual a 0. Como
, o algoritmo retorna o valor 1 para a chamada 4.
A chamada 4 recebe o retorno da funo fat, multiplica esse valor por 1 e retorna o clculo da
mltiplicao, ou seja, 1, para a chamada 3.
A chamada 3 recebe o retorno da funo fat, multiplica esse valor por 2 e retorna o clculo da
multiplicao, ou seja, 2, para a chamada 2.
A chamada 2 recebe o retorno da funo fat, multiplica esse valor por 3 e retorna o clculo da
multiplicao, ou seja, 6, para a chamada 1.
A chamada 1 recebe o retorno da funo fat e atribui esse valor para a varivel f.
O algoritmo, ento, envia a seguinte mensagem para o usurio:
O fatorial de 3 6
Java
O algoritmo completo para a resoluo deste problema, em Java, o seguinte:

50
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

class Fatorial
{
// mdulo funo recursivo
static int fat (int n)
{
int f;
if (n == 0)
{
return 1; // regra 1
}
else
{
// chamada da funo recursiva
f = n * fat(n-1); // regra 2 e 3
return f;
}
}
// mdulo principal
public static void main (String arg [ ])
{
int f, nro;
nro = Integer.parseInt(JOptionPane.showInputDialog(
"Digite um valor cujo fatorial
voc deseja saber "));
if (nro < 0)
{
System.out.println ("Valor invlido para clculo de
fatorial, o valor precisa ser
maior ou igual a zero");
System.exit(0);
}
else
{
f = fat(nro); // chamada da funo recursiva
System.out.println("O fatorial de " + nro +
" " + f);
}
System.exit(0);
} // fim do void main
} // fim da classe
A explicao da execuo deste programa em Java o mesmo que do algoritmo em
pseudocdigo.

51
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

4.5. Exemplos de Recurso em Pseudocdigo


1. Desenvolva um algoritmo que receba do usurio dois nmeros inteiros e no negativos e que
calcule a potncia de um nmero pelo outro. O algoritmo deve utilizar recurso e
modularizao.
numrico_inteiro pot(base numrico_inteiro , exp numrico_inteiro )
incio
se (base = 0)
ento
retornar 0;
seno
se (exp = 0)
ento
retornar 1;
seno
retornar pot(base , exp-1) * base;
fimse;
fimse;
fim_mdulo;
Algoritmo Potencia
incio
Declarar
b, e, p numrico_inteiro;
escrever("Digite a base e o expoente para clculo da potncia");
ler (b,e);
se ( b < 0 ou e < 0)
ento
escrever("valor digitado incorretamente, valores devem ser maiores ou iguais a zero");
seno
p pot(b,e);
escrever(b , " elevado a " , e , " igual a " , p);
fimse;
fim_algoritmo.

52
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

2. Desenvolva um algoritmo que calcule a multiplicao de dois nmeros inteiros positivos sem o
uso do operador de multiplicao. O algoritmo deve utilizar recurso e modularizao.
numrico_inteiro mult(a numrico_inteiro , b numrico_inteiro )
incio
se (b = 1)
ento
retornar a;
seno
retornar (a + mult (a,b-1));
fimse;
fim_mdulo;
Algoritmo Multiplicacao
incio
Declarar
x, y, m numrico_inteiro;
escrever("Digite dois nmeros para clculo da multiplicacao");
ler (x,y);
se ( x <= 0 ou y <= 0)
ento
escrever("valor digitado incorretamente, valores devem ser positivos");
seno
m mult(x,y);
escrever(x , " multiplicado com " , y , " igual a " , m);
fimse;
fim_algoritmo.
3. Desenvolva um algoritmo que calcule a soma dos nmeros inteiros compreendidos entre 1 e
100. O algoritmo deve utilizar recurso e modularizao.
numrico_inteiro soma1(nro numrico_inteiro ,soma numrico_inteiro )
incio
Declarar
s numrico_inteiro;

53
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

se (nro = 100)
ento
s nro + soma;
seno
s soma1(nro+1,nro+soma);
fimse;
retornar s;
fim_mdulo;
Algoritmo Soma100
incio
Declarar
soma numrico_inteiro;
soma soma1(1,0);
escrever("a soma dos cem primeiros nmeros " , soma);
fim_algoritmo.

4.6. Exemplos de Recurso em Java


1. Desenvolva um algoritmo que receba do usurio dois nmeros inteiros e no negativos e que
calcule a potncia de um nmero pelo outro. O algoritmo deve utilizar recurso e
modularizao.
class Potencia
{
static int pot(int base , int exp)
{
if (base == 0)
{
return 0;
}
else
{
if (exp == 0)
{
return 1;
}
else
{
return pot(base , exp-1) * base;
}
}
54
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

} // fim da funo pot


public static void main(String args [ ])
{
int b, e, p;
b = Integer.parseInt(JOptionPane.showInputDialog("Digite a
base para clculo da potncia"));
e = Integer.parseInt(JOptionPane.showInputDialog("Digite o
expoente para clculo da potncia"));
if ( b < 0 || e < 0)
{
System.out.println("valor digitado incorretamente,
valores devem ser maiores ou iguais a
zero");
}
else
{
p = pot(b,e);
System.out.println(b + " elevado a " + e + "
igual a " + p);
}
System.exit(0);
} // fim do void main
} // fim da classe
2. Desenvolva um algoritmo que calcule a multiplicao de dois nmeros inteiros positivos sem o
uso do operador de multiplicao. O algoritmo deve utilizar recurso e modularizao.
class Multiplicacao
{
static int mult(int a , int b)
{
if (b == 1)
{
return a;
}
else
{
return (a + mult (a,b-1));
}
} // fim da funo mult
public static void main (String argh [ ])
{
int x, y, m;
x = Integer.parseInt(JOptionPane.showInputDialog("Digite um
nmero para clculo da multiplicacao"));

55
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

y = Integer.parseInt(JOptionPane.showInputDialog("Digite
outro nmero para clculo damultiplicacao"));
if ( x <= 0 || y <= 0)
{
System.out.println("valor digitado incorretamente,
valores devem ser positivos");
}
else
{
m = mult(x,y);
System.out.println(x + " multiplicado com " + y + "
igual a " + m);
}
System.exit(0);
} // fim do void main
} // fim da classe
3. Desenvolva um algoritmo que calcule a soma dos nmeros inteiros compreendidos entre 1 e
100. O algoritmo deve utilizar recurso e modularizao.
class Soma100
{
static int soma1(int nro , int soma)
{
int s;
if (nro == 100)
{
s = nro + soma;
}
else
{
s = soma1(nro+1,nro+soma);
}
return s;
} // fim da funo soma1
public static void main ( String args [ ])
{
int soma;
soma = soma1(1,0);
System.out.println("a soma dos cem primeiros nmeros "
+ soma);
System.exit(0);
} // fim do void main
} // fim da classe

56
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

4.7. Exerccios de Recurso


01. Desenvolva um algoritmo que some todos elementos de uma matriz quadrada 20 x 20 de inteiros.
O algoritmo deve usar recurso e modularizao.

02. Desenvolva um algoritmo que inverta os elementos de um vetor de inteiros com 10 posies. O
algoritmo deve usar recurso e modularizao.
Ex: vetor original: 10 12 4 68 39 11 20 9 40 33
resultado: 33 40 9 20 11 39 68 4 12 10

03. Desenvolva um algoritmo que receba um valor inteiro como parmetro e que informe quantas
ocorrncias deste valor existem em uma matriz 10 x 10 de inteiros. O algoritmo deve usar
recurso e modularizao.

04. Desenvolva um algoritmo que calcule e que mostre o quadrado dos nmeros inteiros
compreendidos entre 10 e 150. O algoritmo deve usar recurso e modularizao.

05. Desenvolva um algoritmo que receba um nmero N, calcule e mostre o valor da seguinte srie:
Srie = 1 + 1/2 + 1/3 + ... + 1/N. Usar recurso e modularizao.

06. Desenvolva um algoritmo que receba um nmero, calcule e mostre os resultados da tabuada
desse nmero. O algoritmo deve usar recurso e modularizao.

07. Desenvolva um algoritmo que receba um nmero N, calcule e mostre o valor da seguinte srie:
Srie = 1 + 1/1! + 1/2! + 1/3! + ... + 1/N!.
O algoritmo deve usar recurso e modularizao.

08. Desenvolva um algoritmo que receba um nmero inteiro N, calcule e mostre a srie de Fibonacci
at o seu N-simo termo. A srie de Fibonacci dada pela seguinte seqncia: 1, 1, 2, 3, 5, 8, 13,
21, 34, 55 ... etc. O algoritmo deve usar recurso e modularizao.

09. Desenvolva um algoritmo que receba 100 nmeros reais, verifique e mostre o maior e o menor
nmero recebido. O algoritmo deve usar recurso e modularizao.

10. Desenvolva um algoritmo que calcule o nmero de gros de trigo dispostos num tabuleiro de
xadrez e que siga a seguinte regra: no primeiro quadro, colocar um gro de trigo; no segundo
quadro, colocar o dobro de gros de trigo do primeiro quadro; e, para todos os quadros
subseqentes, colocar o dobro de gros de trigo do quadro anterior. Um tabuleiro de xadrez tem
64 quadros. O algoritmo deve usar recurso e modularizao.

57
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

11. Desenvolva um algoritmo que receba um nmero inteiro, verifique e mostre se esse nmero
primo ou no. O algoritmo deve usar recurso e modularizao.

12. Desenvolva um algoritmo que calcule e mostre o valor da seguinte srie:


Srie = 1 + 2/3 + 3/5 + 4/7 + ... + 50/99.
O algoritmo deve usar recurso e modularizao.

13. Desenvolva um algoritmo que receba 30 nmeros reais, calcule e mostre a somatria e a mdia
dos nmeros recebidos. O algoritmo deve usar recurso e modularizao.

14. Desenvolva um algoritmo que receba dois nmeros inteiros, verifique qual o maior entre eles,
calcule e mostre o quociente e o resto da diviso do maior nmero pelo menor. Em hiptese
nenhuma utilizar os operadores div e mod. O algoritmo deve usar recurso e modularizao.

15. Desenvolva um algoritmo que receba o nome e a idade de 50 pessoas, verifique e mostre o nome
e a idade da pessoa mais velha e da pessoa mais nova. O algoritmo deve usar recurso e
modularizao.

16. Desenvolva um algoritmo que calcule e mostre o valor da somatria dos trinta primeiros termos da
seguinte srie:
Srie = 5/1000 - 10/980 + 5/960 - 10/940 + ...
O algoritmo deve usar recurso e modularizao.

17. Desenvolva um algoritmo que calcule e mostre o valor da seguinte srie:


Srie = 1/1 - 2/4 + 3/6 - 4/8 + 5/10 - 6/12 + ... - 50/100.
O algoritmo deve usar recurso e modularizao.

18. Desenvolva um algoritmo que receba um nmero inteiro N, mostre um menu de opes: calcular e
mostrar a soma do fatorial dos nmeros entre 1 e N; calcular e mostrar a srie de Fibonacci at o
seu N-simo termo; calcular e mostrar o produto dos nmeros entre 1 e N; e calcular e mostrar a
soma dos nmeros pares entre 1 e N. O algoritmo deve usar recurso e modularizao.

19. Desenvolva um algoritmo que calcule e mostre o valor da seguinte srie:


Srie = 1/1 - 2/4 + 3/9 - 4/16 + 5/25 - ... + 15/225. O algoritmo deve usar recurso e
modularizao.

20. Desenvolva um algoritmo que receba dois valores inteiros, a e b, a > b, mostre um menu de
opes que: calcule e mostre a potncia ab, sem utilizar o operador pot; calcule e mostre o
quociente e o resto da diviso de a por b, sem usar os operadores div e mod; e calcule e mostre
se os valores a e b so primos ou no.

58
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

5. Estrutura de Ordenao
Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos ordenar
as informaes de diferentes tipos de dados que podemos utilizar no programa. Para isso,
podemos utilizar a estrutura de dados chamada Ordenao para, assim, ordenar essas
informaes no programa.
A estrutura de dados de ordenao bastante utilizada quando se tem como prioridade realizar
comparaes sucessivas e trocar os elementos de posio. s vezes, por exemplo, precisamos
de que as informaes estejam em determinada ordem para que possamos realizar aes, como
verificar se determinado CPF est na lista dos nomes das pessoas que apresentaram cheque
sem fundo ou se determinada pessoa est numa lista de convidados de uma festa de casamento.
H diferentes estruturas de ordenao utilizados na computao, como, por exemplo: ordenao
por insero, ordenao por seleo, ordenao por bolhas, ordenao de shell, ordenao de
heap, ordenao rpida - quicksort, ordenao por fuso - mergesort, ordenao de raiz, etc.
A ordenao uma estrutura de dados muito utilizada na cincia da computao para a
programao. Neste captulo, veremos como e quando trabalhar com ordenao, bem como,
inserir, remover, consultar e manipular dados na ordenao.

5.1. Definio de Ordenao


Em diversas aplicaes, os elementos precisam ser armazenados em determinada ordem.
Ordenar significa rearranjar um conjunto de elementos numa disposio crescente ou decrescente
e o principal objetivo da ordenao o de facilitar a busca de determinado elemento do conjunto
ordenado.
Para exemplificar a importncia da ordenao, podemos pensar em como seria difcil consultar
uma lista telefnica de uma cidade, caso as informaes contidas nesta lista no estivessem em
ordem alfabtica pelo sobrenome das pessoas. Outro exemplo seria a de procurar uma palavra
num dicionrio de idiomas, na eventualidade de que as palavras nesse dicionrio no estivessem
ordenadas.
Alguns algoritmos podem desenvolver a ordenao dos seus elementos para garantir um melhor
desempenho computacional e isso pode ser feito de duas formas: ordenar os elementos na
estrutura de dados no momento em que os elementos so inseridos, ou, ainda, ordenar os
elementos, a partir de um algoritmo, numa estrutura de dados com elementos j inseridos.
Pensando na segunda forma, desenvolveremos, neste captulo, algoritmos que ordenam
elementos j inseridos numa estrutura de dados, mas que garantam a eficincia da ordenao em
tempo reduzido.

5.2. Algoritmos de Ordenao


Nesta seo, estudaremos alguns algoritmos de ordenao conhecidos e qual a idia ou tcnica
utilizada para realizar a ordenao.

59
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

5.2.1. Ordenao bolha ou bubble sort


O algoritmo ordenao bolha, ou bubble sort, assim conhecido pois utiliza a idia de que os
elementos maiores so mais leves e sobem como bolhas at suas posies corretas. Ele um
dos algoritmos mais conhecidos na computao, pois fcil de ser entendido e utilizado. No
entanto, pode ser considerado um dos algoritmos menos eficientes para ordenao.
A tcnica consiste em realizar comparaes entre os elementos dois-a-dois e, quando um
elemento fora de ordem detectado, ocorre a troca desses elementos. Assim, o primeiro
elemento comparado com o segundo. Caso os elementos estejam fora de ordem, a troca
desses elementos realizada. Em seguida, o segundo elemento comparado com o terceiro
elemento. Novamente aqui, se os elementos estiverem fora de ordem, a troca realizada e assim
o processo continua at que todos os elementos tenham sido comparados. Esse processo
garante que o ltimo elemento seja o maior dentre todos os elementos.
O processo continua, considerando agora todos os elementos menos o ltimo, que j est em sua
posio correta. Depois que o penltimo elemento j est na posio correta, o algoritmo continua
at que o primeiro elemento esteja na posio correta, o que significa dizer que esse primeiro
elemento ser o menor dentre todos os elementos.
Para exemplificar, vamos considerar os valores inteiros relacionados a seguir:
26

47

38

11

95

Seguindo o algoritmo explicado acima, a troca dos elementos segue as iteraes seguintes:
26

47

38

11

95

compara 26 e 47 - no efetua a troca

26

47

38

11

95

compara 47 e 38 - realiza a troca

26

38

47

11

95

compara 47 e 11 - realiza a troca

26

38

11

47

95

compara 47 e 95 - no realiza a troca

26

38

11

47

95

final do primeiro processo

Ao final dessa primeira etapa, o maior elemento, 95, j est em sua posio correta. Vamos
continuar o processo:
26

38

11

47

95

compara 26 e 38 - no efetua a troca

26

38

11

47

95

compara 38 e 11 - efetua a troca

26

11

38

47

95

compara 38 e 47 - no efetua a troca

26

11

38

47

95

final do segundo processo

Ao final dessa segunda etapa, o segundo maior elemento, 47, j est em sua posio correta.
Vamos continuar o processo:
26

11

38

47

95

compara 26 e 11 - efetua a troca

11

26

38

47

95

compara 26 e 38 - no efetua a troca

11

26

38

47

95

final do terceiro processo

60
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Ao final dessa terceira etapa, o terceiro maior elemento, 38, j est em sua posio correta.
Vamos continuar o processo:
11

26

38

47

95

compara 11 e 26 - no efetua a troca

11

26

38

47

95

final do ltimo processo

Ao final dessa ltima etapa, o primeiro e o segundo elementos, 11 e 26, respectivamente, j esto
em suas posies corretas. Assim, ao final do processo inteiro, os nmeros inteiros esto todos
ordenados.

5.2.2. Ordenao por Troca de Partio ou Quicksort


O algoritmo ordenao por troca de partio ou quicksort assim conhecido pois utiliza a idia de
ordenar os elementos por parties.
A tcnica consiste em dividir uma lista de elementos em sublistas, que so conhecidas como
parties. Essas parties so novamente subdivididas em outras parties at que a subdiviso
no seja mais necessria, ou seja, quando a partio tem somente um elemento. Assim, a
inteno dividir o problema em subproblemas que possam ser resolvidos com mais facilidade e
rapidamente.
Para determinar as parties, um elemento chamado piv escolhido dentro da lista, de forma
que, os elementos da primeira partio sejam menores ou iguais ao elemento piv e todos os
elementos da segunda partio sejam maiores ou iguais ao elemento piv.
Para exemplificar, vamos considerar os valores inteiros relacionados a seguir:
25

57

48

37

12

92

86

33

Agora, vamos colocar o nmero 25 em sua posio correta. Assim, teremos o seguinte resultado:
12

(25)

57

48

37

92

86

33

piv 25

Isso significa que todos os elementos antes do piv 25 so menores ou iguais a 25, sendo que no
nosso exemplo, temos a lista (12). Da mesma forma, todos os elementos depois do piv 25 so
maiores ou iguais a 25, sendo que no nosso exemplo, temos a lista (57 48 37 92 86 33). Como o
piv 25 est em sua posio correta, agora temos a nossa lista dividida em duas sublistas.
Como a primeira sublista tem um nico elemento, o 12, ela j est ordenada, ou seja, j est em
sua posio correta, assim, no h nada para fazer com ela. Desta forma, devemos ordenar
somente a segunda sublista e, para isso, seguiremos o mesmo processo. Vejamos como est a
lista:
12

25

(57

48

37

92

86

33)

61
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Agora, vamos colocar o nmero 57 em sua posio correta. Assim, teremos o seguinte resultado:
12

25

(48

37

33)

57

(92

86)

piv 57

Seguindo, passo a passo, o mesmo processo, temos as seguintes seqncias:


12

25

(37

33)

48

57

(92

86)

piv 48

12

25

(33)

37

48

57

(92

86)

piv 37

12

25

33

37

48

57

(92

86)

piv 33

12

25

33

37

48

57

(86)

92

piv 92

12

25

33

37

48

57

86

92

piv 86

Depois que o processo do quicksort foi aplicado em todas as sublistas, temos ento a lista
ordenada.

5.2.3. Ordenao por Intercalao ou Mergesort


O algoritmo ordenao por intercalao ou mergesort assim conhecido pois utiliza a idia de
ordenar os elementos a partir da unio de elementos j ordenados.
A tcnica consiste em unir metades ordenadas de duas sublistas de elementos para gerar a lista
ordenada dos elementos. No entanto, primeiro essas sublistas de elementos precisam ser
ordenadas, ou seja, elas sero geradas de sublistas de elementos ordenados dessas sublistas.
Essa tcnica de dividir listas em duas sublistas pra quando a sublista tem menos de dois
elementos.
Em uma lista de elementos, a primeira sublista tem a primeira metade da lista de elementos e a
segunda sublista tem a segunda metade da lista de elementos.
Para exemplificar, vamos considerar os valores inteiros relacionados a seguir:
25

57

48

37

12

92

86

33

Agora vamos dividir a lista de elementos, na metade, em duas sublistas:


(25

57

48

37)

(12

92

86

33)

Vamos repetir a diviso das sublistas, de forma que cada sublista seja dividida na metade em
outras duas sublistas, assim, teremos:
(25

57)

(48

37)

(12

92)

(86

33)

(12)

(92)

(86)

(33)

Repetindo o processo, teremos:


(25)

(57)

(48)

(37)

62
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Agora, vamos intercalar as listas duas a duas, ordenando os elementos parciais das sublistas,
resultando nas seguintes sublistas:
(25

57)

(37

48)

(12

92)

(33

86)

Vamos repetir o processo de intercalar as listas duas a duas, ordenando os elementos parciais
das sublistas, resultando nas seguintes sublistas:
(25

37

48

57)

(12

33

86

92)

E, intercalando as duas ltimas sublistas, teremos;


(12

25

33

37

48

57

86

92)

Depois de intercalas as ltimas duas sublistas, temos a lista com os elementos ordenados.

5.3. Ordenao em Pseudocdigo


5.3.1. Ordenao bolha ou bubble sort
Bolha (numeros [ ] numrico_inteiro)
incio_mdulo
Declarar
constante n numeros.tamanho numrico_inteiro;
aux, i, j numrico_inteiro;
para i de 0 at n-2 passo +1 faa
para j de 0 at n-2-i passo +1 faa
se (numeros[j] > numeros[j+1])
ento
aux numeros[j];
numeros[j] numeros[j+1];
numeros[j+1] aux;
fimse;
fimpara;
fimpara;
fim_mdulo;

63
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

5.3.2. Ordenao por Troca de Partio ou Quicksort


quicksort(p numrico_inteiro, q numrico_inteiro, vetor[ ] numrico_inteiro)
incio_mdulo
Declarar
x numrico_inteiro;
se (p < q)
ento
x particao(p, q, vetor);
quicksort(p, x - 1, vetor);
quicksort(x + 1, q, vetor);
fimse;
fimMdulo;
numrico_inteiro particao(p numrico_inteiro, q numrico_inteiro, vetor[ ] numrico_inteiro)
incio_mdulo
Declarar
j p - 1 numrico_inteiro;
temp, i, aux vetor[q] numrico_inteiro;
para i de p at q passo +1 faa
se (vetor[i] <= aux)
ento
j j +1;
temp vetor[i];
vetor[i] vetor[j];
vetor[j] temp;
fimse;
fimpara;
retornar j;
fimmdulo;

64
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

5.3.3. Ordenao por Intercalao ou Mergesort


merge(a[ ] numrico_inteiro, inicio numrico_inteiro,
meio numrico_inteiro, int numrico_inteiro)
incio_mdulo
Declarar
n, b[n], i1, i2, j 0 nmerico_inteiro;
n fim - inicio + 1;
i1 inicio;
i2 meio + 1;
enquanto (i1 <= meio e i2 <= fim) faa
se (a[i1] < a[i2])
ento
b[j] a[i1];
i1 i1 + 1;
seno
b[j] a[i2];
i2 i2 + 1;
fimse;
j j + 1;
fimenquanto;
enquanto (i1 <= meio) faa
b[j] a[i1];
i1 i1 + 1;
j j + 1;
fimenquanto;
enquanto (i2 <= fim) faa
b[j] a[i2];
i2 i2 + 1;
j j + 1;
fimenquanto;

65
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

para j de 0 at n-1 passo +1 faa


a[inicio + j] b[j];
fimpara;
fimmdulo;
mergeSort(a[ ] numrico_inteiro, inicio numrico_inteiro, fim numrico_inteiro)
incio_mdulo
Declarar
meio numrico_inteiro;
se (inicio = fim)
ento
retornar;
fimse;
meio (inicio + fim) / 2;
mergeSort(a, inicio, meio);
mergeSort(a, meio + 1, fim);
merge(a, inicio, meio, fim);
fimmdulo;

5.4. Ordenao em Java


5.4.1. Ordenao bolha ou bubble sort
public static void Bolha (int numeros [])
{
final int n = numeros.length;
int aux;
for (int i = 0 ; i < n-1 ; i++)
{
for (int j = 0 ; j < n-1-i ; j++)
{
if (numeros[j] > numeros[j+1])
{
aux = numeros[j];
numeros[j] = numeros[j+1];
numeros[j+1] = aux;
}
}
}
}
66
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

5.4.2. Ordenao por Troca de Partio ou Quicksort


public static void quicksort(int p, int q, int vetor[])
{
int x;
if (p < q)
{
x = particao(p, q, vetor);
quicksort(p, x - 1, vetor);
quicksort(x + 1, q, vetor);
}
}
public static int particao(int p, int q, int vetor[])
{
int j = p - 1;
int temp, aux = vetor[q];
for (int i = p; i <= q; i++)
{
if (vetor[i] <= aux)
{
j++;
temp = vetor[i];
vetor[i] = vetor[j];
vetor[j] = temp;
}
}
return j;
}
5.4.3. Ordenao por Intercalao ou Mergesort
public static void merge(int[] a, int inicio, int meio, int fim)
{
int n = fim - inicio + 1;
int[] b = new int[n];
int i1 = inicio;
int i2 = meio + 1;
int j = 0;
while (i1 <= meio && i2 <= fim)
{
if (a[i1] < a[i2])
{
b[j] = a[i1];
i1++;
}
67
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

else
{
b[j] = a[i2];
i2++;
}
j = j + 1;
}
while (i1 <= meio)
{
b[j] = a[i1];
i1 = i1 + 1;
j = j + 1;
}
while (i2 <= fim)
{
b[j] = a[i2];
i2 = i2 + 1;
j = j + 1;
}
for (j = 0; j < n; j++)
{
a[inicio + j] = b[j];
}
}
public static void mergeSort(int[] a, int inicio, int fim)
{
if (inicio == fim)
{
return;
}
int meio = (inicio + fim) / 2;
mergeSort(a, inicio, meio);
mergeSort(a, meio + 1, fim);
merge(a, inicio, meio, fim);
}

5.5. Exemplo de Ordenao em Pseudocdigo


5.5.1. Ordenao bolha ou bubble sort
Desenvolva um algoritmo que ordena 10 nmeros inteiros, utilizando a tcnica do bubblesort.

68
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Algoritmo OrdenacaoBolha
incio_algoritmo
Declarar
i, num [10] numrico_inteiro;
s "" alfanumrico;
para i de 0 at 9 passo +1 faa
escrever("Digite nmero inteiro");
ler(num[i]);
fimpara;
Bolha(num);
para i de 0 at num.length - 1 passo +1 faa
s s + num[i] + " ";
fimpara;
escrever(s);
fimalgoritmo.

5.5.2. Ordenao por Troca de Partio ou Quicksort


Desenvolva um algoritmo que ordena 10 nmeros inteiros, utilizando a tcnica do quicksort.
Algoritmo OrdenacaoBolha
incio_algoritmo
Declarar
i, num [10] numrico_inteiro;
s "" alfanumrico;
para i de 0 at 9 passo +1 faa
escrever("Digite nmero inteiro");
ler(num[i]);
fimpara;
quicksort(0,num.length-1,num);
para i de 0 at num.length - 1 passo +1 faa
s s + num[i] + " ";
69
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimpara;
escrever(s);
fimalgoritmo.

5.5.3. Ordenao por Intercalao ou Mergesort


Desenvolva um algoritmo que ordena 10 nmeros inteiros, utilizando a tcnica do mergesort.
Algoritmo MergeSort
incio_algoritmo
i numrico_inteiro;
msg "" alfanumrico;
vefimr[10] numrico_inteiro;
para i de 0 at vefimr.tamanho -1 passo +1 faa
escrever("Digite um inteiro");
ler(vefimr[i]);
fimpara;
mergeSort(vefimr, 0, vefimr.tamanho-1);
para i de 0 at vefimr.tamanho-1 passo +1 faa
msg msg + vefimr[i] + " ";
fimpara;
escrever(msg);
fimalgoritmo.

5.6. Exemplo de ordenao em java


5.6.1. Ordenao bolha ou bubble sort
Desenvolva um algoritmo que ordena 10 nmeros inteiros, utilizando a tcnica do bubblesort.
import javax.swing.*;
class OrdenacaoBolha
{
public static void Bolha (int numeros [])
{
final int n = numeros.length;
70
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

int aux;
for (int i = 0 ; i < n-1 ; i++)
{
for (int j = 0 ; j < n-1-i ; j++)
{
if (numeros[j] > numeros[j+1])
{
aux = numeros[j];
numeros[j] = numeros[j+1];
numeros[j+1] = aux;
}
}
}
}
public static void main (String arg [])
{
int num [] = new int [10];
for (int i = 0 ; i < 10 ; i++)
{
String s;
s = JOptionPane.showInputDialog("Digite nmero inteiro");
num[i] = Integer.parseInt(s);
}
Bolha(num);
String s = "";
for (int i = 0 ; i < num.length ; i++)
{
s = s + num[i] + " ";
}
JOptionPane.showMessageDialog(null,s);
System.exit(0);
}
}

5.6.2. Ordenao por Troca de Partio ou Quicksort


Desenvolva um algoritmo que ordena 10 nmeros inteiros, utilizando a tcnica do quicksort.
class OrdenacaoQuicksort
{
public static void quicksort(int p, int q, int vetor[])
{
71
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

int x;
if (p < q)
{
x = particao(p, q, vetor);
quicksort(p, x - 1, vetor);
quicksort(x + 1, q, vetor);
}
}
public static int particao(int p, int q, int vetor[])
{
int j = p - 1;
int temp, aux = vetor[q];
for (int i = p; i <= q; i++)
{
if (vetor[i] <= aux)
{
j++;
temp = vetor[i];
vetor[i] = vetor[j];
vetor[j] = temp;
}
}
return j;
}
public static void main (String arg [])
{
int num [] = new int [10];
for (int i = 0 ; i < 10 ; i++)
{
String s;
s = JOptionPane.showInputDialog("Digite nmero inteiro");
num[i] = Integer.parseInt(s);
}
quicksort(0,num.length-1,num);
String s = "";
for (int i = 0 ; i < num.length ; i++)
{
s = s + num[i] + " ";
}
JOptionPane.showMessageDialog(null,s);
System.exit(0);
}
}
72
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

5.6.3. Ordenao por Intercalao ou Mergesort


Desenvolva um algoritmo que ordena 10 nmeros inteiros, utilizando a tcnica do mergesort.
import javax.swing.*;
class MergeSort
{
public static void merge(int[] a, int inicio, int meio, int fim)
{
int n = fim - inicio + 1;
int[] b = new int[n];
int i1 = inicio;
int i2 = meio + 1;
int j = 0;
while (i1 <= meio && i2 <= fim)
{
if (a[i1] < a[i2])
{
b[j] = a[i1];
i1++;
}
else
{
b[j] = a[i2];
i2++;
}
j = j + 1;
}
while (i1 <= meio)
{
b[j] = a[i1];
i1 = i1 + 1;
j = j + 1;
}
while (i2 <= fim)
{
b[j] = a[i2];
i2 = i2 + 1;
j = j + 1;
}
for (j = 0; j < n; j++)
{
a[inicio + j] = b[j];
}
}
73
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public static void mergeSort(int[] a, int inicio, int fim)


{
if (inicio == fim)
{
return;
}
int meio = (inicio + fim) / 2;
mergeSort(a, inicio, meio);
mergeSort(a, meio + 1, fim);
merge(a, inicio, meio, fim);
}
public static void main(String[ ] args)
{
int i;
String msg = "";
int vefimr[ ] = new int [10] ;
for (i = 0; i < vefimr.length; i++)
{
vefimr[i] = Integer.parseInt(JOptionPane.showInputDialog(
"Digite um inteiro"));
}
mergeSort(vefimr, 0, vefimr.length-1);
for (i = 0; i < vefimr.length; i++)
{
msg = msg + vefimr[i] + " ";
}
JOptionPane.showMessageDialog(null, msg);
System.exit(0);
}
}

5.7. Exerccios de Ordenao


Os algoritmos abaixo devem ser desenvolvidos em pseudocdigo e com a utilizao da estrutura
de dados de ordenao.

01. Escreva um vetor de entrada para demonstrar que a ordenao por seleo um mtodo instvel.
Mostre passo a passo a execuo do algoritmo at que a estabilidade seja violada. Perceba que
quanto menor for o vetor escrito, mais rpida ser a resoluo da questo.

02. Desenvolva um algoritmo que receba nmeros inteiros numa matriz quadrada no primeiro
momento. Num segundo momento, o algoritmo deve ordenar em ordem crescente os elementos
de cada linha. Num terceiro momento, o algoritmo deve ordenar em ordem crescente os
74
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

elementos de cada coluna. Mostre os elementos da matriz e diga o porqu de os elementos de


cada linha continuarem em ordem.

03. Desenvolva um algoritmo que receba do usurio 20 nmeros inteiros num vetor e que coloque os
elemento do vetor em ordem crescente. No utilizar bubblesort, nem quicksort, nem mergesort.

04. Desenvolva um algoritmo que receba do usurio 20 nmeros inteiros num vetor e que coloque os
elemento do vetor em ordem crescente. Utilizar bubblesort e mostrar passo a passo a execuo
do algoritmo.

05. Desenvolva um algoritmo que receba do usurio 20 nmeros inteiros num vetor e que coloque os
elemento do vetor em ordem crescente. Utilizar quicksort e mostrar passo a passo a execuo do
algoritmo.

06. Desenvolva um algoritmo que receba do usurio 20 nmeros inteiros num vetor e que coloque os
elemento do vetor em ordem crescente. Utilizar mergesort e mostrar passo a passo a execuo
do algoritmo.

07. Desenvolva um algoritmo que receba do usurio 40 nmeros reais num vetor e que coloque os
elementos do vetor em ordem decrescente. No utilizar bubblesort, nem quicksort, nem
mergesort.

08. Desenvolva um algoritmo que receba do usurio 40 nmeros reais num vetor e que coloque os
elementos do vetor em ordem decrescente. Utilizar bubblesort e mostrar passo a passo a
execuo do algoritmo.

09. Desenvolva um algoritmo que receba do usurio 40 nmeros reais num vetor e que coloque os
elementos do vetor em ordem decrescente. Utilizar quicksort e mostrar passo a passo a execuo
do algoritmo.

10. Desenvolva um algoritmo que receba do usurio 40 nmeros reais num vetor e que coloque os
elementos do vetor em ordem decrescente. Utilizar mergesort e mostrar passo a passo a
execuo do algoritmo.

11. Desenvolva um algoritmo que receba do usurio 15 nmeros inteiros numa matriz de dimenses
3 x 5 e coloque os elementos da matriz em ordem crescente. No utilizar bubblesort, nem
quicksort, nem mergesort.

12. Desenvolva um algoritmo que receba do usurio 15 nmeros inteiros numa matriz de dimenses
3 x 5 e que coloque os elementos da matriz em ordem crescente. Utilizar bubblesort e mostrar
passo a passo a execuo do algoritmo.

75
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

13. Desenvolva um algoritmo que receba do usurio 15 nmeros inteiros numa matriz de dimenses
3 x 5 e que coloque os elementos da matriz em ordem crescente. Utilizar quicksort e mostrar
passo a passo a execuo do algoritmo.

14. Desenvolva um algoritmo que receba do usurio 15 nmeros inteiros numa matriz de dimenses
3 x 5 e que coloque os elementos da matriz em ordem crescente. Utilizar mergesort e mostrar
passo a passo a execuo do algoritmo.

15. Desenvolva um algoritmo que receba do usurio 25 nomes num vetor e que coloque esses nomes
no vetor em ordem alfabtica. No utilizar bubblesort, nem quicksort, nem mergesort.

16. Desenvolva um algoritmo que receba do usurio 25 nomes num vetor e que coloque esses nomes
no vetor em ordem alfabtica. Utilizar bubblesort e mostrar passo a passo a execuo do
algoritmo.

17. Desenvolva um algoritmo que receba do usurio 25 nomes num vetor e que coloque esses nomes
no vetor em ordem alfabtica. Utilizar quicksort e mostrar passo a passo a execuo do algoritmo.

18. Desenvolva um algoritmo que receba do usurio 25 nomes num vetor e que coloque esses nomes
no vetor em ordem alfabtica. Utilizar mergesort e mostrar passo a passo a execuo do
algoritmo.

19. Desenvolva um algoritmo que receba do usurio 30 registros com os campos nome, sexo e
telefone. O algoritmo deve ordenar os elementos no vetor e retornar a busca por um nome
fornecido pelo usurio. No utilizar bubblesort, nem quicksort, nem mergesort.

20. Desenvolva um algoritmo que receba do usurio 30 registros com os campos nome, sexo e
telefone. O algoritmo deve ordenar os elementos no vetor e retornar a busca por um nome
fornecido pelo usurio. Utilizar bubblesort e mostrar passo a passo a execuo do algoritmo.

21. Desenvolva um algoritmo que receba do usurio 30 registros com os campos nome, sexo e
telefone. O algoritmo deve ordenar os elementos no vetor e retornar a busca por um nome
fornecido pelo usurio. Utilizar quicksort e mostrar passo a passo a execuo do algoritmo.

22. Desenvolva um algoritmo que receba do usurio 30 registros com os campos nome, sexo e
telefone. O algoritmo deve ordenar os elementos no vetor e retornar a busca por um nome
fornecido pelo usurio. Utilizar mergesort e mostrar passo a passo a execuo do algoritmo.

23. Desenvolva um algoritmo que recebe os dados de 20 funcionrios de uma empresa com os
campos: cdigo funcional, nome, salrio e data de admisso. O algoritmo deve criar um vetor de
registros com esses campos e armazenar as informaes fornecidas pelo usurio; esse algoritmo
deve, ainda, ordenar os elementos pelo campo cdigo funcional; e deve criar um mdulo para
encontrar os dados de um funcionrio. No utilizar bubblesort, nem quicksort, nem mergesort.
76
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

24. Desenvolva um algoritmo que recebe os dados de 20 funcionrios de uma empresa com os
campos: cdigo funcional, nome, salrio e data de admisso. O algoritmo deve criar um vetor de
registros com esses campos e armazenar as informaes fornecidas pelo usurio; esse algoritmo
deve, ainda, ordenar os elementos pelo campo cdigo funcional; e deve criar um mdulo para
encontrar os dados de um funcionrio. Utilizar bubblesort e mostrar passo a passo a execuo do
algoritmo.

25. Desenvolva um algoritmo que recebe os dados de 20 funcionrios de uma empresa com os
campos: cdigo funcional, nome, salrio e data de admisso. O algoritmo deve criar um vetor de
registros com esses campos e armazenar as informaes fornecidas pelo usurio; deve, ainda,
ordenar os elementos pelo campo cdigo funcional; e deve criar um mdulo para encontrar os
dados de um funcionrio. Utilizar quicksort e mostrar passo a passo a execuo do algoritmo.

26. Desenvolva um algoritmo que recebe os dados de 20 funcionrios de uma empresa com os
campos: cdigo funcional, nome, salrio e data de admisso. O algoritmo deve criar um vetor de
registros com esses campos e armazenar as informaes fornecidas pelo usurio; esse algoritmo
deve, ainda, ordenar os elementos pelo campo cdigo funcional; e deve criar um mdulo para
encontrar os dados de um funcionrio. Utilizar mergesort e mostrar passo a passo a execuo do
algoritmo.

77
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

6. Estrutura de Pilhas

Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos


estruturar as informaes de diferentes tipos de dados que podemos utilizar no programa. Para
isso, podemos utilizar a estrutura de dados chamada Pilha para estruturar essas informaes ao
programa inserindo, removendo e consultando informaes.
Pilhas so freqentemente usadas em compiladores para decodificar expresses aritmticas,
calcular endereos de retorno de chamadas de procedimentos, armazenar variveis locais de
procedimentos e parmetros, em sistemas operacionais. Alm disso, as pilhas tambm so
usadas na Mquina virtual Java. Podemos usar pilhas tambm para resoluo de algoritmos de
pesquisas e apoio deciso de melhor caminho dentre vrias possibilidades.
Outro exemplo de uso de pilhas so os navegadores da Internet, que guardam os endereos mais
recentemente visitados. Sempre que o usurio acessa um site, seu endereo guardado numa
pilha e, quando o usurio resolve pressionar o boto de voltar, retorna-se ao endereo que tinha
sido empilhado por ltimo.
A pilha uma das estruturas de dados mais simples e muito utilizada na cincia da computao
para a programao. Neste captulo, veremos como e quando trabalhar com pilhas, bem como
inserir, remover, consultar e manipular dados com pilha.

6.1. Definio de Pilha


Pilha uma estrutura de dados utilizada na programao de computadores que se dispe em
forma de lista linear, ou seja, um elemento est seguido do outro elemento e assim por diante
para todos os elementos da pilha.
A propriedade fundamental da pilha que o acesso d-se por um nico extremo, chamado topo.
Assim, qualquer elemento que seja inserido ou removido da pilha deve ser feito pelo topo. Da
mesma maneira, a consulta de um elemento da pilha s possvel pelo topo, ou seja, s
conseguimos verificar o contedo do topo da pilha. Esse processo chamado de LIFO ( Last In,
First Out), que, na lngua portuguesa, podemos chamar de UEPS (ltimo a Entrar, Primeiro a
Sair).
Para exemplificar a pilha, podemos pensar nas bandejas de uma lanchonete. Essas bandejas
normalmente esto empilhadas uma em cima da outra e, sempre que algum precisa pegar uma
bandeja desta pilha, retira a que est por cima, ou seja, no topo. Quando algum devolve uma
bandeja nesta pilha, coloca a bandeja por cima da pilha, ou seja, no topo. Assim, a ltima bandeja
colocada a primeira a ser retirada da pilha.
No entanto, se a pilha estiver vazia, ou seja, no existirem bandejas, no ser possvel retirar uma
bandeja. Por outro lado, uma bandeja s pode ser colocada sobre a pilha se houver espao para
isso, ou seja, se a pilha de bandejas no estiver to alta.

78
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

6.2. Exemplo de Pilha


Para exemplificar o funcionamento de pilha, vamos representar uma pilha de letras.
Inicialmente esta pilha est vazia, ou seja, seu topo igual a -1, conforme mostra a figura abaixo:

topo = 1
Vamos, ento, empilhar a letra A na pilha, em seguida empilhar a letra B e, depois, a letra C,
conforme a seqncia abaixo. Perceba que o topo muda a cada letra que empilhada:

topo = 1

topo = 0

topo = 1

topo = 2

Se quisermos desempilhar um elemento da pilha, s podemos desempilhar o elemento do topo,


veja a figura abaixo:

topo = 1

topo = 0

topo = 1

topo = 2

topo = 1

6.3. Operaes de Pilha


Pensando no funcionamento da pilha, conforme exemplificado nas sees 6.1. e 6.2., podemos
definir algumas operaes utilizadas na estrutura de dados da pilha:

empilhar - a operao de empilhar insere um elemento na pilha;


desempilhar - a operao de desempilhar remove um elemento da pilha;
pilha vazia - a operao pilha vazia verifica se a pilha est vazia;
pilha cheia - a operao pilha cheia verifica se a pilha est cheia;
elemento do topo - a operao elemento do topo mostra o elemento que est no topo da pilha;
mostrar pilha - a operao mostrar pilha exibe todos os elementos que a pilha possui.

79
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Para as operaes de pilha codificadas em pseudocdigo e em java, nesta seo,


consideraremos uma pilha que possa receber elementos do tipo numrico inteiro. No entanto,
possvel codificar essas operaes para quaisquer tipos de dados j estudados at ento.
Veremos outros exemplos que utilizam operaes de pilha, definidas com outros tipos de dados,
nos exemplos deste captulo.

6.3.1. Operaes de Pilha em Pseudocdigo


Para as operaes de pilha em pseudocdigo, utilizaremos a seguinte definio de registro:
// definio do tipo registro Pilha com os campos abaixo
tipo Pilha = registro // o tipo registro chama-se Pilha
tamanho numrico_inteiro; // campo tamanho
topo 1 numrico_inteiro; // campo topo
vetor [ tamanho] numrico_inteiro; // campo vetor de capacidade
fimregistro;
Onde o campo tamanho armazena a capacidade da pilha, ou seja, at quantos elementos a pilha
consegue armazenar; o campo topo armazena a posio do elemento que est no topo da pilha
e o campo vetor armazena os elementos que esto armazenados na pilha.

PilhaVazia um mdulo funo sem parmetros da operao pilha vazia. Esse mdulo retorna
verdadeiro se a pilha estiver vazia e retorna falso se a pilha no estiver vazia.
lgico PilhaVazia( )
incio_mdulo
se (topo = - 1)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
PilhaCheia um mdulo funo sem parmetros da operao pilha cheia que retorna verdadeiro
se a pilha estiver cheia, ou falso se a pilha estiver vazia.
lgico PilhaCheia( )
incio_mdulo
se (topo >= tamanho - 1)
ento

80
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
Empilhar um mdulo procedimento da operao empilhar que recebe como parmetro um
objeto elemento a ser empilhado. Este mdulo verifica se a pilha no est cheia antes de empilhar
o elemento. Se a pilha estiver cheia, o elemento no empilhado e uma mensagem enviada ao
usurio e, se a pilha no estiver cheia, o elemento empilhado.
Empilhar (elemento numrico_inteiro)
incio_mdulo
se (no PilhaCheia( ))
ento
topo topo + 1;
vetor[topo] elemento;
seno
escrever ("Pilha Cheia");
fimse;
fim_mdulo;
Desempilhar um mdulo funo sem parmetros da operao desempilhar. Esse mdulo
verifica se a pilha no est vazia antes de desempilhar o elemento. Se a pilha estiver vazia, o
elemento no pode ser desempilhado, ento uma mensagem enviada para o usurio e
retorna-se um elemento 0. Se a pilha no estiver vazia, o elemento do topo desempilhado e
retornado.
int Desempilhar ()
incio_mdulo
Declarar
desempilhado 0 numrico_inteiro;
se (PilhaVazia())
ento
escrever ("Pilha Vazia");
seno
desempilhado vetor[topo];
topo topo - 1;
fimse;
retornar desempilhado;
81
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fim_mdulo;
ElementoTopo um mdulo procedimento da operao elemento do topo que mostra ao usurio
o elemento que est no topo da pilha.
ElementoTopo( )
incio_mdulo
se (topo >= 0)
ento
escrever ("O elemento do topo " , vetor[topo];
seno
escrever(Pilha Vazia);
fimse;
fim_mdulo;
MostraPilha um mdulo procedimento da operao mostra pilha. Esse mdulo mostra ao
usurio todos os elementos da pilha.
MostrarPilha( )
incio_mdulo
Declarar
i numrico_inteiro;
para i de topo at 0 passo -1 faa
escrever ("Elemento " , vetor[i] , " posio " , (i+1));
fimpara;
fim_mdulo;

6.3.2. Operaes de Pilha em Java


Para as operaes de pilha em Java, utilizaremos a seguinte definio de registro numa classe
com o construtor da pilha e com as operaes de pilha:
class Pilha
{
int tamanho;
int topo;
int vetor [ ];
Pilha (int tam)
{

82
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

topo = -1;
tamanho = tam;
vetor = new int[tam];
}
// as operaes de pilha aparecem aqui
}
Onde o campo tamanho armazena a capacidade da pilha, ou seja, at quantos elementos a pilha
consegue armazenar; o campo topo armazena a posio do elemento que est no topo da pilha
e o campo vetor armazena os elementos que esto armazenados na pilha.

PilhaVazia um mdulo funo sem parmetros da operao pilha vazia. Esse mdulo retorna
verdadeiro se a pilha estiver vazia e retorna falso se a pilha no estiver vazia.
public boolean PilhaVazia( )
{
if (topo == -1)
{
return true;
}
else
{
return false;
}
}
PilhaCheia um mdulo funo sem parmetros da operao pilha cheia. Tal mdulo retorna
verdadeiro se a pilha estiver cheia ou falso se a pilha estiver vazia.
public boolean PilhaCheia( )
{
if (topo >= tamanho-1)
{
return true;
}
else
{
return false;
}
}
Empilhar um mdulo procedimento da operao empilhar que recebe como parmetro um
objeto elemento a ser empilhado. Esse mdulo verifica se a pilha no est cheia antes de
empilhar o elemento. Se a pilha estiver cheia, o elemento no empilhado e uma mensagem
enviada ao usurio e, se a pilha no estiver cheia, o elemento empilhado.

public void Empilhar (int elemento)


83
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
if (! PilhaCheia( ))
{
topo = topo + 1;
vetor[topo] = elemento;
}
else
{
System.out.println ("Pilha Cheia");
}
}
Desempilhar um mdulo funo sem parmetros da operao desempilhar que verifica se a
pilha no est vazia antes de desempilhar o elemento. Se a pilha estiver vazia, o elemento no
pode ser desempilhado, ento uma mensagem enviada para o usurio e retorna-se um
elemento 0. Se pilha no estiver vazia, o elemento do topo desempilhado e retornado.
// retorna o valor desempilhado
public int Desempilhar ()
{
int desempilhado = 0;
if (PilhaVazia())
{
System.out.println("Pilha Vazia");
}
else
{
desempilhado = vetor[topo];
topo = topo - 1;
}
return desempilhado;
}
ElementoTopo um mdulo procedimento da operao elemento do topo que mostra ao usurio
o elemento que est no topo da pilha.
public void ElementoTopo( )
{
if (topo >= 0)
System.out.println("O elemento do topo " + vetor[topo]);
}
else
{
System.out.println("Pilha Vazia");
}
}

84
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

MostraPilha um mdulo procedimento da operao mostra pilha que expe ao usurio todos os
elementos da pilha.
public void MostrarPilha( )
{
int i;
for (i = topo ; i >= 0 ; i--)
{
System.out.println("Elemento " + vetor[i] + " posio " + i);
}
}

6.4. Representao do Funcionamento das Operaes de Pilha


Nesta seo, vamos representar o funcionamento das operaes de pilha descritas na seo
anterior. Para isso, vamos empilhar, desempilhar e mostrar o contedo de uma pilha de letras
com capacidade para 3 letras, considerando-se que, inicialmente, a pilha est vazia:

topo = 1

Empilhar(25);
empilha o elemento 25 no topo da pilha.

25
topo = 1

topo = 0

Empilhar(32);
empilha o elemento 32 no topo da pilha.

25
topo = 1

topo = 0

32
25
topo = 1

85
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ElementoTopo( );
mostra o elemento 32 que est no topo da pilha e a pilha fica inalterada:

topo = 1

25

32
25

topo = 0

topo = 1

Empilhar(48);
empilha o elemento 48 no topo da pilha.

topo = 1

48
32
25

25

32
25

topo = 0

topo = 1

topo = 2

Empilhar(96);
como a pilha tem capacidade para 3 elementos, ela j est cheia, por isso, mostra a mensagem
"Pilha Cheia" e a pilha fica inalterada.

topo = 1

48
32
25

25

32
25

topo = 0

topo = 1

topo = 2

Desempilhar( );
desempilha e retorna o elemento 48, que o elemento do topo da pilha.

topo = 1

25

32
25

48
32
25

32
25

topo = 0

topo = 1

topo = 2

topo = 1

86
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Desempilhar( );
desempilha e retorna o elemento 32, que o elemento do topo da pilha.

topo = 1

25

32
25

48
32
25

32
25

25

topo = 0

topo = 1

topo = 2

topo = 1

topo = 0

ElementoTopo( )
mostra o elemento 25, que est no topo da pilha, e a pilha fica inalterada:

topo = 1

25

32
25

48
32
25

32
25

25

topo = 0

topo = 1

topo = 2

topo = 1

topo = 0

Desempilhar( )
desempilha e retorna o elemento 25, que est no topo da pilha.

topo = 1

25

32
25

48
32
25

32
25

25

topo = 0

topo = 1

topo = 2

topo = 1

topo = 0

topo = 1

Desempilhar( )
como a pilha est vazia, mostra a mensagem "Pilha Vazia" e a pilha fica inalterada.

topo = 1

25

32
25

48
32
25

32
25

25

topo = 0

topo = 1

topo = 2

topo = 1

topo = 0

topo = 1

87
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

6.5. Exemplo de Pilhas em Pseudocdigo


1. Desenvolva um algoritmo que receba do usurio cinco nmeros inteiros numa pilha com
capacidade para cinco nmeros e que mostre esses nmeros.
Algoritmo Pilha
incio_algoritmo
Definir
// definio do tipo registro Pilha com os campos abaixo
tipo Pilha = registro // o tipo registro chama-se Pilha
tamanho numrico_inteiro; // campo tamanho
topo -1 numrico_inteiro; // campo topo
vetor [ tamanho] numrico_real; // campo vetor de capacidade
fimregistro;
lgico PilhaVazia( )
incio_mdulo
se (topo = -1)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
lgico PilhaCheia( )
incio_mdulo
se (topo >= tamanho-1)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
Empilhar (elemento numrico_real)

88
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

incio_mdulo
se (no PilhaCheia( ))
ento
topo topo + 1;
vetor[topo] elemento;
seno
escrever("Pilha Cheia");
fimse;
fim_mdulo;
numrico_real Desempilhar ()
incio_mdulo
Declarar
desempilhado 0.0 numrico_real;
se (PilhaVazia())
ento
escrever ("Pilha Vazia");
seno
desempilhado vetor[topo];
topo topo - 1;
fimse;
retornar desempilhado;
fim_mdulo;
ElementoTopo( )
incio_mdulo
se (topo >= 0)
ento
escrever ("O elemento do topo " , vetor[topo]);
seno
escrever(Pilha Vazia);
fimse;
fim_mdulo;
MostrarPilha( )
incio_mdulo;
Declarar

89
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

i numrico_inteiro;
para i de topo at 0 passo -1 faa
escrever ("Elemento " , vetor[i] , " posio " , (i+1));
fimpara;
fim_mdulo;
fim_algoritmo.
Algoritmo Exemplo1
incio_algoritmo
Declarar
realPilha novo Pilha(5);
i numrico_inteiro;
entrada numrico_real;
para i de 1 at 5 passo +1faa
escrever(Digite um valor real);
ler(entrada);
realPilha.Empilhar(entrada);
fimpara;
realPilha.MostrarPilha( );
fim_algoritmo.

2. Desenvolva um algoritmo que receba cinco vogais em qualquer ordem e que mostre essas
vogais ordenadas numa estrutura de pilha.
Algoritmo Pilha
incio_algoritmo
Definir
// definio do tipo registro Pilha com os campos abaixo
tipo Pilha = registro // o tipo registro chama-se Pilha
tamanho numrico_inteiro; // campo tamanho
topo -1 numrico_inteiro; // campo topo
vetor [ tamanho] alfanumrico; // campo vetor de capacidade
fimregistro;
lgico PilhaVazia( )
incio_mdulo

90
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

se (topo = -1)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
lgico PilhaCheia( )
incio_mdulo
se (topo >= tamanho-1)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
Empilhar (elemento alfanumrico)
incio_mdulo
se (no PilhaCheia( ))
ento
topo topo + 1;
vetor[topo] elemento;
seno
escrever("Pilha Cheia");
fimse;
fim_mdulo;
alfanumrico Desempilhar ()
incio_mdulo
Declarar
desempilhado 0 alfanumrico;
se (PilhaVazia())
ento
escrever ("Pilha Vazia");

91
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

seno
desempilhado vetor[topo];
topo topo - 1;
fimse;
retornar desempilhado;
fim_mdulo;
ElementoTopo( )
incio_mdulo
se (topo >= 0)
ento
escrever ("O elemento do topo " , vetor[topo]);
seno
escrever(Pilha Vazia);
fimse;
fim_mdulo;
MostrarPilha( )
incio_mdulo;
Declarar
i numrico_inteiro;
para i de topo at 0 passo -1 faa
escrever ("Elemento " , vetor[i] , " posio " , (i+1));
fimpara;
fim_mdulo;
fim_algoritmo.
Algoritmo Exemplo2
inicio_algoritmo
Declarar
alfaPilha1 novo Pilha(5);
alfaPilha2 novo Pilha(5);
i, j numrico_inteiro;
entrada alfanumrico;
para i de 1 at 5 passo +1 faa

92
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

escrever ("Digite uma vogal");


ler(entrada);
enquanto ((no alfaPilha1.PilhaVazia()) e (alfaPilha1.vetor[alfaPilha1.topo] < entrada)
alfaPilha2.Empilhar(alfaPilha1.Desempilhar());
fimenquanto;
alfaPilha1.Empilhar(entrada);
enquanto (no alfaPilha2.PilhaVazia())
alfaPilha1.Empilhar(alfaPilha2.Desempilhar());
fimenquanto;
fimpara;
alfaPilha1.MostrarPilha( );
fim_algoritmo.

3. Desenvolva um algoritmo que receba 10 nmeros reais e que armazene numa estrutura de
pilha somente os nmeros divisveis por trs, e depois mostre todos os elementos da pilha.
Algoritmo Pilha
incio_algoritmo
Definir
// definio do tipo registro Pilha com os campos abaixo
tipo Pilha = registro // o tipo registro chama-se Pilha
tamanho numrico_inteiro; // campo tamanho
topo -1 numrico_inteiro; // campo topo
vetor [ tamanho] numrico_inteiro; // campo vetor de capacidade
fimregistro;
lgico PilhaVazia( )
incio_mdulo
se (topo = -1)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;

93
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

lgico PilhaCheia( )
incio_mdulo
se (topo >= tamanho-1)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
Empilhar (elemento numrico_inteiro)
incio_mdulo
se (no PilhaCheia( ))
ento
topo topo + 1;
vetor[topo] elemento;
seno
escrever("Pilha Cheia");
fimse;
fim_mdulo;
int Desempilhar ()
incio_mdulo
Declarar
desempilhado 0 numrico_inteiro;
se (PilhaVazia())
ento
escrever ("Pilha Vazia");
seno
desempilhado vetor[topo];
topo topo - 1;
fimse;
retornar desempilhado;
fim_mdulo;
ElementoTopo( )
94
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

incio_mdulo
se (topo >= 0)
ento
escrever ("O elemento do topo " , vetor[topo]);
seno
escrever(Pilha Vazia);
fimse;
fim_mdulo;
MostrarPilha( )
incio_mdulo;
Declarar
i numrico_inteiro;
para i de topo at 0 passo -1 faa
escrever ("Elemento " , vetor[i] , " posio " , (i+1));
fimpara;
fim_mdulo;
fim_algoritmo.
Algoritmo Exemplo3
incio_algoritmo
Declarar
intPilha novo Pilha(10);
entrada i numrico_inteiro;
para i de 0 at 10 passo +1 faa
escrever("Digite um nmero inteiro");
ler(entrada);
se ((entrada mod 3) = 0)
ento
intPilha.Empilhar(entrada);
fimse;
fimpara;
intPilha.MostrarPilha( );
fim_algoritmo.

95
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

6.6. Exemplo de Pilhas em Java


1. Desenvolva um algoritmo que receba do usurio cinco nmeros inteiros numa pilha com
capacidade para cinco nmeros e que mostre esses nmeros.
import javax.swing.*;
class Pilha
{
int tamanho;
int topo;
double vetor [ ];
Pilha (int tam)
{
topo = -1;
tamanho = tam;
vetor = new double[tam];
}
public boolean PilhaVazia( )
{
if (topo == -1)
{
return true;
}
else
{
return false;
}
}
public boolean PilhaCheia( )
{
if (topo >= tamanho-1)
{
return true;
}
else
{
return false;
}
}
public void Empilhar (double elemento)
{
if (! PilhaCheia( ))
{
96
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

topo = topo + 1;
vetor[topo] = elemento;
}
else
{
System.out.println ("Pilha Cheia");
}
}
public double Desempilhar ()
{
double desempilhado = 0.0;
if (PilhaVazia())
{
System.out.println("Pilha Vazia");
}
else
{
desempilhado = vetor[topo];
topo = topo 1;
}
return desempilhado;
}
public void ElementoTopo( )
{
if (topo >= 0)
{
System.out.println("O elemento do topo " + vetor[topo]);
}
else
{
System.out.println("Pilha Vazia");
}
}
public void MostrarPilha( )
{
int i;
for (i = topo ; i >= 0 ; i)
{
System.out.println("Elemento "+ vetor[i] +" posio " + i);
}
}
}
class Exemplo1
{
public static void main (String arg [])

97
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
Pilha realPilha = new Pilha(5);
int i;
double entrada;
for (i = 1 ; i <= 5 ; i++)
{
entrada = Double.parseDouble(JOptionPane.showInputDialog(
"Digite um valor real));
realPilha.Empilhar(entrada);
}
realPilha.MostrarPilha( );
System.exit(0);
}
}

2. Desenvolva um algoritmo que receba cinco vogais em qualquer ordem e que mostre essas
vogais ordenadas numa estrutura de pilha.
import javax.swing.*;
class Pilha
{
int tamanho;
int topo;
char vetor [ ];
Pilha (int tam)
{
topo = -1;
tamanho = tam;
vetor = new char[tam];
}
public boolean PilhaVazia( )
{
if (topo == -1)
{
return true;
}
else
{
return false;
}
}
public boolean PilhaCheia( )
{
if (topo >= tamanho-1)
98
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
return true;
}
else
{
return false;
}
}
public void Empilhar (char elemento)
{
if (! PilhaCheia( ))
{
topo = topo + 1;
vetor[topo] = elemento;
}
else
{
System.out.println ("Pilha Cheia");
}
}
public char Desempilhar ()
{
char desempilhado = 0;
if (PilhaVazia())
{
System.out.println("Pilha Vazia");
}
else
{
desempilhado = vetor[topo];
topo = topo 1;
}
return desempilhado;
}
public void ElementoTopo( )
{
if (topo >= 0)
{
System.out.println("O elemento do topo " + vetor[topo]);
}
else
{
System.out.println("Pilha Vazia");
}
}

99
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public void MostrarPilha( )


{
int i;
for (i = topo ; i >= 0 ; i)
{
System.out.println("Elemento "+ vetor[i] +" posio " + i);
}
}
}
class Exemplo2
{
public static void main (String arg [])
{
Pilha alfaPilha1 = new Pilha(5);
Pilha alfaPilha2 = new Pilha(5);
int i, j;
char entrada;
for (i = 1 ; i <= 5 ; i++)
{
entrada = JOptionPane.showInputDialog("Digite uma
vogal").charAt(0);
while ((!alfaPilha1.PilhaVazia()) &&
(alfaPilha1.vetor[alfaPilha1.topo] < entrada))
{
alfaPilha2.Empilhar(alfaPilha1.Desempilhar());
}
alfaPilha1.Empilhar(entrada);
while (!alfaPilha2.PilhaVazia())
{
alfaPilha1.Empilhar(alfaPilha2.Desempilhar());
}
}
alfaPilha1.MostrarPilha( );
System.exit(0);
}
}

100
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

3. Desenvolva um algoritmo que receba 10 nmeros inteiros e que armazene numa estrutura de
pilha somente os nmeros divisveis por trs, e depois mostre todos os elementos da pilha.
import javax.swing.*;
class Pilha
{
int tamanho;
int topo;
int vetor [ ];
Pilha (int tam)
{
topo = -1;
tamanho = tam;
vetor = new int[tam];
}
public boolean PilhaVazia( )
{
if (topo == -1)
{
return true;
}
else
{
return false;
}
}
public boolean PilhaCheia( )
{
if (topo >= tamanho-1)
{
return true;
}
else
{
return false;
}
}
public void Empilhar (int elemento)
{
if (! PilhaCheia( ))
{
topo = topo + 1;
vetor[topo] = elemento;
}
else

101
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
System.out.println ("Pilha Cheia");
}
}
public int Desempilhar ()
{
int desempilhado = 0;
if (PilhaVazia())
{
System.out.println("Pilha Vazia");
}
else
{
desempilhado = vetor[topo];
topo = topo 1;
}
return desempilhado;
}
public void ElementoTopo( )
{
if (topo >= 0)
{
System.out.println("O elemento do topo " + vetor[topo]);
}
else
{
System.out.println("Pilha Vazia");
}
}
public void MostrarPilha( )
{
int i;
for (i = topo ; i >= 0 ; i)
{
System.out.println("Elemento "+ vetor[i] +" posio " + i);
}
}
}
class Exemplo3
{
public static void main (String arg [])
{
Pilha intPilha = new Pilha(10);
int entrada, i;

102
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

for (i = 1 ; i <= 10 ; i++)


{
entrada = Integer.parseInt(JOptionPane.showInputDialog("
Digite um nmero inteiro"));
if ((entrada % 3) == 0)
{
intPilha.Empilhar(entrada);
}
}
intPilha.MostrarPilha( );
System.exit(0);
}
}

6.7. Exerccios de Pilhas


Os algoritmos abaixo devem ser desenvolvidos em pseudocdigo e com a utilizao da estrutura
de dados de pilha.
01. Desenhe a representao da pilha para a seguinte seqncia de operaes, considerando que a
pilha est inicialmente vazia:
a. ElementoTopo ( );
b. Empilhar (3);
c. Empilhar (7);
d. Desempilhar( );
e. Empilhar (25);
f. Empilhar (18);
g. Desempilhar ( );
h. ElementoTopo ( );
i. Desempilhar ( );
j. MostrarPilha ( );
k. Desempilhar ( );
02. Desenvolva um algoritmo que receba do usurio 10 nmeros inteiros em uma pilha e que inverta a
ordem dos elementos desta pilha usando duas pilhas adicionais.

03. Desenvolva um algoritmo que receba do usurio 10 nmeros reais em uma pilha e que inverta a
ordem dos elementos desta pilha usando uma pilha adicional e algumas variveis adicionais.

103
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

04. Desenvolva um algoritmo que receba do usurio cem nmeros inteiros e que construa uma pilha
apenas com os nmeros pares, e depois mostre os dez primeiros nmeros desta pilha.

05. Desenvolva um algoritmo que receba do usurio um conjunto de caracteres alfanumricos,


podendo ser uma frase ou uma palavra, armazena em uma estrutura de pilha e que mostre esses
caracteres de forma invertida.

06. Desenvolva um algoritmo que receba do usurio 50 caracteres e construa uma pilha apenas com
as vogais, e depois mostre os dez primeiros elementos desta pilha.

07. Desenvolva um algoritmo que receba do usurio 10 nmeros inteiros e que armazene numa pilha
na ordem numrica. Deve-se colocar em ordem no momento da construo da pilha. Deve-se,
ainda, utilizar uma pilha auxiliar.
08. Desenvolva um algoritmo que receba do usurio 10 nmeros reais e armazene numa pilha na
ordem numrica. Deve-se colocar em ordem no momento da construo da pilha. Deve-se utilizar
somente duas pilhas em nico vetor.

09. Desenvolva um algoritmo que receba do usurio 15 nmeros inteiros e que transfira os elementos
dessa pilha para outra pilha, de modo que os elementos da segunda pilha estejam na mesma
ordem que os da primeira pilha. Utilizar uma pilha adicional.

10. Desenvolva um algoritmo que receba do usurio 15 nmeros reais e que transfira os elementos
desta pilha para outra pilha, de modo que os elementos da segunda pilha estejam na mesma
ordem que os da primeira pilha. Usar somente algumas variveis adicionais e nenhuma outra
pilha auxiliar.

11. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos e parnteses para isolar as operaes. Esse algoritmo deve, ainda,
verificar se todos os parnteses abertos foram fechados. Para isso, empilhe os '(' e quanto
aparecer um ')', um '(' deve ser desempilhado. Ao final da expresso matemtica, se todos os
parnteses foram desempilhados ou se nenhum ')' sobrou sem desempilhar um '(', significa que a
expresso matemtica est correta, caso contrrio, significa que a expresso matemtica possui
um erro.
12. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos, parnteses, conchetes e chaves para isolar as operaes e verifica se
todos os parnteses, conchetes e chaves abertos foram fechados. Para isso, empilhe os ( e
quanto aparecer um ), um ( deve ser desempilhado, empilhe os [ e quanto aparecer um ], um
[ deve ser desempilhado e empilhe as { e quanto aparecer um }, um { deve ser desempilhado.
Ao final da expresso matemtica, se todos os parnteses, conchetes e chaves foram
desempilhados ou se nenhum ) , ] ou } sobrou sem desempilhar um (, [ ou { significa que a
expresso matemtica est correta, caso contrrio, significa que a expresso matemtica possui
um erro.

104
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

13. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos e parnteses para isolar as operaes matemticas e verifica se a
expresso matemtica est correta, ou seja, se no aparece uma seqncia de operadores sem
operandos, ou uma seqncia de operandos sem operadores, pois numa operao matemtica,
os operandos e os operadores esto sempre se alternando de forma que a operao matemtica
inicia e termina com um operando e nunca com um operador.

14. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos, parnteses, conchetes e chaves para isolar as operaes matemticas
e verifica se a expresso matemtica est correta, ou seja, se no aparece uma seqncia de
operadores sem operandos, ou uma seqncia de operandos sem operadores, pois numa
operao matemtica, os operandos e os operadores esto sempre se alternando de forma que a
operao matemtica inicia e termina com um operando e nunca com um operador.

15. Um sistema de numerao chama-se decimal quando sua base 10, ou seja, este sistema de
numerao possui 10 caracteres que o representam e que so: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Um
sistema de numerao chama-se binrio quando sua base 2, ou seja, este sistema possui 2
caracteres que o representam e que so: 0 e 1. Podemos representar um nmero decimal em
binrio por divises sucessivas desse nmero por 2 at que o quociente seja 0. O representante
binrio desse nmero ser composto por todos os restos, mas na ordem inversa que foram
calculados. Com base nessas informaes, desenvolva um algoritmo que receba do usurio um
nmero inteiro decimal e que mostre o seu correspondente em binrio. O algoritmo deve utilizar a
estrutura de dados de pilhas.

16. Um sistema de numerao chama-se hexadecimal quanto sua base 16, ou seja, este sistema
de numerao possui 16 caracteres que o representam e que so: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B,
C, D, E e F. Podemos representar um nmero decimal em hexadecimal por divises sucessivas
desse nmero por 16 at que o quociente seja 0. O representante hexadecimal desse nmero
ser composto por todos os restos, mas na ordem inversa que foram calculados. Quando o
resto for 10, dever ser considerado como A, quando for 11, considerado como B, quando for 12,
considerado como C, quando for 13, considerado como D, quando for 14, considerado como E e
quando for 15, considerado como E. Com base nessas informaes, desenvolva um algoritmo
que receba do usurio um nmero inteiro decimal e que mostre o seu correspondente em
hexadecimal. O algoritmo deve utilizar a estrutura de dados de pilhas.
Considere a soma de dois nmeros X e Y. Podemos representar essa soma de trs formas
diferentes:

X + Y a forma mais conhecida chamada de infixa, porque o operador + aparece entre os


operandos X e Y;

+ X Y chamada de prefixa e utilizada na programao, porque o operador + aparece antes dos


dois operandos X e Y, mas calcula a soma corretamente e;

X Y + chamada de posfixa e utilizada em calculadoras financeiras (por exemplo, a 12C), porque


o operador + aparece depois dos dois operandos X e Y, mas calcula a soma corretamente.
Por exemplo:
5 3 2 + * : est representado na expresso posfixa e equivale a 5 * (3 + 2) na expresso infixa. E a
resposta desta expresso igual a 25.

105
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

- / 4 2 5 : est representado na expresso infixa e equivale a 4 / 2 - 5 na expresso posfixa.


Com base nessas informaes, resolva os exerccios 15, 16, 17, 18, 19, 20, 21 e 22.
17. Transforme as seguintes expresses prefixas em posfixas:
a. 10 + 5 - 21
b. (7 + 14) * (6 - 12) / 5 * 2
c. (3 + 8) * (5 / (7 + 2) * 5) - 8
d. (8 - ((3 + 4) / (2 + 8) * 7) * (4 + 8)

18. Transforme as seguintes expresses prefixas em infixas:


a. * + 10 8 21
b. - 8 * 7 8
c. + / 9 - + * 8 4 10 / * 11 3 + 13 5 6
d. + * + 7 5 4 * 10 + * 4 3 2

19. Transforme as seguintes expresses posfixas em infixas:


a. 5 10 * 5 /
b. 2 4 6 * +
c. 10 4 - 5 * 2 4 8 + * +
d. 2 9 10 7 3 - + * + 15 8 / +

20. Desenvolva um algoritmo que receba do usurio uma expresso posfixa e que mostre o resultado
dessa expresso. O algoritmo deve utilizar as estruturas de dados de pilha.

21. Desenvolva um algoritmo que receba do usurio uma expresso infixa e que mostre esta
expresso escrita na forma posfixa. O algoritmo deve utilizar as estruturas de dados de pilha.

22. Desenvolva um algoritmo que receba do usurio uma expresso posfixa e que mostre esta
expresso escrita na forma infixa. O algoritmo deve utilizar as estruturas de dados de pilha.

23. Desenvolva um algoritmo que receba do usurio uma expresso infixa e que mostre o resultado
dessa expresso. O algoritmo deve utilizar as estruturas de dados de pilha.

24. Desenvolva um algoritmo que receba do usurio ma expresso infixa e que mostre o expresso
escrita na forma prefixa. O algoritmo deve utilizar as estrutura de dados de pilha.

106
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

25. Desenvolva um algoritmo que receba dois conjuntos de caracteres A e B e que verifique se um
o inverso do outro, por exemplo, se um dos conjuntos de caracteres for ABBABAAB, o outro
conjunto de caracteres ser o inverso deste se for BAABABBA. Em cada ponto, o algoritmo deve
ler somente o prximo caractere do conjunto de caracteres. O algoritmo deve utilizar a estrutura
de dados de pilha.

26. Desenvolva um algoritmo que represente um estacionamento de carros com capacidade para 10
carros e que possua um nico porto para entrada e sada de carros na extremidade do
estacionamento, onde os carros so sempre estacionados um na frente do outro. Assim, quanto
um carro precisa ser retirado do estacionamento e no for o carro mais prximo do porto de
sada, todos os carros estacionados na frente desse carro devem ser retirados e, aps remover o
carro que deve ser retirado, todos os carros que estavam na frente devem voltar ao
estacionamento para a mesma seqncia inicial. O algoritmo deve receber do usurio a placa do
carro e se o carro est entrando ou deixando o estacionamento. Se um carro estiver entrando no
estacionamento, mas este estiver lotado, o algoritmo deve enviar mensagem ao usurio avisando
que ele no pode estacionar. Se um carro estiver saindo do estacionamento, deve ser informado
quantas vezes o carro foi manobrado para que outros carros atrs dele fossem retirados. O
algoritmo deve utilizar a estrutura de dados da pilha.

27. Desenvolva um algoritmo que represente um estacionamento de carros com capacidade para 10
carros e que possua um nico porto para entrada e sada de carros no centro do
estacionamento. Nesse estacionamento, os carros so sempre estacionados um na frente do
outro, direita ou esquerda do porto. Assim, o estacionamento tem capacidade para
estacionar 5 carros esquerda do porto de entrada e outros 5 carros direita do porto de
entrada. Quando um carro precisa ser retirado do estacionamento e no for o carro mais prximo
do porto de sada, todos os carros estacionados na frente desse carro devem ser retirados e
aps remover o carro que deve ser retirado, todos os carros que estavam na frente devem voltar
ao estacionamento para a mesma seqncia inicial. O primeiro carro a entrar no estacionamento
deve estacionar esquerda do porto de entrada; o segundo carro a entrar deve estacionar
direita do porto de entrada; o terceiro carro esquerda; o quarto carro direita e assim por
diante, sempre intercalando. Se um carro estiver entrando no estacionamento, mas este estiver
lotado, o algoritmo deve enviar mensagem ao usurio avisando que ele no pode estacionar. Se
um carro estiver saindo do estacionamento, deve ser informado quantas vezes o carro foi
manobrado para que outros carros atrs dele fossem retirados. O algoritmo deve utilizar um nico
vetor e a estrutura de dados da pilha.

28. Desenvolva um algoritmo que recebe o nmero de uma conta corrente sem o dgito verificador e
armazena os dgitos desse nmero numa pilha. Com o auxlio de outra pilha, calcule o dgito
verificador desta conta corrente, armazenando o resultado na mesma pilha. Mostrar o nmero da
conta corrente com o dgito verificador. Para calcular o dgito verificador da conta corrente, some
o nmero da conta corrente com o seu reverso. Depois multiplique cada dgito por sua ordem
posicional e somar este resultado. O ltimo dgito deste resultado o dgito verificador da conta.
Por exemplo, considere a seguinte conta corrente: 25678
* o reverso deste nmero 87652;
* somar nmero da conta com seu reverso: 25678 + 87652 = 113330;
* multiplicar cada dgito por sua ordem posicional e somar este resultado:

107
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

posio

nmero

* soma = 1 * 1 + 2 * 1 + 3 * 3 + 4 * 3 + 5 * 3 + 6 * 0 = 39
* o ltimo dgito de 39 o dgito verificador da conta corrente, ou seja, 9
Logo, a conta corrente : 25678-9

29. Desenvolva um algoritmo que recebe o nmero de um CPF com 9 dgitos e sem os dgitos
verificadores e armazena os dgitos desse nmero numa pilha chamada CPF e de capacidade
para 11 elementos. Com o auxlio de outra pilha, calcula os dois dgitos verificadores e empilha na
mesma pilha CPF. Mostrar a pilha com o nmero do CPF e os dgitos verificadores. Para calcular
os dgitos verificadores de um CPF, utilize a seguinte frmula:
9

total1 =

(numi * (11 i))

i=1

resto1 = resto da diviso de total1 por 11


se resto1 for igual a 0 ou igual a 1 ento dig1 = 0 seno dig1 = 11 resto1
10

total2 = (numi * (12 i))


i=1

resto2 = resto da diviso de total2 por 11


se resto2 for igual a 0 ou igual a 1 ento dig2 = 0 seno dig2 = 11 resto2
Por exemplo, considere o seguinte CPF 111.222.333
i

num

total1 = 1 * 10 + 1 * 9 + 1 * 8 + 2 * 7 + 2 * 6 + 2 * 5 + 3 * 4 + 3 * 3 + 3 * 2 = 90
resto1 = 90 mod 11 = 2
como 2 diferente de 0 e 1, ento dig1 = 11 2 = 9
i

10

num

total2 = 1 * 11 + 1 * 10 + 1 * 9 + 2 * 8 + 2 * 7 + 2 * 6 + 3 * 5 + 3 * 4 + 3 * 3 + 9 * 2 = 126
resto2 = 126 mod 11 = 5
como 5 diferente de 0 e 1, ento dig2 = 11 5 = 6
Logo, o CPF completo : 111.222.333-96

108
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

30. Desenvolva um algoritmo que recebe 10 anos e empilha numa pilha os anos que so bissextos e
numa outra pilha os anos que no so bissextos. Mostrar os elementos das duas pilhas. Para
saber se um ano bissexto basta satisfazer um dos seguintes itens:

ano divisvel por 4 e no divisvel por 100


ano divisvel por 400

7. Estrutura de Filas

Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos


estruturar as informaes de diferentes tipos de dados que podemos utilizar no programa. Para
isso, podemos utilizar a estrutura de dados chamada Fila para estruturar essas informaes ao
programa inserindo, removendo e consultando informaes.
Filas so freqentemente usadas na computao em filas de impresso de um computador
servidor de impresses. Este enfileira os pedidos de impresso dos vrios usurios do sistema,
atribuindo o local de cada arquivo para impresso de acordo com a prioridade do usurio e a
prpria fila de processos esperando para serem executados num computador com um nico
processador.
Outro exemplo de uso de filas so em algoritmos de tratamento de fluxo de transporte de dados
em redes de computadores. Essas redes tambm utilizam filas para armazenar pacotes,
transmitidos atravs da rede, que chegam a um computador, pacotes esses que ainda no
puderam ser processados.
A fila uma das estruturas de dados mais simples e muito utilizada na cincia da computao
para a programao. Neste captulo, veremos como e quando trabalhar com filas, bem como
inserir, remover, consultar e manipular dados com fila.

7.1. Definio de Fila


Fila uma estrutura de dados utilizada na programao de computadores que se dispe em
forma de lista linear, ou seja, um elemento est seguido do outro elemento e assim por diante
para todos os elementos da fila.
A propriedade fundamental da fila que o acesso d-se pelos dois extremos chamados incio e
fim da fila. Assim, qualquer elemento que seja inserido deve ser feito pelo fim da fila e qualquer
elemento que seja removido deve ser feito pelo incio da fila. Dessa mesma maneira, deve ser
feita a consulta de um elemento da fila, ou seja, s conseguimos verificar o contedo do incio da
fila. Esse processo chamado de FIFO (First In, First Out), que, na lngua portuguesa, podemos
chamar de PEPS (Primeiro a Entrar, Primeiro a Sair).
Para exemplificar a fila, podemos pensar nas filas de um banco, de supermercado, de
restaurante, etc. Quem entrou na fila primeiro, chegar primeiro ao caixa e ser o primeiro a ser
atendido.
No entanto, se a fila estiver vazia, ou seja, no existirem pessoas na fila, no ser possvel sair
algum da fila para ser atendido. Por outro lado, uma pessoa s pode entrar na fila se houver
espao para isso, ou seja, se a fila de pessoas no estiver lotada.

109
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

7.2. Exemplo de Fila


Para exemplificar o funcionamento de fila, vamos representar uma fila de letras.
Inicialmente esta fila est vazia, ou seja, o total de elementos na fila igual a 0, conforme mostra
a figura a seguir:
total = 0

Vamos, ento, enfileirar a letra A na fila, em seguida enfileirar a letra B e, depois, a letra C,
conforme a seqncia abaixo. Perceba que o total de elementos na fila muda a cada letra que
enfileirada:
total = 0
A

total = 1

total = 2
C

total = 3

Se quisermos desenfileirar um elemento da fila, s podemos desenfileirar o primeiro elemento da


fila. Veja a figura abaixo:
total = 0
A

total = 1

total = 2
C

total = 3
total = 2

7.3. Operaes de fila


Pensando no funcionamento da fila, conforme exemplificado nas sees 7.1. e 7.2., podemos
definir algumas operaes utilizadas na estrutura de dados da fila:

enfileirar - a operao de enfileirar insere um elemento na fila;


desenfileirar - a operao de desenfileirar remove um elemento da fila;

110
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fila vazia - a operao fila vazia verifica se a fila est vazia;


fila cheia - a operao fila cheia verifica se a fila est cheia;
elemento do incio - a operao elemento do incio mostra o elemento que est no incio da
fila;

mostrar fila - a operao mostrar fila exibe todos os elementos que a fila possui.
Para as operaes de fila codificadas em pseudocdigo e em java, nesta seo, consideraremos
uma fila que possa receber elementos do tipo numrico inteiro. No entanto, possvel codificar
essas operaes para quaisquer tipos de dados j estudados at ento. Veremos outros
exemplos que utilizam operaes de fila, definidas com outros tipos de dados, nos exemplos
deste captulo.

7.3.1. Operaes de Fila em Pseudocgido


Para as operaes de fila em pseudocdigo, utilizaremos a seguinte definio de registro:
// definio do tipo registro Fila com os campos abaixo
tipo Fila = registro // o tipo registro chama-se Fila
tamanho 0 numrico_inteiro; // armazena o tamanho da fila
inicio 0 numrico_inteiro; // armazena a posio inicial da fila
fim 0 numrico_inteiro; // armazena a posio final da final
total 0 numrico_inteiro; // armazena a quantidade de elementos da fila
vetor [ tamanho] numrico_inteiro; // armazena os elementos da fila
fimregistro;

Onde o campo tamanho armazena a capacidade da fila, ou seja, at quantos elementos a fila
consegue armazenar; o campo inicio armazena a posio do elemento que est no incio da fila;
o campo fim armazena a posio do elemento que est no fim da fila; o campo total armazena a
quantidade de elementos que a fila possui; e o campo vetor armazena os elementos que esto
armazenados na fila.
FilaVazia um mdulo funo sem parmetros da operao fila vazia que retorna verdadeiro se a
fila estiver vazia e retorna falso se a fila no estiver vazia.
lgico FilaVazia( )
incio_mdulo
se (total = 0)
ento
retornar verdadeiro;
seno
retornar falso;

111
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimse;
fim_mdulo;
FilaCheia um mdulo funo sem parmetros da operao fila cheia. Esse mdulo retorna
verdadeiro se a fila estiver cheia ou falso se a fila estiver vazia.
lgico FilaCheia( )
incio_mdulo
se (total >= tamanho)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
Enfileirar um mdulo procedimento da operao enfileirar que recebe como parmetro um
objeto elemento a ser enfileirado. Este mdulo verifica se a fila no est cheia antes de enfileirar o
elemento. Se a fila estiver cheia, o elemento no enfileirado e uma mensagem enviada ao
usurio e, se a fila no estiver cheia, o elemento enfileirado.
Enfileirar (elemento numrico_inteiro)
incio_mdulo
se (no FilaCheia( ))
ento
vetor[fim] elemento;
fim fim + 1;
total total + 1;
se (fim > = tamanho)
ento
fim 0;
fimse;
seno
escrever ("Fila Cheia");
fimse;
fim_mdulo;
Desenfileirar um mdulo funo sem parmetros da operao desenfileirar que verifica se a fila
no est vazia antes de desenfileirar o elemento. Se a fila estiver vazia, o elemento no pode ser

112
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

desenfileirado, ento, uma mensagem enviada para o usurio e retorna-se um elemento nulo.
Se a fila no estiver vazia, o primeiro elemento da fila desenfileirado e retornado.
numrico_inteiro Desenfileirar ()
incio_mdulo
Declarar
desenfileirado 0 numrico_inteiro;
se (FilaVazia())
ento
escrever ("Fila Vazia");
seno
desenfileirado vetor[inicio ];
incio inicio + 1;
total total - 1;
se (inicio >= tamanho)
ento
inicio 0;
fimse;
retornar desenfileirado;
fim_mdulo;
ElementoInicio um mdulo procedimento da operao elemento do incio que mostra ao usurio
o primeiro elemento que est na fila.
ElementoInicio( )
incio_mdulo
se (no FilaVazia())
ento
escrever ("O primeiro elemento da fila " , vetor[inicio];
seno
escrever("Fila Vazia");
fimse;
fim_mdulo;
MostraFila um mdulo procedimento da operao mostra fila que mostra ao usurio todos os
elementos da fila.

113
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

MostrarFila( )
incio_mdulo
Declarar
i, aux numrico_inteiro;
aux inicio;
para i de 1 at total 1 passo +1 faa
escrever ("Elemento " , vetor[aux] , " posio " , i));
aux aux + 1;
se (aux >= tamanho)
ento
aux 0;
fimse;
fimpara;
fim_mdulo;

7.3.2. Operaes de Fila em Java


Para as operaes de fila em Java, utilizaremos a seguinte definio de registro numa classe com
o construtor da fila e com as operaes de fila:
class Fila
{
int tamanho, inicio, fim, total;
int vetor[];
Fila(int tam)
{
inicio = 0;
fim = 0;
total = 0;
tamanho = tam;
vetor = new int[tam];
}
// as operaes de fila aparecem aqui
}
Onde o campo tamanho armazena a capacidade da fila, ou seja, at quantos elementos a fila
consegue armazenar; o campo inicio armazena a posio do elemento que est no incio da fila;
o campo fim armazena a posio do elemento que est no fim da fila; o campo total armazena a
quantidade de elementos que a fila possui; e o campo vetor armazena os elementos que esto
armazenados na fila.

114
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

FilaVazia um mdulo funo sem parmetros da operao fila vazia que retorna verdadeiro se a
fila estiver vazia e retorna falso se a fila no estiver vazia.
public boolean FilaVazia( )
{
if (total == 0)
{
return true;
}
else
{
return false;
}
}
FilaCheia um mdulo funo sem parmetros da operao fila cheia que retorna verdadeiro se a
fila estiver cheia ou falso se a fila estiver vazia.
public boolean FilaCheia( )
{
if (total >= tamanho)
{
return true;
}
else
{
return false;
}
}
Enfileirar um mdulo procedimento da operao enfileirar que recebe como parmetro um
objeto elemento a ser enfileirado. Esse mdulo verifica se a fila no est cheia antes de enfileirar
o elemento. Se a fila estiver cheia, o elemento no enfileirado e uma mensagem enviada ao
usurio. Se a fila no estiver cheia, o elemento enfileirado.
public void Enfileirar (int elemento)
{
if (! FilaCheia( ))
{
vetor[fim] = elemento;
fim = fim + 1;
total = total + 1;
if (fim > = tamanho)
{
fim = 0;
}
}
115
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

else
{
System.out.println ("Fila Cheia");
}
}
Desenfileirar um mdulo funo sem parmetros da operao desenfileirar que verifica se a fila
no est vazia antes de desenfileirar o elemento. Se a fila estiver vazia, o elemento no pode ser
desenfileirado, ento, uma mensagem enviada para o usurio e retorna-se um elemento nulo.
Se a fila no estiver vazia, o primeiro elemento da fila desenfileirado e retornado.
// retorna o valor desenfileirado
public int Desenfileirar ()
{
int desenfileirado = 0;
if (FilaVazia())
{
System.out.println("Fila Vazia");
}
else
{
desenfileirado = vetor[inicio];
inicio = inicio + 1;
total = total - 1;
if (inicio >= tamanho)
{
inicio = 0;
}
}
return desenfileirado;
}
ElementoInicio um mdulo procedimento da operao elemento do incio que mostra ao usurio
o primeiro elemento que est na fila.
public void ElementoInicio( )
{
if (!FilaVazia())
{
System.out.println("O primeiro elemento " + vetor[inicio]);
}
else
{
System.out.println("Fila Vazia");
}
}

116
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

MostrarFila um mdulo procedimento da operao mostrar fila que mostra ao usurio todos os
elementos da fila.
public void MostrarFila( )
{
int i, aux;
aux = inicio;
for (i = 1 ; i <= total ; i++)
{
JOptionPane.showMessageDialog(null, "Elemento " + vetor[aux] +
" posio " + i);
aux = aux + 1;
if (aux >= tamanho)
{
aux = 0;
}
}
}

7.4. Representao do Funcionamento das Operaes de Fila


Nesta seo, vamos representar o funcionamento das operaes de fila descritas na seo
anterior. Para isso, vamos enfileirar, desenfileirar e mostrar o contedo de uma fila de letras com
capacidade para 3 letras, ou seja, o tamanho da fila 3, e considerando que inicialmente a fila
est vazia:
total = 0

Enfileirar(12);
enfileira o elemento 12 no incio da fila.
total = 0
12

total = 1

Enfileirar(25);
enfileira o elemento 25 na fila.
total = 0
12

total = 1

117
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

12

25

total = 2

ElementoInicio( );
mostra o elemento 12, que est no incio da fila, e a fila fica inalterada:
total = 0
12
12

total = 1
25

total = 2

Enfileirar(64);
enfileira o elemento 64 na fila.
total = 0
12

total = 1

12

25

12

25

total = 2
64

total = 3

Enfileirar(88);
como a fila tem capacidade para 3 elementos, ou seja, tamanho = 3, ela j est cheia. Por isso,
mostra a mensagem "Fila Cheia" e a fila fica inalterada.
total = 0
12

total = 1

12

25

12

25

total = 2
64

total = 3

Desenfileirar( );
desenfileira e retorna o elemento 12 que o elemento do incio da fila.
total = 0
12

total = 1

118
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

12

25

12

25

25

64

total = 2
64

total = 3
total = 2

Desenfileirar( );
desenfileira e retorna o elemento 25 que o elemento do incio da fila.
total = 0
12

total = 1

12

25

12

25

25

64

total = 2
64

total = 3
total = 2

64

total = 1

ElementoInicio( )
mostra o elemento 64 que est no incio da fila e a fila fica inalterada:
total = 0
12

total = 1

12

25

12

25

25

64

64

total = 2
64

total = 3
total = 2
total = 1

Desenfileirar( )
desenfileira e retorna o elemento 64 que est no incio da fila.
total = 0

119
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

12

total = 1

12

25

12

25

25

64

total = 2
64

total = 3
total = 2

64

total = 1
total = 0

Desenfileirar( )
como a fila est vazia, mostra a mensagem "Fila Vazia" e a fila fica inalterada.
total = 0
12

total = 1

12

25

12

25

25

64

64

total = 2
64

total = 3
total = 2
total = 1
total = 0

7.5. Exemplo de Filas em Pseudocdigo


1. Desenvolva um algoritmo que recebe do usurio cinco nmeros inteiros numa fila com
capacidade para cinco nmeros e que mostre a esses nmeros.
Algoritmo Fila
incio_algoritmo
Definir
// definio do tipo registro Fila com os campos abaixo
tipo Fila = registro // o tipo registro chama-se Fila
tamanho 0 numrico_inteiro; // armazena o tamanho da fila

120
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

inicio 0 numrico_inteiro; // armazena a posio inicial da fila


fim 0 numrico_inteiro; // armazena a posio final da final
total 0 numrico_inteiro; // armazena a quantidade de elementos da fila
vetor [ tamanho] numrico_real; // armazena os elementos da fila
fimregistro;
lgico FilaVazia( )
incio_mdulo
se (total = 0)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
lgico FilaCheia( )
incio_mdulo
se (total >= tamanho)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
Enfileirar (elemento numrico_real)
incio_mdulo
se (no FilaCheia( ))
ento
vetor[fim] elemento;
fim fim + 1;
total total + 1;
se (fim > = tamanho)
ento
fim 0;
fimse;
seno

121
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

escrever (Fila Cheia);


fimse;
fim_mdulo;
numrico_real Desenfileirar ()
incio_mdulo
Declarar
desenfileirado 0.0 numrico_real;
se (FilaVazia())
ento
escrever (Fila Vazia);
seno
desenfileirado vetor[inicio];
inicio inicio + 1;
total total 1;
se (inicio >= tamanho)
ento
inicio 0;
fimse;
retornar desenfileirado;
fim_mdulo;
ElementoInicio( )
incio_mdulo
se (no FilaVazia())
ento
escrever (O primeiro elemento da fila , vetor[inicio];
seno
escrever(Fila Vazia);
fimse;
fim_mdulo;
MostrarFila( )
incio_mdulo
Declarar
i, aux numrico_inteiro;

122
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

aux inicio;
para i de 1 at total passo +1 faa
escrever (Elemento , vetor[aux] , posio , i);
aux aux + 1;
se (aux >= tamanho)
ento
aux 0;
fimse;
fimpara;
fim_mdulo;
fim_algoritmo.
Algoritmo Exemplo1
incio_algoritmo
Declarar
realFila novo Fila(5);
entrada 0.0 numrico_real;
i numrico_inteiro;
para i de 1 at 5 passo +1faa
entrada escrever(Digite um valor real);
ler(entrada)
realFila.Enfileirar(entrada);
fimpara;
realFila.MostrarFila( );
fim_algoritmo.

2. Desenvolva um algoritmo que receba cinco vogais em qualquer ordem e que mostre essas
vogais ordenadas numa estrutura de fila.
Algoritmo Fila
incio_algoritmo
Definir
// definio do tipo registro Fila com os campos abaixo
tipo Fila = registro // o tipo registro chama-se Fila
tamanho 0 numrico_inteiro; // armazena o tamanho da fila
inicio 0 numrico_inteiro; // armazena a posio inicial da fila
123
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fim 0 numrico_inteiro; // armazena a posio final da final


total 0 numrico_inteiro; // armazena a quantidade de elementos da fila
vetor [ tamanho] alfanumrico; // armazena os elementos da fila
fimregistro;
lgico FilaVazia( )
incio_mdulo
se (total = 0)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
lgico FilaCheia( )
incio_mdulo
se (total >= tamanho)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
Enfileirar (elemento alfanumrico)
incio_mdulo
se (no FilaCheia( ))
ento
vetor[fim] elemento;
fim fim + 1;
total total + 1;
se (fim > = tamanho)
ento
fim 0;
fimse;
seno
escrever (Fila Cheia);

124
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimse;
fim_mdulo;
alfanumrico Desenfileirar ()
incio_mdulo
Declarar
desenfileirado 0 alfanumrico;
se (FilaVazia())
ento
escrever (Fila Vazia);
seno
desenfileirado vetor[inicio];
inicio inicio + 1;
total total 1;
se (inicio >= tamanho)
ento
inicio 0;
fimse;
retornar desenfileirado;
fim_mdulo;
ElementoInicio( )
incio_mdulo
se (no FilaVazia())
ento
escrever (O primeiro elemento da fila , vetor[inicio];
seno
escrever(Fila Vazia);
fimse;
fim_mdulo;
MostrarFila( )
incio_mdulo
Declarar
i, aux numrico_inteiro;
aux inicio;

125
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

para i de 1 at total passo +1 faa


escrever (Elemento , vetor[aux] , posio , i);
aux aux + 1;
se (aux >= tamanho)
ento
aux 0;
fimse;
fimpara;
fim_mdulo;
fim_algoritmo.
AlgoritmoExemplo2
incio_algoritmo
Declarar
alfaFila novo Fila(5);
aux, entrada 0 alfanumrico;
i, j, total numrico_inteiro;
ok lgico;
para i de 1 at 5 passo +1faa
ok verdadeiro;
entrada escrever(Digite uma vogal);
ler(entrada);
se (alfaFila.FilaVazia())
ento
alfaFila.Enfileirar(entrada);
seno
total alfaFila.total;
para j de 1 at total passo +1 faa
aux alfaFila.Desenfileirar();
se (entrada < aux e ok)
ento
alfaFila.Enfileirar(entrada);
ok falso;
fimse;
alfaFila.Enfileirar(aux);

126
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimpara;
se (ok)
ento
alfaFila.Enfileirar(entrada);
fimse;
fimse;
fimpara;
alfaFila.MostrarFila( );
fim_algoritmo.

3. Desenvolva um algoritmo que receba 10 nmeros inteiros e que armazene numa estrutura de
fila somente os nmeros divisveis por trs, e depois mostre todos os elementos da fila.
Algoritmo Fila
incio_algoritmo
Definir
// definio do tipo registro Fila com os campos abaixo
tipo Fila = registro // o tipo registro chama-se Fila
tamanho 0 numrico_inteiro; // armazena o tamanho da fila
inicio 0 numrico_inteiro; // armazena a posio inicial da fila
fim 0 numrico_inteiro; // armazena a posio final da final
total 0 numrico_inteiro; // armazena a quantidade de elementos da fila
vetor [ tamanho] numrico_inteiro; // armazena os elementos da fila
fimregistro;
lgico FilaVazia( )
incio_mdulo
se (total = 0)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
lgico FilaCheia( )
incio_mdulo

127
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

se (total >= tamanho)


ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
Enfileirar (elemento numrico_inteiro)
incio_mdulo
se (no FilaCheia( ))
ento
vetor[fim] elemento;
fim fim + 1;
total total + 1;
se (fim > = tamanho)
ento
fim 0;
fimse;
seno
escrever (Fila Cheia);
fimse;
fim_mdulo;
numrico_inteiro Desenfileirar ()
incio_mdulo
Declarar
desenfileirado 0 numrico_inteiro;
se (FilaVazia())
ento
escrever (Fila Vazia);
seno
desenfileirado vetor[inicio];
inicio inicio + 1;
total total 1;
se (inicio >= tamanho)
ento

128
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

inicio 0;
fimse;
retornar desenfileirado;
fim_mdulo;
ElementoInicio( )
incio_mdulo
se (no FilaVazia())
ento
escrever (O primeiro elemento da fila , vetor[inicio];
seno
escrever(Fila Vazia);
fimse;
fim_mdulo;
MostrarFila( )
incio_mdulo
Declarar
i, aux numrico_inteiro;
aux inicio;
para i de 1 at total passo +1 faa
escrever (Elemento , vetor[aux] , posio , i);
aux aux + 1;
se (aux >= tamanho)
ento
aux 0;
fimse;
fimpara;
fim_mdulo;
fim_algoritmo.
AlgoritmoExemplo3
incio_algoritmo
Declarar
intFila novo Fila(10);
entrada 0 numrico_inteiro;

129
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

i numrico_inteiro;
para i de 1 at 10 passo +1faa
entrada escrever(Digite um valor inteiro);
ler(entrada)
se (entrada mod 3 = 0)
ento
intFila.Enfileirar(entrada);
fimse;
fimpara;
intFila.MostrarFila( );
fim_algoritmo.

7.6. Exemplo de Filas em Java


1. Desenvolva um algoritmo que receba do usurio cinco nmeros inteiros numa fila com
capacidade para cinco nmeros e que mostre esses nmeros.
import javax.swing.*;
class Fila
{
int tamanho, inicio, fim, total;
double vetor[];
Fila(int tam)
{
inicio = 0;
fim = 0;
total = 0;
tamanho = tam;
vetor = new double[tam];
}
public boolean FilaVazia( )
{
if (total == 0)
{
return true;
}
else
{
return false;
}
}
public boolean FilaCheia( )

130
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
if (total >= tamanho)
{
return true;
}
else
{
return false;
}
}
public void Enfileirar (double elemento)
{
if (! FilaCheia( ))
{
vetor[fim] = elemento;
fim = fim + 1;
total = total + 1;
if (fim >= tamanho)
{
fim = 0;
}
}
else
{
System.out.println ("Fila Cheia");
}
}
// retorna o valor desenfileirado
public double Desenfileirar ()
{
double desenfileirado = 0.0;
if (FilaVazia())
{
System.out.println("Fila Vazia");
}
else
{
desenfileirado = vetor[inicio];
inicio = inicio + 1;
total = total 1;
if (inicio >= tamanho)
{
inicio = 0;
}
}
return desenfileirado;
}

131
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public void ElementoInicio( )


{
if (!FilaVazia())
{
System.out.println("O primeiro elemento "+ vetor[inicio]);
}
else
{
System.out.println("Fila Vazia");
}
}
public void MostrarFila( )
{
int i, aux;
aux = inicio;
for (i = 1 ; i <= total ; i++)
{
JOptionPane.showMessageDialog(null, "Elemento " + vetor[aux]
+
" posio " + i);
aux = aux + 1;
if (aux >= tamanho)
{
aux = 0;
}
}
}
}
class Exemplo1
{
public static void main (String arg [])
{
Fila realFila = new Fila(5);
double entrada = 0.0;
int i;
for (i = 0 ; i < 5 ; i++)
{
entrada = Double.parseDouble(JOptionPane.showInputDialog(
"Digite um valor real"));
realFila.Enfileirar(entrada);
}
realFila.MostrarFila( );
System.exit(0);
}
}

132
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

2. Desenvolva um algoritmo que receba cinco vogais em qualquer ordem e que mostre essas
vogais ordenadas numa estrutura de fila.
import javax.swing.*;
class Fila
{
int tamanho, inicio, fim, total;
char vetor[];
Fila(int tam)
{
inicio = 0;
fim = 0;
total = 0;
tamanho = tam;
vetor = new char[tam];
}
public boolean FilaVazia( )
{
if (total == 0)
{
return true;
}
else
{
return false;
}
}
public boolean FilaCheia( )
{
if (total >= tamanho)
{
return true;
}
else
{
return false;
}
}
public void Enfileirar (char elemento)
{
if (! FilaCheia( ))
{
vetor[fim] = elemento;
fim = fim + 1;

133
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

total = total + 1;
if (fim >= tamanho)
{
fim = 0;
}
}
else
{
System.out.println ("Fila Cheia");
}
}

// retorna o valor desenfileirado


public char Desenfileirar ()
{
char desenfileirado = 0.0;
if (FilaVazia())
{
System.out.println("Fila Vazia");
}
else
{
desenfileirado = vetor[inicio];
inicio = inicio + 1;
total = total 1;
if (inicio >= tamanho)
{
inicio = 0;
}
}
return desenfileirado;
}
public void ElementoInicio( )
{
if (!FilaVazia())
{
System.out.println("O primeiro elemento "+ vetor[inicio]);
}
else
{
System.out.println("Fila Vazia");
}
}
public void MostrarFila( )
{
int i, aux;
aux = inicio;
134
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

for (i = 1 ; i <= total ; i++)


{
JOptionPane.showMessageDialog(null, "Elemento " + vetor[aux]
+
" posio " + i);
aux = aux + 1;
if (aux >= tamanho)
{
aux = 0;
}
}
}
}
class Exemplo2
{
public static void main (String arg [])
{
Fila alfaFila = new Fila (5);
char aux, entrada = 0;
int i, j;
boolean ok;
for (i = 1 ; i <=5 ; i++)
{
ok = true;
entrada = (JOptionPane.showInputDialog("Digite uma
vogal")).charAt(0);
if (alfaFila.FilaVazia())
{
alfaFila.Enfileirar(entrada);
}
else
{
int total = alfaFila.total;
for (j = 1 ; j <= total ; j++)
{
aux = alfaFila.Desenfileirar();
if (entrada < aux && ok )
{
alfaFila.Enfileirar(entrada);
ok = false;
}
alfaFila.Enfileirar(aux);
}
if (ok)
{
alfaFila.Enfileirar(entrada);
}
}
}
135
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

alfaFila.MostrarFila();
System.exit(0);
}
}

3. Desenvolva um algoritmo que receba 10 nmeros inteiros e que armazene numa estrutura de
fila somente os nmeros divisveis por trs, e depois mostre todos os elementos da fila.
import javax.swing.*;
class Fila
{
int tamanho, inicio, fim, total;
int vetor[];
Fila(int tam)
{
inicio = 0;
fim = 0;
total = 0;
tamanho = tam;
vetor = new int[tam];
}
public boolean FilaVazia( )
{
if (total == 0)
{
return true;
}
else
{
return false;
}
}
public boolean FilaCheia( )
{
if (total >= tamanho)
{
return true;
}
else
{
return false;
}
}
136
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public void Enfileirar (int elemento)


{
if (! FilaCheia( ))
{
vetor[fim] = elemento;
fim = fim + 1;
total = total + 1;
if (fim >= tamanho)
{
fim = 0;
}
}
else
{
System.out.println ("Fila Cheia");
}
}

// retorna o valor desenfileirado


public int Desenfileirar ()
{
int desenfileirado = 0;
if (FilaVazia())
{
System.out.println("Fila Vazia");
}
else
{
desenfileirado = vetor[inicio];
inicio = inicio + 1;
total = total - 1;
if (inicio >= tamanho)
{
inicio = 0;
}
}
return desenfileirado;
}

137
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public void ElementoInicio( )


{
if (!FilaVazia())
{
System.out.println("O primeiro elemento " + vetor[inicio]);
}
else
{
System.out.println("Fila Vazia");
}
}
public void MostrarFila( )
{
int i, aux;
aux = inicio;
for (i = 1 ; i <= total ; i++)
{
JOptionPane.showMessageDialog(null, "Elemento " + vetor[aux]
+
" posio " + i);
aux = aux + 1;
if (aux >= tamanho)
{
aux = 0;
}
}
}
}
class Exemplo3
{
public static void main (String arg [])
{
Fila intFila = new Fila(10);
int entrada = 0;
int i;
for (i = 1 ; i <= 10 ; i++)
{
entrada = Integer.parseInt(JOptionPane.showInputDialog
("Digite um valor inteiro"));
if (Entrada % 3 == 0)
{
intFila.Enfileirar(entrada);
}
}
intFila.MostrarFila( );
System.exit(0);

138
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

}
}

7.7. Exerccios de Filas


Os algoritmos abaixo devem ser desenvolvidos em pseudocdigo e com a utilizao da estrutura
de dados de fila.
01. Desenhe a representao da fila para a seguinte seqncia de operaes, considerando que a fila
est inicialmente vazia:
a. ElementoInicio ( );
b. Enfileirar (3);
c. Enfileirar (7);
d. Desenfileirar( );
e. Enfileirar (25);
f. Enfileirar (18);
g. MostrarFila ( );
h. Desenfileirar ( );
i. ElementoInicio ( );
j. Desenfileirar ( );
k. Desenfileirar ( );

02. Desenvolva um algoritmo que receba do usurio 10 nmeros inteiros em uma fila e que inverta a
ordem dos elementos desta fila usando duas filas adicionais.

03. Desenvolva um algoritmo que receba do usurio 10 nmeros reais em uma fila e que inverta a
ordem dos elementos desta fila usando uma fila adicional e algumas variveis adicionais.

04. Desenvolva um algoritmo que receba do usurio cem nmeros inteiros e que construa uma fila
apenas com os nmeros mpares, e depois mostre os dez primeiros nmeros desta fila.

05. Considerando a necessidade de um algoritmo que administra filas de reserva de filmes de uma
vdeo locadora, desenvolva um algoritmo que receba do usurio o dia da semana em que ele
deseja alugar o filme, sabendo que para cada filme existem sete filas, uma para cada dia da
semana. Quando o usurio for informado da disponibilidade da fita e confirmar a locao, ele deve
sair da fila. Considerar que para cada filme existe uma nica fita.

06. Desenvolva um algoritmo que receba do usurio uma lista de compras para sua casa e, medida
que os itens forem comprados, eles devem sair da fila e uma mensagem deve ser mostrada ao
usurio.

139
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

07. Desenvolva um algoritmo que implemente uma fila de pilhas.

08. Desenvolva um algoritmo que implemente uma pilha de filas.

09. Desenvolva um algoritmo que implemente uma fila de filas.

10. Desenvolva um algoritmo que receba do usurio um conjunto de caracteres alfanumricos,


podendo ser uma frase ou uma palavra. Esse algoritmo deve armazenar em uma estrutura de fila
e deve mostrar esses caracteres de forma invertida.

11. Desenvolva um algoritmo que receba do usurio 50 caracteres e que construa uma fila apenas
com as vogais, e depois mostre os dez primeiros elementos desta fila.

12. Desenvolva um algoritmo que receba do usurio 10 nmeros inteiros e que armazene numa fila
na ordem numrica, O algoritmo deve colocar em ordem no momento da construo da fila. Alm
disso, o algoritmo deve utilizar uma fila auxiliar.

13. Desenvolva um algoritmo que receba do usurio 10 nmeros reais e que armazene numa fila na
ordem numrica. O algoritmo deve colocar em ordem no momento da construo da fila.
Ademais o algoritmo deve utilizar somente duas filas em nico vetor.

14. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos e parnteses para isolar as operaes e que verifique se todos os
parnteses abertos foram fechados. Para isso, enfileire todos os algarismos da expresso
matemtica numa fila. Depois, enquanto os algarismos forem desenfileirados, o algoritmo deve
verificar os pares de parnteses '(' e ')'. Ao final da expresso matemtica, se todos os parnteses
formarem um par de parnteses '(' e ')', significa que a expresso matemtica est correta, caso
contrrio, significa que a expresso matemtica possui um erro.

15. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos e parnteses para isolar as operaes e verifica se todos os parnteses
abertos foram fechados. Para isso, enfileire todos os algarismos da expresso matemtica numa
fila. Depois, enquanto os algarismos forem desenfileirados, o algoritmo deve verificar os pares de
parnteses ( e ); [ e ]; e { e }. Ao final da expresso matemtica, se todos os parnteses
formarem um par de parnteses ( e ); [ e ]; e { e } significa que a expresso matemtica est
correta, caso contrrio, significa que a expresso matemtica possui um erro.

16. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos e parnteses para isolar as operaes matemticas. O algoritmo deve
tambm verificar se a expresso matemtica est correta, ou seja, se no aparece uma
seqncia de operadores sem operandos, ou uma seqncia de operandos sem operadores. Isso
porque, numa operao matemtica, os operandos e os operadores esto sempre se alternando
de forma que a operao matemtica inicia e termina com um operando e nunca com um
operador. O algoritmo deve utilizar a estrutura de dados de fila.
140
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

17. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos, parnteses, conchetes e chaves para isolar as operaes matemticas
e verifica se a expresso matemtica est correta, ou seja, se no aparece uma seqncia de
operadores sem operandos, ou uma seqncia de operandos sem operadores, pois numa
operao matemtica, os operandos e os operadores esto sempre se alternando de forma que a
operao matemtica inicia e termina com um operando e nunca com um operador. Utilizar a
estrutura de dados de fila.

18. Um sistema de numerao chama-se decimal quando sua base 10, ou seja, este sistema de
numerao possui 10 caracteres que o representam e que so: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Um
sistema de numerao chama-se binrio quando sua base 2, ou seja, este sistema possui 2
caracteres que o representam e que so: 0 e 1. Podemos representar um nmero binrio em
decimal utilizando a notao posicional (somatria de dgito multiplicado pela base elevado
posio, ver exemplo abaixo). Com base nessas informaes, desenvolva um algoritmo que
receba do usurio um nmero inteiro binrio e que mostre o seu correspondente em decimal. O
algoritmo deve utilizar a estrutura de dados de fila.
Exemplo: representar o nmero binrio 10110 (base 2) em decimal

posio

nmero

10110 = 1 24 + 0 23 + 1 22 + 1 21 + 0 20 = 16 + 0 + 4 + 2 + 0 = 22 (decimal)
19. Um sistema de numerao chama-se hexadecimal quanto sua base 16, ou seja, este sistema
de numerao possui 16 caracteres que a representa e que so: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C,
D, E e F. Podemos representar um nmero hexadecimal em decimal utilizando a notao
posicional (somatria de dgito multiplicado pela base elevado posio, ver exemplo abaixo).
Com base nessas informaes, desenvolva um algoritmo que receba do usurio um nmero
inteiro hexadecimal e que mostre o seu correspondente em decimal. O algoritmo deve utilizar a
estrutura de dados de fila.
Exemplo: representar o nmero hexadecimal 10A5F (base 16) em decimal

posio

nmero

1AF5 = 1 163 + A 162 + 5 161 + F 160 = 4096 + 2560 + 80 + 15 = 6751 (decimal)


Considere a soma de dois nmeros X e Y. Podemos representar essa soma de trs formas
diferentes:

X + Y a forma mais conhecida, chamada de infixa, porque o operador + aparece entre os


operandos X e Y;

141
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

+ X Y, chamada de prefixa e utilizada na programao, porque o operador + aparece antes dos


dois operandos X e Y, mas calcula a soma corretamente e;

X Y +, chamada de posfixa e utilizada em calculadoras financeiras (por exemplo, a 12C),


porque o operador + aparece depois dos dois operandos X e Y, mas calcula a soma
corretamente.
Por exemplo:

5 3 2 + * : est representado na expresso posfixa e equivale a 5 * (3 + 2) na expresso infixa.


E a resposta desta expresso igual a 25.

- / 4 2 5 : est representado na expresso infixa e equivale a 4 / 2 - 5 na expresso posfixa.


Com base nessas informaes, resolva os exerccios 20, 21, 22, 23 e 24.

20. Desenvolva um algoritmo que receba do usurio uma expresso posfixa e que mostre o resultado
dessa expresso. O algoritmo deve utilizar as estruturas de dados de fila.

21. Desenvolva um algoritmo que receba do usurio uma expresso infixa e que mostre esta
expresso escrita na forma posfixa. O algoritmo deve utilizar as estruturas de dados de fila.

22. Desenvolva um algoritmo que receba do usurio uma expresso posfixa e que mostre esta
expresso escrita na forma infixa. O algoritmo deve utilizar as estruturas de dados de fila.

23. Desenvolva um algoritmo que receba do usurio uma expresso infixa e que mostreo resultado
dessa expresso. O algoritmo deve utilizar as estruturas de dados de fila.

24. Desenvolva um algoritmo que receba do usurio ma expresso infixa e que mostre o expresso
escrita na forma prefixa. O algoritmo deve utilizar as estrutura de dados de fila.

25. Desenvolva um algoritmo que receba dois conjuntos de caracteres A e B e que verifique se um
o inverso do outro. Assim, por exemplo, se um dos conjuntos de caracteres for ABBABAAB, o
outro conjunto de caracteres ser o inverso deste se for BAABABBA. Em cada ponto, o algoritmo
deve ler somente o prximo caractere do conjunto de caracteres. O algoritmo deve utilizar a
estrutura de dados de fila.

26. Desenvolva um algoritmo que represente um estacionamento de carros com capacidade para 10
carros e que possua um porto somente para entrada e outro porto somente para sada de
carros nas extremidades do estacionamento. Nesse estacionamento, os carros so sempre
estacionados um na frente do outro. Assim, quanto um carro precisa ser retirado do
estacionamento e no for o carro mais prximo do porto de sada, todos os carros estacionados
na frente desse carro devem ser retirados at remover o carro que deve ser retirado e todos os
carros que estavam na frente devem voltar ao estacionamento para a mesma seqncia inicial,
mas devem entrar pelo porto de entrada do estacionamento. O algoritmo deve receber do
usurio a placa do carro e se o carro est entrando ou deixando o estacionamento. Se um carro
estiver entrando no estacionamento, mas este estiver lotado, o algoritmo deve enviar mensagem

142
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ao usurio avisando que ele no pode estacionar. Se um carro estiver saindo do estacionamento,
deve ser informado quantas vezes o carro foi manobrado para que outros carros atrs dele
fossem retirados. O algoritmo deve utilizar a estrutura de dados da fila.
27. Desenvolva um algoritmo que represente um estacionamento de carros com capacidade para 10
carros e que possua um nico porto para entrada no centro do estacionamento e dois portes de
sada de carros, um em cada extremidade. Dessa maneira, os carros so sempre estacionados
um na frente do outro direita ou esquerda do porto de entrada. Assim, o estacionamento tem
capacidade para estacionar 5 carros esquerda do porto de entrada e outros 5 carros direita
do porto de entrada. Quando um carro precisa ser retirado do estacionamento e no for o carro
mais prximo de um dos portes de sada, todos os carros estacionados na frente desse carro
devem ser retirados e, aps remover o carro que deve ser retirado, todos os carros que estavam
na frente devem voltar ao estacionamento para a mesma seqncia inicial mas devem entrar pelo
porto de entrada do estacionamento. O primeiro carro a entrar no estacionamento deve
estacionar esquerda do porto de entrada; o segundo carro a entrar deve estacionar direita do
porto de entrada; o terceiro carro esquerda; o quarto carro direita e assim por diante, sempre
intercalando. Se um carro estiver entrando no estacionamento, mas este estiver lotado, o
algoritmo deve enviar mensagem ao usurio avisando que ele no pode estacionar. Se um carro
estiver saindo do estacionamento, deve ser informado quantas vezes o carro foi manobrado para
que outros carros atrs dele fossem retirados. O algoritmo deve utilizar um nico vetor e a
estrutura de dados da fila.

28. Desenvolva um algoritmo que recebe o nmero de uma conta corrente sem o dgito verificador e
armazena os dgitos desse nmero numa fila. Com o auxlio de uma pilha, calcule o dgito
verificador desta conta corrente, armazenando o resultado na mesma fila. Mostrar o nmero da
conta corrente com o dgito verificador. Para calcular o dgito verificador da conta corrente, some
o nmero da conta corrente com o seu reverso. Depois multiplique cada dgito por sua ordem
posicional e somar este resultado. O ltimo dgito deste resultado o dgito verificador da conta.
Por exemplo, considere a seguinte conta corrente: 25678
* o reverso deste nmero 87652;
* somar nmero da conta com seu reverso: 25678 + 87652 = 113330;
* multiplicar cada dgito por sua ordem posicional e somar este resultado:
posio

nmero

* soma = 1 * 1 + 2 * 1 + 3 * 3 + 4 * 3 + 5 * 3 + 6 * 0 = 39
* o ltimo dgito de 39 o dgito verificador da conta corrente, ou seja, 9
Logo, a conta corrente : 25678-9

29. Desenvolva um algoritmo que recebe o nmero de um CPF com 9 dgitos e sem os dgitos
verificadores e armazena os dgitos desse nmero numa fila chamada CPF e de capacidade para
11 elementos. Com o auxlio de outra fila, calcula os dois dgitos verificadores e enfileira na
mesma fila CPF. Mostrar os elementos da fila com o nmero do CPF e os dgitos verificadores.
Para calcular os dgitos verificadores de um CPF, utilize a seguinte frmula:

143
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

total1 =

(numi * (11 i))

i=1

resto1 = resto da diviso de total1 por 11


se resto1 for igual a 0 ou igual a 1 ento dig1 = 0 seno dig1 = 11 resto1
10

total2 =

(numi * (12 i))

i=1

resto2 = resto da diviso de total2 por 11


se resto2 for igual a 0 ou igual a 1 ento dig2 = 0 seno dig2 = 11 resto2
Por exemplo, considere o seguinte CPF 111.222.333

num

total1 = 1 * 10 + 1 * 9 + 1 * 8 + 2 * 7 + 2 * 6 + 2 * 5 + 3 * 4 + 3 * 3 + 3 * 2 = 90
resto1 = 90 mod 11 = 2
como 2 diferente de 0 e 1, ento dig1 = 11 2 = 9

10

num

total2 = 1 * 11 + 1 * 10 + 1 * 9 + 2 * 8 + 2 * 7 + 2 * 6 + 3 * 5 + 3 * 4 + 3 * 3 + 9 * 2 = 126
resto2 = 126 mod 11 = 5
como 5 diferente de 0 e 1, ento dig2 = 11 5 = 6
Logo, o CPF completo : 111.222.333-96

30. Desenvolva um algoritmo que recebe 10 anos e enfileira numa fila os anos que so bissextos e
numa outra fila os anos que no so bissextos. Mostrar os elementos das duas filas. Para saber
se um ano bissexto basta satisfazer um dos seguintes itens:

ano divisvel por 4 e no divisvel por 100.


ano divisvel por 400

144
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

8. Estrutura de Lista Ligada

Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos


estruturar as informaes de diferentes tipos de dados que podemos utilizar no programa. Para
isso, podemos utilizar a estrutura de dados chamada Lista Ligada para estruturar essas
informaes ao programa inserindo, removendo e consultando informaes.
A vantagem da Lista Ligada em relao a outras estruturas de dados que j estudamos, como
vetores utilizados nas pilhas e filas, est na memria que utilizada. Quando utilizamos um vetor
para armazenar dados, a alocao de memria sempre feita na declarao do vetor e utilizada
ou no no meio do algoritmo. No entanto, quando utilizamos uma lista ligada para armazenar
dados, a alocao de memria feita no momento em que o dado ser inserido, ou seja, no
alocando memria que pode no ser utilizada, como o caso do vetor.
As listas ligadas podem ser desenvolvidas para pilhas e filas de dados e, por isso, sua aplicao
se estende para todas aquelas apresentadas no incio do captulo de pilhas e filas.
A lista ligada uma das estruturas de dados muito utilizada na cincia da computao para a
programao. Neste captulo, veremos como e quando trabalhar com listas ligadas, bem como
inserir, remover, consultar e manipular dados com lista ligada.

8.1. Definio de Lista Ligada


A lista ligada uma estrutura de dados utilizada na programao de computadores que se dispe
em forma de lista linear, ou seja, um elemento est seguido do outro elemento e assim por diante
para todos os elementos da lista ligada.
Numa lista ligada, os elementos so dispostos de uma forma que cada elemento tenha uma
ligao com o prximo elemento da lista ligada. Assim, os elementos no esto armazenados
seqencialmente de forma fsica, na ordem dos endereos que os elementos ocupam na
memria, como acontece com os vetores. Com a lista ligada, os elementos esto armazenados
de forma lgica e a seqncia das ligaes que determina a ordem dos elementos.
Para exemplificar a lista ligada, podemos pensar tanto nas filas de um banco, exemplificado no
captulo de filas, como na pilha de bandejas, como exemplificado no captulo de pilhas, pois
podemos representar tanto a pilha como a fila numa lista ligada.

8.2. Exemplo de Lista Ligada


Para exemplificar o funcionamento de lista ligada, vamos representar uma lista ligada de letras.
Inicialmente esta lista ligada est vazia, ou seja, no existem elementos na lista ligada. Portanto,
o primeiro e o ltimo elemento desta lista ligada so nulos, conforme mostra a figura abaixo:
primeiro

nulo

ltimo

145
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Vamos, ento, inserir a letra A na lista ligada, em seguida inserir a letra B e, depois, a letra C,
conforme a seqncia abaixo. Perceba que o tamanho da lista ligada muda a cada letra que
inserida:
A

prximo

prximo

prximo

primeiro

nulo

ltimo

Se quisermos remover um elemento da lista ligada, podemos remover qualquer elemento que
esteja na lista ligada. Vamos, por exemplo, remover a letra B, observando-se a figura abaixo:
A

prximo

prximo

primeiro

nulo

ltimo

8.3. Operaes de Lista Ligada


Pensando no funcionamento da lista ligada, conforme exemplificado nas sees 8.1. e 8.2.,
podemos definir algumas operaes utilizadas na estrutura de dados da lista ligada:

inserir no incio - a operao de inserir no incio insere um elemento no incio da lista;


inserir no final - a operao de inserir no final insere um elemento no final da lista;
inserir no meio - a operao de inserir no meio insere um elemento no meio da lista;
lista vazia - a operao lista vazia verifica se a lista est vazia;
elemento do incio - a operao elemento do incio mostra o elemento que est no incio da
lista;

elemento do final - a operao elemento do final mostra o elemento que est no final da lista;
remover - a operao remove elimina um elemento que est na lista ligada;
contar ns - a operao contar ns verifica quantos elementos existem na lista ligada;
mostrar lista - a operao que exibe todos os elementos que a lista possui;
buscar - a operao que verifica se determinado elemento pertence lista;
destruir - a operao destruir elimina todos os elementos da lista ligada.
Para as operaes de lista ligada codificadas em pseudocdigo e em java, nesta seo,
consideraremos uma lista ligada que possa receber elementos do tipo numrico inteiro. No
entanto, possvel codificar essas operaes para quaisquer tipos de dados j estudados at
ento. Veremos outros exemplos que utilizam operaes de lista ligada, definidas com outros
tipos de dados, nos exemplos deste captulo.

146
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

8.3.1. Operaes de Lista Ligada em Pseudocgido


Para as operaes de lista ligada em pseudocdigo, utilizaremos as seguintes definies de
registro:
// definio do tipo registro No com os campos abaixo
tipo No = registro
elemento 0 numrico_inteiro; // campo que armazena o elemento
prox nulo No; // campo que armazena o endereo do prximo n
fimregistro;
Onde o campo elemento armazena o elemento e o campo prox o ponteiro que armazena o
endereo do prximo n que contm o prximo elemento da lista ligada.

// definio do tipo registro ListaLigada com os campos abaixo


tipo ListaLigada = registro // o tipo registro chama-se ListaLigada
primeiro nulo No; // campo primeiro que armazena o primeiro elemento da lista
ultimo nulo No; // campo ultimo que armazena o ltimo elemento da lista ligada
fimregistro;
Onde o campo primeiro um ponteiro que armazena o endereo do primeiro elemento da
listaligada e o campo ltimo um ponteiro armazena o endereo do ltimo elemento da lista
ligada.

ListaVazia um mdulo funo sem parmetros da operao lista vazia que retorna verdadeiro se
a lista estiver vazia e retorna falso se a lista no estiver vazia.
lgico ListaVazia( )
incio_mdulo
se (primeiro = nulo e ultimo = nulo)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;

147
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

InserirInicio um mdulo procedimento da operao inserir no incio que recebe como parmetro
um elemento do tipo No a ser inserido. Esse mdulo insere este elemento no incio da lista ligada.
InserirInicio (novoNo No)
incio_mdulo
se (ListaVazia())
ento
ultimo novoNo;
seno
novoNo.prox primeiro;
fimse;
primeiro novoNo;
fim_mdulo;
InserirFinal um mdulo procedimento da operao inserir no final que recebe como parmetro
um elemento do tipo No a ser inserido. Esse mdulo insere este elemento no final da lista ligada.
InserirFinal (novoNo No)
incio_mdulo
se (ListaVazia())
ento
primeiro novoNo;
seno
ultimo.prox novoNo;
fimse;
ultimo novoNo;
fim_mdulo;

ContarNos um mdulo funo que utilizado na operao inserir no final que verificar. Esse
mdulo retorna quantos elementos possui a lista ligada.
numrico_inteiro ContarNos( )
incio_mdulo
Declarar
tamanho 0 numrico_inteiro;
NoTemp primeiro No;

148
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

enquanto (NoTemp <> nulo) faa


tamanho tamanho + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar tamanho;
fim_mdulo;
InserirMeio um mdulo procedimento da operao inserir no final, que recebe como parmetro
um elemento do tipo No a ser inserido e a posio onde o elemento deve ser inserido. A partir
disso, esse mdulo insere este elemento no meio da lista ligada.
InserirMeio(NovoNo No, posicao numrico_inteiro)
incio_mdulo
Declarar
NoTemp primeiro No;
NroNos, PosAux 1 numrico_inteiro;
NroNos ContarNos( );
se (posicao <= 1)
ento
InserirInicio(NovoNo);
seno
se (posicao > NroNos)
ento
InserirFinal(NovoNo);
seno
enquanto (posAux > (posicao 1))
NoTemp NoTemp.prox;
posAux posAux + 1;
fimenquanto;
NovoNo.prox NoTemp.prox;
NoTemp.prox NovoNo;
fimse;
fimse;
fim_mdulo;

149
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Remover um mdulo procedimento que recebe o elemento a ser removido da operao remover
e no faz nada se o elemento no existe ou se a lista ligada estiver vazia. Caso contrrio, esse
mdulo remove o elemento da lista ligada.
Remover (elemento numrico_inteiro)
incio_mdulo
Declarar
NoTemp primeiro No;
NoAnt nulo No;
se (primeiro.elemento = elemento)
ento
primeiro primeiro.prox;
seno
enquanto (NoTemp <> nulo e NoTemp.elemento <> elemento)
NoAnt NoTemp;
NoTemp NoTemp.prox;
fimenquanto;
se (NoTemp <> nulo)
ento
NoAnt.prox NoTemp.prox;
fimse;
se (NoTemp = ultimo)
ento
ultimo NoAnt;
fimse;
fimse;
fim_mdulo;

ElementoInicio um mdulo procedimento da operao elemento do incio que mostra ao usurio


o primeiro elemento que est na lista ligada.
ElementoInicio( )
incio_mdulo
se (no ListaVazia())
ento
escrever (O primeiro elemento da lista ligada , primeiro.elemento);

150
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

seno
escrever (Lista Ligada vazia);
fimse;
fim_mdulo;

ElementoFinal um mdulo procedimento da operao elemento do final que mostra ao usurio o


ltimo elemento que est na lista ligada.
ElementoFinal( )
incio_mdulo
se (no ListaVazia())
ento
escrever (O ltimo elemento da lista ligada , ultimo.elemento);
seno
escrever (Lista Ligada vazia);
fimse;
fim_mdulo;

BuscaNo um mdulo funo que recebe o elemento a ser pesquisado da operao buscar e
retorna o n cujo elemento foi pesquisado.
No BuscaNo (elemento numrico_inteiro)
incio_mdulo
Declarar
i 1 numrico_inteiro;
NoTemp primeiro No;
enquanto (NoTemp <> nulo) faa
se (NoTemp.elemento = elemento)
ento
escrever ("No " , NoTemp.elemento , " posio " , i);
retornar NoTemp;
fimse;
i i + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar nulo;

151
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fim_mdulo;
MostraLista um mdulo procedimento da operao mostra lista ligada, que mostra ao usurio
todos os elementos da lista ligada.
MostrarLista( )
incio_mdulo
Declarar
NoTemp primeiro No;
i 1 numrico_inteiro;
enquanto (NoTemp <> nulo) faa
escrever ("Elemento " , NoTemp.elemento , " posio " , i));
NoTemp NoTemp.prox;
i i + 1;
fimenquanto;
fim_mdulo;

8.3.2. Operaes de Lista Ligada em Java


Para as operaes de lista ligada em Java, utilizaremos as seguintes definies de registro numa
classe com o construtor do n e numa classe com o construtur da lista ligada e com as operaes
de fila:
class No
{
int elemento;
No prox;
No (int elem)
{
elemento = elem;
prox = null;
}
}
Onde o campo elemento armazena o elemento e o campo prox o ponteiro que armazena o
endereo do prximo n que contm o prximo elemento da lista ligada.
class ListaLigada
{
No primeiro, ultimo;
ListaLigada ()
152
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
primeiro = null;
ultimo = null;
}
// as operaes de lista ligada aparecem aqui
}
Onde o campo primeiro um ponteiro que armazena o endereo do primeiro elemento da
listaligada e o campo ltimo um ponteiro armazena o endereo do ltimo elemento da lista
ligada.

ListaVazia um mdulo funo sem parmetros da operao lista vazia, que retorna verdadeiro
se a lista estiver vazia e retorna falso se a lista no estiver vazia.
public boolean ListaVazia( )
{
if (primeiro == null && ultimo == null)
{
return true;
}
else
{
return false;
}
}
InserirInicio um mdulo procedimento da operao inserir no incio, que recebe como parmetro
um elemento do tipo No a ser inserido e insere este elemento no incio da lista ligada.
public void InserirInicio (No novoNo)
{
if (ListaVazia())
{
ultimo = novoNo;
}
else
{
novoNo.prox = primeiro;
}
primeiro = novoNo;
}

InserirFinal um mdulo procedimento da operao inserir no final, que recebe como parmetro
um elemento do tipo No a ser inserido e insere este elemento no final da lista ligada.
public void InserirFinal (No novoNo)
{
if (ListaVazia())

153
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
primeiro = novoNo;
}
else
{
ultimo.prox = novoNo;
}
ultimo = novoNo;
}

ContarNos um mdulo funo que utilizado na operao inserir no final, que verificar e retorna
quantos elementos possui a lista ligada.
public int ContarNos ( )
{
int tamanho = o;
No NoTemp = primeiro;
while (NoTempo != null)
{
tamanho = tamanho + 1;
NoTemp = NoTemp.prox;
}
return tamanho;
}
InserirMeio um mdulo procedimento da operao inserir no final, que recebe como parmetro
um elemento do tipo No a ser inserido e a posio onde o elemento deve ser inserido. A partir
disso, esse mdulo insere este elemento no meio da lista ligada.
public void InserirMeio(No NovoNo, int posicao)
{
No NoTemp = primeiro;
int NroNos, posAux = 1;
NroNos = ContarNos( );
if (posicao <= 1)
{
InserirInicio(NovoNo);
}
else
{
if (posicao > NroNos)
{
InserirFinal(NovoNo);

154
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

}
else
{
while (posAux < (posicao 1))
{
NoTemp = NoTemp.prox;
posAux = posAux + 1;
}
NovoNo.prox = NoTemp.prox;
NoTemp.prox = NovoNo;
}
}
}

Remover um mdulo procedimento que recebe o elemento a ser removido da operao remover
e no faz nada se o elemento no existe ou se a lista ligada estiver vazia. Caso contrrio, remove
o elemento da lista ligada.
public void Remover (int elemento)
{
No NoTemp = primeiro;
No NoAnt = null;
if (primeiro.elemento == elemento)
{
primeiro = primeiro.prox;
}
else
{
while (NoTemp != null && NoTemp.elemento != elemento)
{
NoAnt = NoTemp;
NoTemp = NoTemp.prox;
}
if(NoTemp != null)
{
NoAnt.prox = NoTemp.prox;
}
if (NoTemp == ultimo)
{
ultimo = NoAnt;
}
}
}

155
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ElementoInicio um mdulo procedimento da operao elemento do incio, que mostra ao usurio


o primeiro elemento que est na lista ligada.
public void ElementoInicio( )
{
if (! ListaVazia())
{
System.out.println("O primeiro elemento " +
primeiro.elemento);
}
else
{
System.out.println("Lista Ligada Vazia");
}
}

ElementoFinal um mdulo procedimento da operao elemento do final, que mostra ao usurio


o ltimo elemento que est na lista ligada.
public void ElementoFinal( )
{
if (! ListaVazia())
{
System.out.println("O ltimo elemento " +
ultimo.elemento);
}
else
{
System.out.println("Lista Ligada Vazia");
}
}

BuscaNo um mdulo funo que recebe o elemento a ser pesquisado da operao buscar e
retorna o n cujo elemento foi pesquisado.
public No BuscaNo (int elemento)
{
int i = 1;
No NoTempo = primeiro;
while (NoTemp != null)
{
if (NoTemp.elemento == elemento)
{
System.out.println("No " + NoTemp.elemento + " posio "
+ i);
return NoTemp;
}
i = i + 1;
156
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

NoTemp = NoTemp.prox;
}
return null;
}
MostraLista um mdulo procedimento da operao mostra lista ligada, que mostra ao usurio
todos os elementos da lista ligada.
public void MostrarLista( )
{
int i = 1;
No NoTemp = primeiro;
while (NoTemp != null)
{
System.out.println("Elemento " + NoTemp.elemento + " posio "
+ i);
NoTemp = NoTemp.prox;
i = i + 1;
}
}

8.4. Representao do Funcionamento das Operaes de Lista Ligada


Nesta seo, vamos representar o funcionamento das operaes de lista ligada descritas na
seo anterior. Para isso, vamos inserir, remover e mostrar o contedo de uma lista ligada de
letras, considerando-se que, inicialmente, a lista ligada est vazia:
primeiro

nulo

ltimo

InserirInicio(43);
insere o elemento 43 no incio da lista ligada.
43

nulo

prximo

primeiro

ltimo

157
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

InserirFinal(89);
insere o elemento 89 no final da lista ligada.
43

89

prximo

prximo

primeiro

ltimo

nulo

ElementoInicio( );
mostra o elemento 43 que est no incio da lista ligada e a lista ligada fica inalterada:
43

89

prximo

prximo

primeiro

ltimo

nulo

InserirMeio(55,2);
insere o elemento 55 no meio da lista ligada, na posio 2.

43

55

89

prximo

prximo

prximo

primeiro

nulo

ltimo

ContarNos( );
verifica quantos elementos a lista ligada possui, retornando o valor 3 e a lista ligada fica
inalterada.

43

55

89

prximo

prximo

prximo

primeiro

ltimo

158
Copyright Faculdade IBTA

nulo

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Remover(55);
remove e retorna o elemento 55 que um elemento da lista ligada.
43

89

prximo

prximo

primeiro

ltimo

nulo

ElementoFinal( )
mostra o elemento 89 que est no final da lista e a lista fica inalterada:

43

89

prximo

prximo

primeiro

ltimo

nulo

Remover(43)
remove e retorna o elemento 43, que um elemento da lista ligada.
89

nulo

prximo

primeiro

ltimo

Remover(19)
como a lista ligada no possui n com elemento 19, no remove elemento da lista ligada e esta
permanece inalterada.
89

nulo

prximo

primeiro

ltimo

Remover(89)
remove e retorna o elemento 89, que um elemento da lista ligada.
primeiro

nulo

ltimo

159
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ElementoInicio( )
como a lista ligada est vazia, mostra a mensagem "lista ligada vazia" e a lista ligada fica
inalterada.
primeiro

nulo

ltimo

8.5. Exemplo de Lista Ligada em Pseudocdigo


1. Desenvolva um algoritmo que recebe do usurio cinco nmeros inteiros numa lista ligada e
mostra esses nmeros.
Algoritmo No
incio_algoritmo
tipo No = registro
elemento 0 numrico_real;
prox nulo No;
fimregistro;
fimalgoritmo.
Algoritmo ListaLigada
incio_algoritmo
// definio do tipo registro ListaLigada com os campos abaixo
tipo ListaLigada = registro // o tipo registro chama-se ListaLigada
primeiro nulo No;
ultimo nulo No;
fimregistro;
lgico ListaVazia( )
incio_mdulo
se (primeiro = nulo e ultimo = nulo)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;

160
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

InserirInicio (novoNo No)


incio_mdulo
se (ListaVazia())
ento
ultimo novoNo;
seno
novoNo.prox primeiro;
fimse;
primeiro novoNo;
fim_mdulo;
InserirFinal (novoNo No)
incio_mdulo
se (ListaVazia())
ento
primeiro novoNo;
seno
ultimo.prox novoNo;
fimse;
ultimo novoNo;
fim_mdulo;

numrico_inteiro ContarNos( )
incio_mdulo
Declarar
tamanho 0 numrico_inteiro;
NoTemp primeiro No;
enquanto (NoTemp <> nulo) faa
tamanho tamanho + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar tamanho;
fim_mdulo;

161
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

InserirMeio(NovoNo No, posicao numrico_inteiro)


incio_mdulo
Declarar
NoTemp primeiro No;
NroNos, posAux 1 numrico_inteiro;
NroNos ContarNos( );
se (posicao <= 1)
ento
InserirInicio(NovoNo);
seno
se (posicao > NroNos)
ento
InserirFinal(NovoNo);
seno
enquanto (posAux > (posicao 1))
NoTemp NoTemp.prox;
posAux posAux + 1;
fimenquanto;
NovoNo.prox NoTemp.prox;
NoTemp.prox NovoNo;
fimse;
fimse;
fim_mdulo;
Remover (elemento numrico_real)
incio_mdulo
Declarar
NoTemp primeiro No;
NoAnt nulo No;
se (primeiro.elemento = elemento)
ento
primeiro primeiro.prox;
seno
enquanto (NoTemp <> nulo e NoTemp.elemento <> elemento)
162
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

NoAnt NoTemp;
NoTemp NoTemp.prox;
fimenquanto;
se (NoTemp <> nulo)
ento
NoAnt.prox NoTemp.prox;
fimse;
se (NoTemp = ultimo)
ento
ultimo NoAnt;
fimse;
fimse;
fim_mdulo;
ElementoInicio( )
incio_mdulo
se (no ListaVazia())
ento
escrever (O primeiro elemento da lista ligada , primeiro.elemento);
seno
escrever (Lista Ligada vazia);
fimse;
fim_mdulo;
ElementoFinal( )
incio_mdulo
se (no ListaVazia())
ento
escrever (O ltimo elemento da lista ligada , ultimo.elemento);
seno
escrever (Lista Ligada vazia);
fimse;
fim_mdulo;
No BuscaNo (elemento numrico_real)
incio_mdulo

163
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Declarar
i 1 numrico_inteiro;
NoTemp primeiro No;
enquanto (NoTemp <> nulo) faa
se (NoTemp.elemento = elemento)
ento
escrever (No , NoTemp.elemento , posio , i);
retornar NoTemp;
fimse;
i i + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar nulo;
fim_mdulo;
MostrarLista( )
incio_mdulo
Declarar
NoTemp primeiro No;
i 1 numrico_inteiro;
enquanto (NoTemp <> nulo) faa
escrever (Elemento , NoTemp.elemento , posio , i));
NoTemp NoTemp.prox;
i i + 1;
fimenquanto;
fim_mdulo;
fimalgoritmo.
Algoritmo Exemplo1
incio_algoritmo
Declarar
realLista = novo ListaLigada();
i numrico_inteiro;
num numrico_real;

164
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

para i de 1 at 5 passo + 1 faa


ler(num);
realLista.InserirFinal(novo No(num));
fimpara;
realLista.MostrarLista();
fim_algoritmo.

2. Desenvolva um algoritmo que receba cinco nmeros inteiros em qualquer ordem e mostre
esses nmeros ordenados numa estrutura de lista ligada.
Algoritmo No
incio_algoritmo
tipo No = registro
elemento 0 alfanumrico;
prox nulo No;
fimregistro;
fimalgoritmo.
Algoritmo ListaLigada
incio_algoritmo
// definio do tipo registro ListaLigada com os campos abaixo
tipo ListaLigada = registro // o tipo registro chama-se ListaLigada
primeiro nulo No;
ultimo nulo No;
fimregistro;
lgico ListaVazia( )
incio_mdulo
se (primeiro = nulo e ultimo = nulo)
ento
retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;

165
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

InserirInicio (novoNo No)


incio_mdulo
se (ListaVazia())
ento
ultimo novoNo;
seno
novoNo.prox primeiro;
fimse;
primeiro novoNo;
fim_mdulo;
InserirFinal (novoNo No)
incio_mdulo
se (ListaVazia())
ento
primeiro novoNo;
seno
ultimo.prox novoNo;
fimse;
ultimo novoNo;
fim_mdulo;
numrico_inteiro ContarNos( )
incio_mdulo
Declarar
tamanho 0 numrico_inteiro;
NoTemp primeiro No;
enquanto (NoTemp <> nulo) faa
tamanho tamanho + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar tamanho;
fim_mdulo;
InserirMeio(NovoNo No, posicao numrico_inteiro)
incio_mdulo

166
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Declarar
NoTemp primeiro No;
NroNos, posAux 1 numrico_inteiro;
NroNos ContarNos( );
se (posicao <= 1)
ento
InserirInicio(NovoNo);
seno
se (posicao > NroNos)
ento
InserirFinal(NovoNo);
seno
enquanto (posAux > (posicao 1))
NoTemp NoTemp.prox;
posAux posAux + 1;
fimenquanto;
NovoNo.prox NoTemp.prox;
NoTemp.prox NovoNo;
fimse;
fimse;
fim_mdulo;
Remover (elemento alfanumrico)
incio_mdulo
Declarar
NoTemp primeiro No;
NoAnt nulo No
se (primeiro.elemento = elemento)
ento
primeiro primeiro.prox;
seno
enquanto (NoTemp nulo e NoTemp.elemento elemento)
NoAnt NoTemp;
NoTemp NoTemp.prox;

167
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimenquanto;
se (NoTemp <> nulo)
ento
NoAnt.prox NoTemp.prox;
fimse;
se (NoTemp = ultimo)
ento
ultimo NoAnt;
fimse;
fimse;
fim_mdulo;
ElementoInicio( )
incio_mdulo
se (no ListaVazia())
ento
escrever (O primeiro elemento da lista ligada , primeiro.elemento);
seno
escrever (Lista Ligada vazia);
fimse;
fim_mdulo;
ElementoFinal( )
incio_mdulo
se (no ListaVazia())
ento
escrever (O ltimo elemento da lista ligada , ultimo.elemento);
seno
escrever (Lista Ligada vazia);
fimse;
fim_mdulo;
No BuscaNo (elemento alfanumrico)
incio_mdulo
Declarar
i 1 numrico_inteiro;
NoTemp primeiro No;
168
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

enquanto (NoTemp <> nulo) faa


se (NoTemp.elemento = elemento)
ento
escrever (No , NoTemp.elemento , posio , i);
retornar NoTemp;
fimse;
i i + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar nulo;
fim_mdulo;
MostrarLista( )
incio_mdulo
Declarar
NoTemp primeiro No;
i 1 numrico_inteiro;
enquanto (NoTemp <> nulo) faa
escrever (Elemento , NoTemp.elemento , posio , i));
NoTemp NoTemp.prox;
i i + 1;
fimenquanto;
fim_mdulo;
fimalgoritmo.
Algoritmo Exemplo2
incio_algoritmo
Declarar
alfaLista = novo ListaLigada();
i, pos numrico_inteiro;
num alfanumrico;
aux No;
para i de 1 at 5 passo + 1 faa
ler(num);
se (alfaLista.primeiro = nulo)
ento

169
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

alfaLista.InserirFinal(novo No(num));
else
aux alfaLista.primeiro;
pos 1;
enquanto ((aux <> nulo) e (num > aux.elemento)) faa
aux aux.prox;
pos pos + 1;
fimenquanto;
alfaLista.InserirMeio(novo No(num), pos);
fimse;
fimpara;
alfaLista.MostrarLista();
fim_algoritmo.

3. Desenvolva um algoritmo que receba 10 nmeros inteiros e armazena numa estrutura de lista
ligada somente os nmeros divisveis por trs. Mostre todos os elementos da lista ligada.
Algoritmo No
incio_algoritmo
tipo No = registro
elemento 0 numrico_inteiro;
prox nulo No;
fimregistro;
fimalgoritmo.
Algoritmo ListaLigada
incio_algoritmo
// definio do tipo registro ListaLigada com os campos abaixo
tipo ListaLigada = registro // o tipo registro chama-se ListaLigada
primeiro nulo No;
ultimo nulo No;
fimregistro;
lgico ListaVazia( )
incio_mdulo
se (primeiro = nulo e ultimo = nulo)
ento

170
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

retornar verdadeiro;
seno
retornar falso;
fimse;
fim_mdulo;
InserirInicio (novoNo No)
incio_mdulo
se (ListaVazia())
ento
ultimo novoNo;
seno
novoNo.prox primeiro;
fimse;
primeiro novoNo;
fim_mdulo;
InserirFinal (novoNo No)
incio_mdulo
se (ListaVazia())
ento
primeiro novoNo;
seno
ultimo.prox novoNo;
fimse;
ultimo novoNo;
fim_mdulo;
numrico_inteiro ContarNos( )
incio_mdulo
Declarar
tamanho 0 numrico_inteiro;
NoTemp primeiro No;
enquanto (NoTemp <> nulo) faa
tamanho tamanho + 1;
NoTemp NoTemp.prox;

171
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimenquanto;
retornar tamanho;
fim_mdulo;
InserirMeio(NovoNo No, posicao numrico_inteiro)
incio_mdulo
Declarar
NoTemp primeiro No;
NroNos, posAux 1 numrico_inteiro;
NroNos ContarNos( );
se (posicao <= 1)
ento
InserirInicio(NovoNo);
seno
se (posicao > NroNos)
ento
InserirFinal(NovoNo);
seno
enquanto (posAux > (posicao 1))
NoTemp NoTemp.prox;
posAux posAux + 1;
fimenquanto;
NovoNo.prox NoTemp.prox;
NoTemp.prox NovoNo;
fimse;
fimse;
fim_mdulo;
Remover (elemento numrico_inteiro)
incio_mdulo
Declarar
NoTemp primeiro No;
NoAnt nulo No;
se (primeiro.elemento = elemento)
ento

172
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

primeiro primeiro.prox;
seno
enquanto (NoTemp <> nulo e NoTemp.elemento elemento)
NoAnt NoTemp;
NoTemp NoTemp.prox;
fimenquanto;
se (NoTemp <> nulo)
ento
NoAnt.prox NoTemp.prox;
fimse;
se (NoTemp = ultimo)
ento
ultimo NoAnt;
fimse;
fimse;
fim_mdulo;
ElementoInicio( )
incio_mdulo
se (no ListaVazia())
ento
escrever (O primeiro elemento da lista ligada , primeiro.elemento);
seno
escrever (Lista Ligada vazia);
fimse;
fim_mdulo;
ElementoFinal( )
incio_mdulo
se (no ListaVazia())
ento
escrever (O ltimo elemento da lista ligada , ultimo.elemento);
seno
escrever (Lista Ligada vazia);
fimse;
fim_mdulo;

173
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

No BuscaNo (elemento numrico_inteiro)


incio_mdulo
Declarar
i 1 numrico_inteiro;
NoTemp primeiro No;
enquanto (NoTemp <> nulo) faa
se (NoTemp.elemento = elemento)
ento
escrever (No , NoTemp.elemento , posio , i);
retornar NoTemp;
fimse;
i i + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar nulo;
fim_mdulo;
MostrarLista( )
incio_mdulo
Declarar
NoTemp primeiro No;
i 1 numrico_inteiro;
enquanto (NoTemp <> nulo) faa
escrever (Elemento , NoTemp.elemento , posio , i));
NoTemp NoTemp.prox;
i i + 1;
fimenquanto;
fim_mdulo;
fimalgoritmo.
Algoritmo Exemplo3
incio_algoritmo
Declarar
intLista = novo ListaLigada();
i, num numrico_inteiro;

174
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

para i de 1 at 10 passo + 1 faa


ler(num);
se (num mod 3 = 0)
ento
intLista.InserirFinal(novo No(num));
fimse;
fimpara;
intLista.MostrarLista();
fim_algoritmo.

8.6. Exemplo de Lista Ligada em Java


1. Desenvolva um algoritmo que recebe do usurio cinco nmeros inteiros numa lista ligada e
mostra esses nmeros.
import javax.swing.*;
class No
{
double elemento;
No prox;
No (double elem)
{
elemento = elem;
prox = null;
}
}
class ListaLigada
{
No primeiro, ultimo;
ListaLigada ()
{
primeiro = null;
ultimo = null;
}
public boolean ListaVazia( )
{
if (primeiro == null && ultimo == null)
{
return true;
}
else
175
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
return false;
}
}
public void InserirInicio (No novoNo)
{
if (ListaVazia())
{
ultimo = novoNo;
}
else
{
novoNo.prox = primeiro;
}
primeiro = novoNo;
}
public void InserirFinal (No novoNo)
{
if (ListaVazia())
{
primeiro = novoNo;
}
else
{
ultimo.prox = novoNo;
}
ultimo = novoNo;
}
public int ContarNos ( )
{
int tamanho = 0;
No NoTemp = primeiro;
while (NoTemp != null)
{
tamanho = tamanho + 1;
NoTemp = NoTemp.prox;
}
return tamanho;
}
public void InserirMeio(No NovoNo, int posicao)
{
No NoTemp = primeiro;
int NroNos, posAux = 1;
NroNos = ContarNos( );
176
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

if (posicao <= 1)
{
InserirInicio(NovoNo);
}
else
{
if (posicao > NroNos)
{
InserirFinal(NovoNo);
}
else
{
while (posAux < (posicao 1))
{
NoTemp = NoTemp.prox;
posAux = posAux + 1;
}
NovoNo.prox = NoTemp.prox;
NoTemp.prox = NovoNo;
}
}
}
public void Remover (double elemento)
{
No NoTemp = primeiro;
No NoAnt = null;
if (primeiro.elemento == elemento)
{
primeiro = primeiro.prox;
}
else
{
while (NoTemp != null && NoTemp.elemento != elemento)
{
NoAnt = NoTemp;
NoTemp = NoTemp.prox;
}
if(NoTemp != null)
{
NoAnt.prox = NoTemp.prox;
}
if (NoTemp == ultimo)
{
ultimo = NoAnt;
}
}
}
177
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public void ElementoInicio( )


{
if (! ListaVazia())
{
System.out.println("O primeiro elemento " +
primeiro.elemento);
}
else
{
System.out.println("Lista Ligada Vazia");
}
}
public void ElementoFinal( )
{
if (! ListaVazia())
{
System.out.println("O ltimo elemento "+
ultimo.elemento);
}
else
{
System.out.println("Lista Ligada Vazia");
}
}
public No BuscarNo (double elemento)
{
int i = 1;
No NoTemp = primeiro;
while (NoTemp != null)
{
if (NoTemp.elemento == elemento)
{
System.out.println("No " + NoTemp.elemento + " posio "
+ i);
return NoTemp;
}
i = i + 1;
NoTemp = NoTemp.prox;
}
return null;
}
public void MostrarLista( )
{
int i = 1;
No NoTemp = primeiro;

178
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

while (NoTemp != null)


{
System.out.println("Elemento " + NoTemp.elemento + " posio
" + i);
NoTemp = NoTemp.prox;
i = i + 1;
}
}
}
class Exemplo1
{
public static void main (String arg [])
{
ListaLigada realLista = new ListaLigada();
int i;
double num;
for (i = 1 ; i <= 5 ; i++)
{
num = Double.parseDouble(JOptionPane.showInputDialog(
"digite um nmero real"));
realLista.InserirFinal(new No(num));
}
realLista.MostrarLista();
System.exit(0);
}
}

2. Desenvolva um algoritmo que receba cinco nmeros inteiros em qualquer ordem e mostre
esses nmeros ordenados numa estrutura de lista ligada.
import javax.swing.*;
class No
{
char elemento;
No prox;
No (char elem)
{
elemento = elem;
prox = null;
}
}
class ListaLigada
{
No primeiro, ultimo;
179
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ListaLigada ()
{
primeiro = null;
ultimo = null;
}
public boolean ListaVazia( )
{
if (primeiro == null && ultimo == null)
{
return true;
}
else
{
return false;
}
}
public void InserirInicio (No novoNo)
{
if (ListaVazia())
{
ultimo = novoNo;
}
else
{
novoNo.prox = primeiro;
}
primeiro = novoNo;
}
public void InserirFinal (No novoNo)
{
if (ListaVazia())
{
primeiro = novoNo;
}
else
{
ultimo.prox = novoNo;
}
ultimo = novoNo;
}
public int ContarNos ( )
{
int tamanho = 0;
No NoTemp = primeiro;

180
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

while (NoTemp != null)


{
tamanho = tamanho + 1;
NoTemp = NoTemp.prox;
}
return tamanho;
}
public void InserirMeio(No NovoNo, int posicao)
{
No NoTemp = primeiro;
int NroNos, posAux = 1;
NroNos = ContarNos( );
if (posicao <= 1)
{
InserirInicio(NovoNo);
}
else
{
if (posicao > NroNos)
{
InserirFinal(NovoNo);
}
else
{
while (posAux < (posicao 1))
{
NoTemp = NoTemp.prox;
posAux = posAux + 1;
}
NovoNo.prox = NoTemp.prox;
NoTemp.prox = NovoNo;
}
}
}
public void Remover (char elemento)
{
No NoTemp = primeiro;
No NoAnt = null;
if (primeiro.elemento == elemento)
{
primeiro = primeiro.prox;
}
else
{
while (NoTemp != null && NoTemp.elemento != elemento)
181
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
NoAnt = NoTemp;
NoTemp = NoTemp.prox;
}
if(NoTemp != null)
{
NoAnt.prox = NoTemp.prox;
}
if (NoTemp == ultimo)
{
ultimo = NoAnt;
}
}
}
public void ElementoInicio( )
{
if (! ListaVazia())
{
System.out.println("O primeiro elemento " +
primeiro.elemento);
}
else
{
System.out.println("Lista Ligada Vazia");
}
}
public void ElementoFinal( )
{
if (! ListaVazia())
{
System.out.println("O ltimo elemento " +
ultimo.elemento);
}
else
{
System.out.println("Lista Ligada Vazia");
}
}
public No BuscarNo (char elemento)
{
int i = 1;
No NoTemp = primeiro;
while (NoTemp != null)
{
if (NoTemp.elemento == elemento)

182
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
System.out.println("No " + NoTemp.elemento + " posio "
+ i);
return NoTemp;
}
i = i + 1;
NoTemp = NoTemp.prox;
}
return null;
}
public void MostrarLista( )
{
int i = 1;
No NoTemp = primeiro;
while (NoTemp != null)
{
System.out.println("Elemento " + NoTemp.elemento + " posio
" + i);
NoTemp = NoTemp.prox;
i = i + 1;
}
}
}
class Exemplo2
{
public static void main (String arg [])
{
ListaLigada alfaLista = new ListaLigada();
int i, pos;
char num;
No aux;
for (i = 1 ; i <= 5 ; i++)
{
num = (JOptionPane.showInputDialog("digite um nmero
inteiro")).charAt(0);
if (alfaLista.primeiro == null)
{
alfaLista.InserirFinal(new No(num));
}
else
{
aux = alfaLista.primeiro;
pos = 1;
while ((aux != null) && (num > aux.elemento))
{

183
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

aux = aux.prox;
pos = pos + 1;
}
alfaLista.InserirMeio(new No(num),pos);
}
}
alfaLista.MostrarLista();
System.exit(0);
}
}

3. Desenvolva um algoritmo que receba 10 nmeros inteiros e armazena numa estrutura de lista
ligada somente os nmeros divisveis por trs. Mostre todos os elementos da lista ligada.
import javax.swing.*;
class No
{
int elemento;
No prox;
No (int elem)
{
elemento = elem;
prox = null;
}
}
class ListaLigada
{
No primeiro, ultimo;
ListaLigada ()
{
primeiro = null;
ultimo = null;
}
public boolean ListaVazia( )
{
if (primeiro == null && ultimo == null)
{
return true;
}
else
{
return false;
}
}
184
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public void InserirInicio (No novoNo)


{
if (ListaVazia())
{
ultimo = novoNo;
}
else
{
novoNo.prox = primeiro;
}
primeiro = novoNo;
}
public void InserirFinal (No novoNo)
{
if (ListaVazia())
{
primeiro = novoNo;
}
else
{
ultimo.prox = novoNo;
}
ultimo = novoNo;
}
public int ContarNos ( )
{
int tamanho = 0;
No NoTemp = primeiro;
while (NoTemp != null)
{
tamanho = tamanho + 1;
NoTemp = NoTemp.prox;
}
return tamanho;
}
public void InserirMeio(No NovoNo, int posicao)
{
No NoTemp = primeiro;
int NroNos, posAux = 1;
NroNos = ContarNos( );
if (posicao <= 1)
{
InserirInicio(NovoNo);
}
185
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

else
{
if (posicao > NroNos)
{
InserirFinal(NovoNo);
}
else
{
while (posAux < (posicao 1))
{
NoTemp = NoTemp.prox;
posAux = posAux + 1;
}
NovoNo.prox = NoTemp.prox;
NoTemp.prox = NovoNo;
}
}
}
public void Remover (int elemento)
{
No NoTemp = primeiro;
No NoAnt = null;
if (primeiro.elemento == elemento)
{
primeiro = primeiro.prox;
}
else
{
while (NoTemp != null && NoTemp.elemento != elemento)
{
NoAnt = NoTemp;
NoTemp = NoTemp.prox;
}
if(NoTemp != null)
{
NoAnt.prox = NoTemp.prox;
}
if (NoTemp == ultimo)
{
ultimo = NoAnt;
}
}
}
public void ElementoInicio( )
{
if (! ListaVazia())
186
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
System.out.println("O primeiro elemento " +
primeiro.elemento);
}
else
{
System.out.println("Lista Ligada Vazia");
}
}
public void ElementoFinal( )
{
if (! ListaVazia())
{
System.out.println("O ltimo elemento " +
ultimo.elemento);
}
else
{
System.out.println("Lista Ligada Vazia");
}
}
public No BuscarNo (int elemento)
{
int i = 1;
No NoTemp = primeiro;
while (NoTemp != null)
{
if (NoTemp.elemento == elemento)
{
System.out.println("No " + NoTemp.elemento + " posio "
+ i);
return NoTemp;
}
i = i + 1;
NoTemp = NoTemp.prox;
}
return null;
}
public void MostrarLista( )
{
int i = 1;
No NoTemp = primeiro;
while (NoTemp != null)
{

187
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

System.out.println("Elemento " + NoTemp.elemento + " posio


" + i);
NoTemp = NoTemp.prox;
i = i + 1;
}
}
}
class Exemplo3
{
public static void main(String arg[])
{
ListaLigada intLista = new ListaLigada();
int i, num;
for (i = 1 ; i <= 10 ; i++)
{
num = Integer.parseInt(JOptionPane.showInputDialog("Digite
um nmero inteiro"));
if (num % 3 == 0)
{
intLista.InserirFinal(new No(num));
}
}
intLista.MostrarLista();
System.exit(0);
}
}

8.7. Exerccios de Lista Ligada


Os algoritmos abaixo devem ser desenvolvidos em pseudocdigo e com a utilizao da estrutura
de dados de lista ligada.
01. Desenhe a representao de lista ligada para a seguinte seqncia de operaes, considerando
que a lista ligada est inicialmente vazia:
a. ElementoInicio ( );
b. ElementoFinal( );
c. InserirInicio (3);
d. InserirFinal (7);
e. InserirMeio(5,2);
f. InserirMeio(4,2);
g. InserirMeio(6,4);
h. MostrarLista( );
188
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

i. Remover(3);
j. Remover (7);
k. Remover (25);
l. MostrarLista ( );
m. Remover (18);
02. Desenvolva um algoritmo que receba do usurio 10 nmeros inteiros em uma lista ligada simples
e inverta a ordem dos elementos desta lista ligada.
03. Desenvolva um algoritmo que receba do usurio cem nmeros inteiros e que construa uma lista
ligada apenas com os nmeros pares. O algoritmo deve mostrar os dez primeiros nmeros desta
lista ligada.
04. Desenvolva um algoritmo que receba do usurio uma conjunto de caracteres alfanumricos,
podendo ser uma frase ou uma palavra. Esse algoritmo deve, ainda, armazenar em uma estrutura
de lista ligada simples e mostrar esses caracteres de forma invertida.
05. Desenvolva um algoritmo que receba do usurio 50 caracteres e que construa uma lista ligada
apenas com as vogais. O Algoritmo deve mostrar os dez primeiros elementos desta lista ligada.
06. Desenvolva um algoritmo que receba do usurio 10 nmeros inteiros e que armazene numa lista
ligada simples na ordem numrica. O algoritmo deve colocar em ordem no momento da
construo da lista ligada.
07. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos e parnteses para isolar as operaes e que verifique se todos os
parnteses abertos foram fechados. Para isso, insira do final para o incio de uma lista ligada os '('
e quanto aparecer um ')', um '(' deve ser removido do incio da lista ligada. Ao final da expresso
matemtica, se todos os parnteses foram removidos ou se nenhum ')' sobrou sem remover um '('
da lista ligada, significa que a expresso matemtica est correta, caso contrrio, significa que a
expresso matemtica possui um erro.
08. Desenvolva um algoritmo que receba do usurio uma expresso matemtica com operadores
matemticos, operandos e parnteses para isolar as operaes matemticas e que verifique se a
expresso matemtica est correta, ou seja, se no aparece uma seqncia de operadores sem
operandos, ou uma seqncia de operandos sem operadores. Isso porque, numa operao
matemtica, os operandos e os operadores esto sempre se alternando de forma que a operao
matemtica inicia e termina com um operando e nunca com um operador. O algoritmo deve
utilizar a estrutura de dados de lista ligada.
09. Um sistema de numerao chama-se decimal quando sua base 10, ou seja, este sistema de
numerao possui 10 caracteres que o representam e que so: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Um
sistema de numerao chama-se binrio quando sua base 2, ou seja, este sistema possui 2
caracteres que o representam e que so: 0 e 1. Podemos representar um nmero decimal em
189
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

binrio por divises sucessivas desse nmero por 2 at que o quociente seja 0. O representante
binrio desse nmero ser composto por todos os restos, mas na ordem inversa que foram
calculados. Com base nessas informaes, desenvolva um algoritmo que receba do usurio um
nmero inteiro decimal e que mostre o seu correspondente em binrio. O algoritmo deve utilizar a
estrutura de dados de listas ligadas.
10. Um sistema de numerao chama-se hexadecimal quanto sua base 16, ou seja, este sistema
de numerao possui 16 caracteres que o representam e que so: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B,
C, D, E e F. Podemos representar um nmero decimal em hexadecimal por divises sucessivas
desse nmero por 16 at que o quociente seja 0. O representante hexadecimal desse nmero
ser composto por todos os restos, mas na ordem inversa que foram calculados. Quando o
resto for 10, dever ser considerado como A, quando for 11, considerado como B, quando for 12,
considerado como C, quando for 13, considerado como D, quando for 14, considerado como E e,
quando for 15, considerado como E. Com base nessas informaes, desenvolva um algoritmo
que receba do usurio um nmero inteiro decimal e que mostre o seu correspondente em
hexadecimal. O algoritmo deve utilizar a estrutura de dados de listas ligadas.
Considere a soma de dois nmeros X e Y. Podemos representar essa soma de trs formas
diferentes:

X + Y a forma mais conhecida, chamada de infixa, porque o operador + aparece entre os


operandos X e Y;

+ X Y, chamada de prefixa e utilizada na programao, porque o operador + aparece antes dos


dois operandos X e Y, mas calcula a soma corretamente e;

X Y +, chamada de posfixa e utilizada em calculadoras financeiras (por exemplo, a 12C),


porque o operador + aparece depois dos dois operandos X e Y, mas calcula a soma
corretamente.
Por exemplo:

5 3 2 + * : est representado na expresso posfixa e equivale a 5 * (3 + 2) na expresso infixa.


E a resposta desta expresso igual a 25.

- / 4 2 5 : est representado na expresso infixa e equivale a 4 / 2 - 5 na expresso posfixa.


Com base nessas informaes, resolva os exerccios 11, 12, 13, 14 e 15.
11. Desenvolva um algoritmo que receba do usurio uma expresso posfixa e que mostre o resultado
dessa expresso. O algoritmo deve utilizar as estruturas de dados de listas ligadas.
12. Desenvolva um algoritmo que receba do usurio uma expresso infixa e que mostre esta
expresso escrita na forma posfixa. O algoritmo deve utilizar as estruturas de dados de listas
ligadas.
13. Desenvolva um algoritmo que receba do usurio uma expresso posfixa e que mostre esta
expresso escrita na forma infixa. O algoritmo deve utilizar as estruturas de dados de listas
ligadas.

190
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

14. Desenvolva um algoritmo que receba do usurio uma expresso infixa e que mostre o resultado
dessa expresso. O algoritmo deve utilizar as estruturas de dados de listas ligadas.
15. Desenvolva um algoritmo que receba do usurio ma expresso infixa e que mostre o expresso
escrita na forma prefixa. O algoritmo deve utilizar as estrutura de dados de listas ligadas.
16. Desenvolva um algoritmo que receba dois conjuntos de caracteres A e B e que verifique se um
o inverso do outro. Se, por exemplo, um dos conjuntos de caracteres for ABBABAAB, o outro
conjunto de caracteres ser o inverso deste se for BAABABBA. Em cada ponto, o algoritmo deve
ler somente o prximo caractere do conjunto de caracteres. O algoritmo deve utilizar a estrutura
de dados de listas ligadas.
17. Desenvolva um algoritmo que represente um estacionamento de carros com capacidade para 10
carros e que possua um nico porto para entrada e sada de carros na extremidade do
estacionamento. Nesse estacionamento, os carros so sempre estacionados um na frente do
outro. Assim, quanto um carro precisa ser retirado do estacionamento e no for o carro mais
prximo do porto de sada, todos os carros estacionados na frente desse carro devem ser
retirados e aps remover o carro que deve ser retirado, todos os carros que estavam na frente
devem voltar ao estacionamento para a mesma seqncia inicial. O algoritmo deve receber do
usurio a placa do carro e se o carro est entrando ou deixando o estacionamento. Se um carro
estiver entrando no estacionamento, mas este estiver lotado, o algoritmo deve enviar mensagem
ao usurio avisando que ele no pode estacionar. Se um carro estiver saindo do estacionamento,
deve ser informado quantas vezes o carro foi manobrado para que outros carros atrs dele
fossem retirados. O algoritmo deve utilizar a estrutura de dados da lista ligada.
18. Desenvolva um algoritmo que represente um estacionamento de carros com capacidade para 10
carros e que possua um nico porto para entrada e sada de carros no centro do
estacionamento. Nesse estacionamento, os carros so sempre estacionados um na frente do
outro direita ou esquerda do porto. Assim, o estacionamento tem capacidade para estacionar
5 carros esquerda do porto de entrada e outros 5 carros direita do porto de entrada.
Quando um carro precisa ser retirado do estacionamento e no for o carro mais prximo do porto
de sada, todos os carros estacionados na frente desse carro devem ser retirados e, aps
remover o carro que deve ser retirado, todos os carros que estavam na frente devem voltar ao
estacionamento para a mesma seqncia inicial. O primeiro carro a entrar no estacionamento
deve estacionar esquerda do porto de entrada; o segundo carro a entrar deve estacionar
direita do porto de entrada; o terceiro carro esquerda; o quarto carro direita e assim por
diante, sempre intercalando. Se um carro estiver entrando no estacionamento, mas este estiver
lotado, o algoritmo deve enviar mensagem ao usurio avisando que ele no pode estacionar. Se
um carro estiver saindo do estacionamento, deve ser informado quantas vezes o carro foi
manobrado para que outros carros atrs dele fossem retirados. O algoritmo deve utilizar um nico
vetor e a estrutura de dados da lista ligada.
19. Considerando a necessidade de um algoritmo que administre listas ligadas de reserva de filmes
de uma vdeo locadora, desenvolva um algoritmo que receba do usurio o dia da semana em que
ele deseja alugar o filme, sabendo que, para cada filme, existem sete listas ligadas, uma para
cada dia da semana. Quando o usurio for informado da disponibilidade da fita e confirmar a
locao, ele deve sair da lista ligada. Considerar que, para cada filme, existe uma nica lista
ligada.

191
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

20. Desenvolva um algoritmo que receba do usurio uma lista ligada de compras para sua casa e,
medida que os itens forem comprados, eles devem sair da lista ligada e uma mensagem deve ser
mostrada ao usurio.
21. Um sistema de numerao chama-se decimal quando sua base 10, ou seja, este sistema de
numerao possui 10 caracteres que o representam e que so: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Um
sistema de numerao chama-se binrio quando sua base 2, ou seja, este sistema possui 2
caracteres que o representam e que so: 0 e 1. Podemos representar um nmero binrio em
decimal utilizando a notao posicional (somatria de dgito multiplicado pela base elevado
posio, ver exemplo abaixo). Com base nessas informaes, desenvolva um algoritmo que
receba do usurio um nmero inteiro binrio e que mostre o seu correspondente em decimal. O
algoritmo deve utilizar a estrutura de dados de lista ligada.
Exemplo: representar o nmero binrio 10110 (base 2) em decimal
posio

nmero

10110 = 1 24 + 0 23 + 1 22 + 1 21 + 0 20 = 16 + 0 + 4 + 2 + 0 = 22 (decimal)
22. Um sistema de numerao chama-se hexadecimal quanto sua base 16, ou seja, este sistema
de numerao possui 16 caracteres que o representam e que so: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B,
C, D, E e F. Podemos representar um nmero hexadecimal em decimal utilizando a notao
posicional (somatria de dgito multiplicado pela base elevado posio, ver exemplo abaixo).
Com base nessas informaes, desenvolva um algoritmo que receba do usurio um nmero
inteiro hexadecimal e que mostre o seu correspondente em decimal. O algoritmo deve utilizar a
estrutura de dados de lista ligada.
Exemplo: representar o nmero hexadecimal 10A5F (base 16) em decimal
posio

nmero

1AF5 = 1 163 + A 162 + 5 161 + F 160 = 4096 + 2560 + 80 + 15 = 6751 (decimal)


23. Desenvolva um algoritmo que recebe o nmero de uma conta corrente sem o dgito verificador e
armazena os dgitos desse nmero numa lista ligada. Calcule o dgito verificador desta conta
corrente, armazenando o resultado na mesma lista ligada. Mostrar o nmero da conta corrente
com o dgito verificador. Para calcular o dgito verificador da conta corrente, some o nmero da
conta corrente com o seu reverso. Depois multiplique cada dgito por sua ordem posicional e
somar este resultado. O ltimo dgito deste resultado o dgito verificador da conta.
Por exemplo, considere a seguinte conta corrente: 25678
* o reverso deste nmero 87652;
* somar nmero da conta com seu reverso: 25678 + 87652 = 113330;
* multiplicar cada dgito por sua ordem posicional e somar este resultado:
192
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

posio

nmero

* soma = 1 * 1 + 2 * 1 + 3 * 3 + 4 * 3 + 5 * 3 + 6 * 0 = 39
* o ltimo dgito de 39 o dgito verificador da conta corrente, ou seja, 9
Logo, a conta corrente : 25678-9

24. Desenvolva um algoritmo que recebe o nmero de um CPF com 9 dgitos, sem os dgitos
verificadores e armazena os dgitos desse nmero numa lista ligada.Calcula os dois dgitos
verificadores e armazena na mesma lista ligada. Mostrar os elementos da lista ligada com o
nmero do CPF e os dgitos verificadores. Para calcular os dgitos verificadores de um CPF,
utilize a seguinte frmula:
9

total1 = (numi * (11 i))


i=1

resto1 = resto da diviso de total1 por 11


se resto1 for igual a 0 ou igual a 1 ento dig1 = 0 seno dig1 = 11 resto1
10

total2 = (numi * (12 i))


i=1

resto2 = resto da diviso de total2 por 11


se resto2 for igual a 0 ou igual a 1 ento dig2 = 0 seno dig2 = 11 resto2
Por exemplo, considere o seguinte CPF 111.222.333
i

num

total1 = 1 * 10 + 1 * 9 + 1 * 8 + 2 * 7 + 2 * 6 + 2 * 5 + 3 * 4 + 3 * 3 + 3 * 2 = 90
resto1 = 90 mod 11 = 2
como 2 diferente de 0 e 1, ento dig1 = 11 2 = 9
i

10

num

total2 = 1 * 11 + 1 * 10 + 1 * 9 + 2 * 8 + 2 * 7 + 2 * 6 + 3 * 5 + 3 * 4 + 3 * 3 + 9 * 2 = 126
resto2 = 126 mod 11 = 5
como 5 diferente de 0 e 1, ento dig2 = 11 5 = 6
Logo, o CPF completo : 111.222.333-96

193
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

25. Desenvolva um algoritmo que recebe 10 anos e armazena numa lista ligada os anos que so
bissextos e numa outra lista ligada os anos que no so bissextos. Mostrar os elementos das
duas lista ligadas. Para saber se um ano bissexto basta satisfazer um dos seguintes itens:

ano divisvel por 4 e no divisvel por 100


ano divisvel por 400

9. Estrutura de rvores

Quando desenvolvemos um algoritmo ou programa estruturado, muitas vezes precisamos


estruturar as informaes de diferentes tipos de dados que podemos utilizar no programa. Para
isso, podemos utilizar a estrutura de dados chamada rvores para estruturar essas informaes
ao programa inserindo, removendo e consultando informaes.
A estrutura de dados de rvores bastante utilizada quando tem como prioridade um ou mais dos
seguintes itens: acesso direto e seqencial eficientes; facilidade de insero e remoo de
elementos; boa taxa de utilizao de memria; e utilizao de memria primria e secundria.
As rvores so desenvolvidas utilizando-se os conceitos da lista ligada e recurso.
H diferentes estruturas de rvores para representar os dados na computao, por exemplo:
rvore binria, rvores AVL, rvores rubro negras, rvores B, rvores R, etc.
A rvore uma estrutura de dados muito utilizada na cincia da computao para a programao.
Neste captulo, veremos como e quando trabalhar com rvores binrias, bem como, inserir,
remover, consultar e manipular dados com rvore binria.

9.1. Definio de rvores


A rvore uma estrutura de dados bidimensional, no linear, utilizada na programao de
computadores que se compem de ns e arcos. Essas rvores so representadas de cima para
baixo com a raiz no topo e as folhas na base, diferente das rvores naturais. A raiz um n que
no possui pai, ou seja, outros ns acima dele e as folhas so ns que no possuem filhos, ou
seja, ns abaixo delas, ou melhor, s possuem filhos nulos.
Podemos dizer que, de modo geral, uma rvore possui as seguintes caractersticas:

n raiz - o primeiro n da rvore e que fica acima de qualquer outro n. Todos os outros ns
so descendentes deste n. Existe somente um n raiz em qualquer estrutura de rvore;

n folha - o ltimo n da rvore e, por isso, ele no possui descendentes. Pode existir mais do
que uma n folha;

n interior - o n que est no interior da rvore. Este n possui descendentes e ascendentes


e no pode ser o n raiz e nem o n folha;

trajetria - o nmero de ns que possui entre um n e outro;


grau do n - o nmero de descendentes que um n possui. Tambm pode ser definido como
o nmero de subrvores que um n possui;

altura da rvore - o nmero mximo de nveis que podem ter os ns da rvore; e

194
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

altura do n - o nmero mximo de nveis que podem ter os descendentes desse n, inclusive
com este n.
Para exemplificar a rvore, podemos pensar nos diretrios e arquivos de computadores. Os
arquivos que criamos num computador podem ser armazenados dentro de um diretrio. Este
diretrio, por sua vez, pode armazenar outros diretrios que podem ser chamados de
subdiretrios. Esses subdiretrios tambm podem armazenar outros arquivos e subdiretrios e
assim por diante, de forma recursiva. O primeiro diretrio que criamos o que chamamos de n
raiz e os ltimos arquivos que armazenamos no ltimo subdiretrio que criamos o que
chamamos de ns folha.
Uma rvore binria pode estar vazia ou pode ser composta de trs partes: o n raiz, a subrvore
direita do n raiz e a subrvore esquerda do n raiz. Essas partes tambm so rvores
binrias. Uma subrvore binria tambm pode estar vazia. Cada elemento da rvore binria o
que chamamos de n e cada ligao de um n para outro o que chamamos de arco. Na seo
seguinte, vamos exemplificar uma rvore binria.

9.2. Exemplo de rvores Binrias


Para exemplificar o funcionamento de uma rvore binria, vamos representar uma rvore binria
de letras, de acordo com a regra (recursiva): "todo elemento esquerda menor que a raiz, todo
elemento direita maior ou igual raiz".
Inicialmente, esta rvore binria est vazia, ou seja, no existe elementos na rvore binria,
portanto, a raiz da rvore binria nula, conforme mostra a figura abaixo:

raiz

nulo

Figura 1.

Vamos, ento, inserir a letra E na rvore binria, em seguida inserir a letra A, depois a letra U, e,
por ltimo, a letra O, conforme a seqncia abaixo. Perceba que o tamanho da rvore binria
muda, dependendo do nvel em que a letra inserida:
raiz
E
A

U
O

Figura 2.

Se quisermos remover um elemento da rvore binria, podemos remover qualquer elemento que
esteja na rvore binria, por exemplo, vamos remover a letra U, observando a figura a seguir:

195
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

raiz
E
A

Figura 3.

9.3. Caractersticas de rvores Binrias


9.3.1. Altura de uma rvore Binria
Uma propriedade fundamental de qualquer rvore binria a de que existe um nico caminho de
sua raiz para qualquer n, seja este n um n interno ou um n folha. Assim, podemos considerar
que a altura de uma rvore binria o comprimento do caminho mais longo que pode ter
determinada rvore binria, ou seja, a distncia da raiz at o n folha mais distante da raiz. Assim,
por exemplo, uma rvore binria com um nico n, a raiz, tem altura igual a zero; uma rvore
binria com dois ns, um n raiz e um n folha, tem altura igual a 1; e assim por diante. A rvore
binria da figura abaixo tem altura igual a 3.

Figura 4.

9.3.2. A rvore Binria Completa e o seu Nmero de Ns


Podemos separar uma rvore binria em nveis. O nvel zero o nvel no qual se encontra o n
raiz. O nvel 1 o nvel no qual esto os ns abaixo do n raiz e assim por diante, conforme
mostra a figura abaixo.
Uma rvore binria considerada completa se todo n possuir uma subrvore binria esquerda
e outra direita, com exceo de todos os ns folhas, que devem estar no mesmo nvel.
Observando a figura abaixo que representa uma rvore binria completa, perceba que, no nvel 1,
a rvore binria possui 2 = 2 1 ns, no nvel 2 a rvore binria possui 4 = 2 2 ns, no nvel 3 a
rvore binria possui 8 = 2 3 ns, e assim por diante, at que, no nvel n, a rvore binria possua
2n ns. Assim, considerando tambm o n raiz, uma rvore binria completa possui
20 + 21 + 22 + 23 + ... + 2n ns.

196
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

nvel
0
1
2
3
Figura 5.

9.3.3. rvores Binrias Degeneradas


Uma rvore binria dita degenerada se, para todo n de uma rvore binria, existe uma nica
subrvore, seja ela para a direita ou para a esquerda. Veja as ilustraes abaixo que representam
rvores degeneradas.

Figura 6.

9.4. Operaes de rvores Binrias


Pensando no funcionamento da rvore, conforme exemplificado nas sees 8.1 e 8.2, podemos
definir algumas operaes utilizadas na estrutura de dados da rvore:

inserir - a operao de inserir insere um elemento na rvore binria;


exibir esquerda - a operao de exibir esquerda mostra todos os elementos esquerda de
determinado n;

exibir direita - a operao de exibir direita mostra todos os elementos esquerda de


determinado n;

exibir raiz - a operao de exibir a raiz mostra o elemento da raiz da rvore binria;
remover - a operao de remover exclui um elemento da rvore binria.

197
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

9.4.1. Operaes de rvores Binrias em Pseudocdigo


Inserir um mdulo procedimento da operao inserir que recebe como parmetro um BIntNo
rvore e um novoNo a ser inserido.
BIntNo inserir (arvore BIntNo, novoNo numrico_inteiro)
incio_mdulo
se (arvore = nulo)
ento
retornar novo BIntNo (novoNo);
seno
se (novoNo < arvore.valor)
ento
arvore.esq inserir (arvore.esq, novoNo);
seno
arvore.dir inserir (arvore.dir, novoNo);
fimse;
fimse;
retornar arvore;
fim_mdulo;
inserirNo (novoValor numrico_inteiro)
incio_mdulo
Raiz inserir(Raiz, novoValor);
fim_mdulo;
ExibirEsq um mdulo procedimento que recebe um n e mostra o elemento que est
esquerda desse n.
exibirEsquerdo (arv BIntNo)
incio_mdulo
se (arv <> nulo)
ento
exibirEsquerdo (arv.esq);
escrever(arv.valor);
fimse;
fim_mdulo;
exibirNoEsq()

198
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

incio_mdulo
exibirEsquerdo(Raiz);
fim_mdulo;
ExibirDir um mdulo procedimento que recebe um n e mostra o elemento que est direita
desse n.
exibirDireito (arv BIntNo)
incio_mdulo
se (arv <> nulo)
ento
exibirDireito(arv.dir);
escrever (arv.valor);
fimse;
fim_mdulo;
exibirNoDir()
incio_mdulo
exibirDireito(Raiz);
fim_mdulo;
ExibirRaiz um mdulo procedimento que mostra o elemento que est no n raiz.
exibirRaiz()
incio_mdulo
escrever("raiz " , Raiz.valor);
fim_mdulo;
Remover um mdulo procedimento que recebe um n e remove esse mesmo n.
No (item numrico_inteiro)
incio_mdulo
tempNo, pai, filho, temp BIntNo;
tempNo Raiz;
pai null;
filho Raiz;
enquanto (tempNo <> nulo e tempNo.valor <> item) faa

199
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

pai tempNo;
se (item < tempNo.valor)
ento
tempNo tempNo.esq;
seno
tempNo tempNo.dir;
fimse;
se (tempNo = nulo)
ento
escrever("item no localizado!");
fimse;
se (pai = nulo)
ento
se (tempNo.dir = nulo)
ento
Raiz tempNo.esq;
seno
se (tempNo.esq = nulo)
ento
Raiz tempNo.dir;
seno
para temp tempNo e filho tempNo.esq at filho.dir <> null
passo temp filho e filho filho.dir faa
fimpara;
se (filho <> tempNo.esq)
ento
temp.dir filho.esq;
filho.esq Raiz.esq;
fimse;
filho.dir Raiz.dir;
Raiz filho;
fimse;
fimse;
seno
se (tempNo.dir = nulo)
ento
200
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

se (pai.esq = tempNo)
ento
pai.esq tempNo.esq;
seno
pai.dir tempNo.esq;
fimse;
seno
se (tempNo = nulo)
ento
se (pai.esq = tempNo)
ento
pai.esq tempNo.dir;
seno
pai.dir tempNo.dir;
fimse;
seno
para temp tempNo e filho tempNo.esq at filho.dir <> nulo
passo temp filho e filho filho.dir
fimpara;
se (filho <> tempNo.esq)
ento
temp.dir filho.esq;
filho.esq tempNo.esq;
fimse;
filho.dir tempNo.dir;
se (pai.esq = tempNo)
ento
pai.esq filho;
seno
pai.dir filho;
fimse;
fimse;
fimse;
fimse;
fimenquanto;
fimmdulo;
201
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

9.4.2. Operaes de rvores Binrias em Java


Inserir um mdulo procedimento da operao inserir que recebe como parmetro um BIntNo
rvore e um novoNo a ser inserido.
private BIntNo inserir (BIntNo arvore, int novoNo)
{
if (arvore == null)
{
return new BIntNo (novoNo);
}
else
{
if (novoNo < arvore.valor)
{
arvore.esq = inserir (arvore.esq, novoNo);
}
else
{
arvore.dir = inserir (arvore.dir, novoNo);
}
}
return arvore;
}
public void inserirNo (int novoValor)
{
Raiz = inserir(Raiz, novoValor);
}

ExibirEsq um mdulo procedimento que recebe um n e mostra o elemento que est


esquerda desse n.
private void exibirEsquerdo (BIntNo arv)
{
if (arv != null)
{
exibirEsquerdo (arv.esq);
System.out.println(arv.valor);
}
}
public void exibirNoEsq()
{
exibirEsquerdo(Raiz);
}

202
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ExibirDir um mdulo procedimento que recebe um n e mostra o elemento que est direita
desse n.
private void exibirDireito (BIntNo arv)
{
if (arv != null)
{
exibirDireito(arv.dir);
System.out.println (arv.valor);
}
}
public void exibirNoDir()
{
exibirDireito(Raiz);
}

ExibirRaiz um mdulo procedimento que mostra o elemento que est no n raiz.


public void exibirRaiz()
{
System.out.println("raiz " + Raiz.valor);
}

Remover um mdulo procedimento que recebe um n e remove esse n.


public void excluirNo (int item)
{
try
{
BIntNo tempNo, pai, filho, temp;
tempNo = Raiz;
pai = null;
filho = Raiz;
while (tempNo != null && tempNo.valor != item)
{
pai = tempNo;
if (item < tempNo.valor)
{
tempNo = tempNo.esq;
}
else
{
tempNo = tempNo.dir;
}
}
if (tempNo == null)
{
203
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

System.out.println("item no localizado!");
}
if (pai == null)
{
if (tempNo.dir == null)
{
Raiz = tempNo.esq;
}
else
{
if (tempNo.esq == null)
{
Raiz = tempNo.dir;
}
else
{
for (temp = tempNo, filho = tempNo.esq ; filho.dir !=
null ; temp = filho, filho = filho.dir);
if (filho != tempNo.esq)
{
temp.dir = filho.esq;
filho.esq = Raiz.esq;
}
filho.dir = Raiz.dir;
Raiz = filho;
}
}
}
else
{
if (tempNo.dir == null)
{
if (pai.esq == tempNo)
{
pai.esq = tempNo.esq;
}
else
{
pai.dir = tempNo.esq;
}
}
else
{
if (tempNo == null)
{
if (pai.esq == tempNo)
{
pai.esq = tempNo.dir;
}
else

204
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
pai.dir = tempNo.dir;
}
}
else
{
for (temp = tempNo, filho = tempNo.esq ; filho.dir !=
null ; temp = filho, filho = filho.dir);
if (filho != tempNo.esq)
{
temp.dir = filho.esq;
filho.esq = tempNo.esq;
}
filho.dir = tempNo.dir;
if (pai.esq == tempNo)
{
pai.esq = filho;
}
else
{
pai.dir = filho;
}
}
}
}
}
catch(NullPointerException erro)
{
// item no encontrado
}
}
}

9.5. Exemplo de rvores Binrias em Pseudocdigo


1. Desenvolva um algoritmo que receba do usurio cinco nmeros inteiros numa rovre binria
degenerada esquerda e que mostre esses nmeros.
Algoritmo BIntNo
incio_algoritmo
// definio do tipo registro BIntNo com os campos abaixo
tipo BIntNo = registro // o tipo registro chama-se BIntNo
valor numrico_inteiro; // campos inteiros
esq, dir BIntNo; // campo vetor de capacidade
fimregistro;
Fim_algoritmo.

205
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Algoritmo ArvoreBinaria
incio_algoritmo
Declarar
Raiz BIntNo;
BIntNo inserir (rvore BIntNo, novoNo numrico_inteiro)
incio_mdulo
se ( rvore = nulo)
ento
retornar novo BIntNo (novoNo);
seno
se (novoNo < arvore.valor)
ento
arvore.esq inserir (arvore.esq, novoNo);
seno
arvore.dir inserir (arvore.dir, novoNo);
fimse;
fimse;
retornar arvore;
fim_mdulo;
inserirNo (novoValor numrico_inteiro)
incio_mdulo
Raiz inserir(Raiz, novoValor);
fim_mdulo;
exibirEsquerdo (arv BIntNo)
incio_mdulo
se (arv <> nulo)
ento
exibirEsquerdo (arv.esq);
escrever(arv.valor);
fimse;
fim_mdulo;
exibirNoEsq()
incio_mdulo
exibirEsquerdo(Raiz);
206
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fim_mdulo;
exibirDireito (arv BIntNo)
incio_mdulo
se (arv <> nulo)
ento
exibirDireito(arv.dir);
escrever (arv.valor);
fimse;
fim_mdulo;
exibirNoDir()
incio_mdulo
exibirDireito(Raiz);
fim_mdulo;
incio_mdulo
exibirNoEsq( );
exibirRaiz( );
exibirNoDir( );
fim_mdulo;
exibirRaiz()
incio_mdulo
escrever("raiz " , Raiz.valor);
fim_mdulo;
No (item numrico_inteiro)
incio_mdulo
tempNo, pai, filho, temp BIntNo;
tempNo Raiz;
pai null;
filho Raiz;
enquanto (tempNo <> nulo e tempNo.valor <> item) faa
pai tempNo;
se (item < tempNo.valor)

207
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ento
tempNo tempNo.esq;
seno
tempNo tempNo.dir;
fimse;
se (tempNo = nulo)
ento
escrever("item no localizado!");
fimse;
se (pai = nulo)
ento
se (tempNo.dir = nulo)
ento
Raiz tempNo.esq;
seno
se (tempNo.esq = nulo)
ento
Raiz tempNo.dir;
seno
para temp tempNo e filho tempNo.esq at filho.dir <> null
passo temp filho e filho filho.dir faa
fimpara;
se (filho <> tempNo.esq)
ento
temp.dir filho.esq;
filho.esq Raiz.esq;
fimse;
filho.dir Raiz.dir;
Raiz filho;
fimse;
fimse;
seno
se (tempNo.dir = nulo)
ento
se (pai.esq = tempNo)
ento
pai.esq tempNo.esq;

208
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

seno
pai.dir tempNo.esq;
fimse;
seno
se (tempNo = nulo)
ento
se (pai.esq = tempNo)
ento
pai.esq tempNo.dir;
seno
pai.dir tempNo.dir;
fimse;
seno
para temp tempNo e filho tempNo.esq at filho.dir <> nulo
passo temp filho e filho filho.dir
fimpara;
se (filho <> tempNo.esq)
ento
temp.dir filho.esq;
filho.esq tempNo.esq;
fimse;
filho.dir tempNo.dir;
se (pai.esq = tempNo)
ento
pai.esq filho;
seno
pai.dir filho;
fimse;
fimse;
fimse;
fimse;
fimenquanto;
fimmdulo;
fim_algoritmo.
Algoritmo teste
incio_algoritmo

209
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Declarar
num numrico_inteiro;
ArvoreBinaria arv novo ArvoreBinaria();
ler(num);
arv.inserirNo(num);
ler(num);
arv.inserirNo(num);
ler(num);
arv.inserirNo(num);
ler(num);
arv.inserirNo(num);
ler(num);
arv.inserirNo(num);
arv.exibirNo();
Fim_algoritmo.

2. Desenvolva um algoritmo que receba do usurio cinco nmeros inteiros numa rovre binria,
de acordo com a regra (recursiva): "todo elemento esquerda menor que a raiz, todo
elemento direita maior ou igual raiz". Esse algoritmo deve, ainda, mostrar esses
nmeros.
Algoritmo BIntNo
incio_algoritmo
// definio do tipo registro BIntNo com os campos abaixo
tipo BIntNo = registro // o tipo registro chama-se BIntNo
valor numrico_inteiro; // campos inteiros
esq, dir BIntNo; // campo vetor de capacidade
fimregistro;
Fim_algoritmo.
Algoritmo ArvoreBinaria
incio_algoritmo
Declarar
Raiz BIntNo;
BIntNo inserir (arvore BIntNo, novoNo numrico_inteiro)
incio_mdulo
210
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

se (arvore = nulo)
ento
retornar novo BIntNo (novoNo);
seno
se (novoNo < arvore.valor)
ento
arvore.esq inserir (arvore.esq, novoNo);
seno
arvore.dir inserir (arvore.dir, novoNo);
fimse;
fimse;
retornar arvore;
fim_mdulo;
inserirNo (novoValor numrico_inteiro)
incio_mdulo
Raiz inserir(Raiz, novoValor);
fim_mdulo;
exibirEsquerdo (arv BIntNo)
incio_mdulo
se (arv <> nulo)
ento
exibirEsquerdo (arv.esq);
escrever(arv.valor);
fimse;
fim_mdulo;
exibirNoEsq()
incio_mdulo
exibirEsquerdo(Raiz);
fim_mdulo;

211
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

exibirDireito (arv BIntNo)


incio_mdulo
se (arv <> nulo)
ento
exibirDireito(arv.dir);
escrever (arv.valor);
fimse;
fim_mdulo;
exibirNoDir()
incio_mdulo
exibirDireito(Raiz);
fim_mdulo;
incio_mdulo
exibirNoEsq( );
exibirRaiz( );
exibirNoDir( );
fim_mdulo;
exibirRaiz()
incio_mdulo
escrever("raiz " , Raiz.valor);
fim_mdulo;
No (item numrico_inteiro)
incio_mdulo
tempNo, pai, filho, temp BIntNo;
tempNo Raiz;
pai null;
filho Raiz;
enquanto (tempNo <> nulo e tempNo.valor <> item) faa
pai tempNo;
se (item < tempNo.valor)
ento
tempNo tempNo.esq;
212
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

seno
tempNo tempNo.dir;
fimse;
se (tempNo = nulo)
ento
escrever("item no localizado!");
fimse;
se (pai = nulo)
ento
se (tempNo.dir = nulo)
ento
Raiz tempNo.esq;
seno
se (tempNo.esq = nulo)
ento
Raiz tempNo.dir;
seno
para temp tempNo e filho tempNo.esq at filho.dir <> null
passo temp filho e filho filho.dir faa
fimpara;
se (filho <> tempNo.esq)
ento
temp.dir filho.esq;
filho.esq Raiz.esq;
fimse;
filho.dir Raiz.dir;
Raiz filho;
fimse;
fimse;
seno
se (tempNo.dir = nulo)
ento
se (pai.esq = tempNo)
ento
pai.esq tempNo.esq;
seno
pai.dir tempNo.esq;

213
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimse;
seno
se (tempNo = nulo)
ento
se (pai.esq = tempNo)
ento
pai.esq tempNo.dir;
seno
pai.dir tempNo.dir;
fimse;
seno
para temp tempNo e filho tempNo.esq at filho.dir <> nulo
passo temp filho e filho filho.dir
fimpara;
se (filho <> tempNo.esq)
ento
temp.dir filho.esq;
filho.esq tempNo.esq;
fimse;
filho.dir tempNo.dir;
se (pai.esq = tempNo)
ento
pai.esq filho;
seno
pai.dir filho;
fimse;
fimse;
fimse;
fimse;
fimenquanto;
fimmdulo;
fim_algoritmo.
Algoritmo teste
incio_algoritmo
Declarar
num numrico_inteiro;

214
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ArvoreBinaria arv novo ArvoreBinaria();


ler(num);
arv.inserirNo(num);
ler(num);
arv.inserirNo(num);
ler(num);
arv.inserirNo(num);
ler(num);
arv.inserirNo(num);
ler(num);
arv.inserirNo(num);
arv.exibirNo();
Fim_algoritmo.
3. Desenvolva um algoritmo que receba 10 nmeros inteiros e que armazene numa estrutura de
rvore binria, de forma ordenada, somente os nmeros divisveis por trs. Esse algoritmo
deve mostrar todos os elementos da rvore binria.
Algoritmo BIntNo
incio_algoritmo
// definio do tipo registro BIntNo com os campos abaixo
tipo BIntNo = registro // o tipo registro chama-se BIntNo
valor numrico_inteiro; // campos inteiros
esq, dir BIntNo; // campo vetor de capacidade
fimregistro;
Fim_algoritmo.
Algoritmo ArvoreBinaria
incio_algoritmo
Declarar
Raiz BIntNo;
BIntNo inserir ( rvore BIntNo, novoNo numrico_inteiro)
incio_mdulo
se ( rvore = nulo)
ento
retornar novo BIntNo (novoNo);
215
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

seno
se (novoNo < arvore.valor)
ento
arvore.esq inserir (arvore.esq, novoNo);
seno
arvore.dir inserir (arvore.dir, novoNo);
fimse;
fimse;
retornar arvore;
fim_mdulo;
inserirNo (novoValor numrico_inteiro)
incio_mdulo
Raiz inserir(Raiz, novoValor);
fim_mdulo;
exibirEsquerdo (arv BIntNo)
incio_mdulo
se (arv <> nulo)
ento
exibirEsquerdo (arv.esq);
escrever(arv.valor);
fimse;
fim_mdulo;
exibirNoEsq()
incio_mdulo
exibirEsquerdo(Raiz);
fim_mdulo;
exibirDireito (arv BIntNo)
incio_mdulo
se (arv <> nulo)
ento
exibirDireito(arv.dir);
escrever (arv.valor);
fimse;
216
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fim_mdulo;
exibirNoDir()
incio_mdulo
exibirDireito(Raiz);
fim_mdulo;
incio_mdulo
exibirNoEsq( );
exibirRaiz( );
exibirNoDir( );
fim_mdulo;
exibirRaiz()
incio_mdulo
escrever("raiz " , Raiz.valor);
fim_mdulo;
No (item numrico_inteiro)
incio_mdulo
tempNo, pai, filho, temp BIntNo;
tempNo Raiz;
pai null;
filho Raiz;
enquanto (tempNo <> nulo e tempNo.valor <> item) faa
pai tempNo;
se (item < tempNo.valor)
ento
tempNo tempNo.esq;
seno
tempNo tempNo.dir;
fimse;
se (tempNo = nulo)
ento
escrever("item no localizado!");
fimse;

217
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

se (pai = nulo)
ento
se (tempNo.dir = nulo)
ento
Raiz tempNo.esq;
seno
se (tempNo.esq = nulo)
ento
Raiz tempNo.dir;
seno
para temp tempNo e filho tempNo.esq at filho.dir <> null
passo temp filho e filho filho.dir faa
fimpara;
se (filho <> tempNo.esq)
ento
temp.dir filho.esq;
filho.esq Raiz.esq;
fimse;
filho.dir Raiz.dir;
Raiz filho;
fimse;
fimse;
seno
se (tempNo.dir = nulo)
ento
se (pai.esq = tempNo)
ento
pai.esq tempNo.esq;
seno
pai.dir tempNo.esq;
fimse;
seno
se (tempNo = nulo)
ento
se (pai.esq = tempNo)
ento
pai.esq tempNo.dir;

218
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

seno
pai.dir tempNo.dir;
fimse;
seno
para temp tempNo e filho tempNo.esq at filho.dir <> nulo
passo temp filho e filho filho.dir
fimpara;
se (filho <> tempNo.esq)
ento
temp.dir filho.esq;
filho.esq tempNo.esq;
fimse;
filho.dir tempNo.dir;
se (pai.esq = tempNo)
ento
pai.esq filho;
seno
pai.dir filho;
fimse;
fimse;
fimse;
fimse;
fimenquanto;
fimmdulo;
fim_algoritmo.
Algoritmo teste
incio_algoritmo
Declarar
i, num numrico_inteiro;
ArvoreBinaria arv novo ArvoreBinaria();
para i de 1 at 10 passo +1 faa
ler(num);
se (num mod 3 = 0)
ento
arv.inserirNo(num);

219
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimse;
fimpara;
arv.exibirNo();
Fim_algoritmo.

9.6. Exemplo de rvores Binrias em Java


1. Desenvolva um algoritmo que receba do usurio cinco nmeros inteiros numa rvore binria
degenerada esquerda e que mostre esses nmeros.
import javax.swing.*;
class BIntNo
{
int valor;
BIntNo esq, dir;
BIntNo(int novoValor)
{
valor = novoValor;
}
}
class ArvoreBinaria
{
private BIntNo Raiz;
private BIntNo inserir (BIntNo arvore, int novoNo)
{
if (arvore == null)
{
return new BIntNo (novoNo);
}
else
{
if (novoNo < arvore.valor)
{
arvore.esq = inserir (arvore.esq, novoNo);
}
else
{
arvore.dir = inserir (arvore.dir, novoNo);
}
}
return arvore;
}
public void inserirNo (int novoValor)
220
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
Raiz = inserir(Raiz, novoValor);
}
private void exibirEsquerdo (BIntNo arv)
{
if (arv != null)
{
exibirEsquerdo (arv.esq);
System.out.println(arv.valor);
}
}
private void exibirDireito (BIntNo arv)
{
if (arv != null)
{
exibirDireito(arv.dir);
System.out.println (arv.valor);
}
}
public void exibirRaiz()
{
System.out.println("raiz " + Raiz.valor);
}
public void exibirNoEsq()
{
exibirEsquerdo(Raiz);
}
public void exibirNoDir()
{
exibirDireito(Raiz);
}
public void exibirNo()
{
exibirNoEsq();
exibirRaiz();
exibirNoDir();
}
public void excluirNo (int item)
{
try
{
BIntNo tempNo, pai, filho, temp;

221
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

tempNo = Raiz;
pai = null;
filho = Raiz;
while (tempNo != null && tempNo.valor != item)
{
pai = tempNo;
if (item < tempNo.valor)
{
tempNo = tempNo.esq;
}
else
{
tempNo = tempNo.dir;
}
}
if (tempNo == null)
{
System.out.println("item no localizado!");
}
if (pai == null)
{
if (tempNo.dir == null)
{
Raiz = tempNo.esq;
}
else
{
if (tempNo.esq == null)
{
Raiz = tempNo.dir;
}
else
{
for (temp = tempNo, filho = tempNo.esq ; filho.dir !=
null ; temp = filho, filho = filho.dir);
if (filho != tempNo.esq)
{
temp.dir = filho.esq;
filho.esq = Raiz.esq;
}
filho.dir = Raiz.dir;
Raiz = filho;
}
}
}
else
{
if (tempNo.dir == null)
{

222
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

if (pai.esq == tempNo)
{
pai.esq = tempNo.esq;
}
else
{
pai.dir = tempNo.esq;
}
}
else
{
if (tempNo == null)
{
if (pai.esq == tempNo)
{
pai.esq = tempNo.dir;
}
else
{
pai.dir = tempNo.dir;
}
}
else
{
for (temp = tempNo, filho = tempNo.esq ; filho.dir !=
null ; temp = filho, filho = filho.dir);
if (filho != tempNo.esq)
{
temp.dir = filho.esq;
filho.esq = tempNo.esq;
}
filho.dir = tempNo.dir;
if (pai.esq == tempNo)
{
pai.esq = filho;
}
else
{
pai.dir = filho;
}
}
}
}
}
catch(NullPointerException erro)
{
// item no encontrado
}
}
}

223
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

class teste
{
public static void main (String args [])
{
ArvoreBinaria arv = new ArvoreBinaria();
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.exibirNo();
System.exit(0);
}
}

nmero inteiro")));
nmero inteiro")));
nmero inteiro")));
nmero inteiro")));
nmero inteiro")));

2. Desenvolva um algoritmo que receba do usurio cinco nmeros inteiros numa rovre binria,
de acordo com a regra (recursiva): "todo elemento esquerda menor que a raiz, todo
elemento direita maior ou igual raiz". Esse algoritmo deve, ainda, mostrar esses
nmeros.
import javax.swing.*;
class BIntNo
{
int valor;
BIntNo esq, dir;
BIntNo(int novoValor)
{
valor = novoValor;
}
}
class ArvoreBinaria
{
private BIntNo Raiz;
private BIntNo inserir (BIntNo arvore, int novoNo)
{
if (arvore == null)
{
return new BIntNo (novoNo);
}
224
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

else
{
if (novoNo < arvore.valor)
{
arvore.esq = inserir (arvore.esq, novoNo);
}
else
{
arvore.dir = inserir (arvore.dir, novoNo);
}
}
return arvore;
}
public void inserirNo (int novoValor)
{
Raiz = inserir(Raiz, novoValor);
}
private void exibirEsquerdo (BIntNo arv)
{
if (arv != null)
{
exibirEsquerdo (arv.esq);
System.out.println(arv.valor);
}
}
private void exibirDireito (BIntNo arv)
{
if (arv != null)
{
exibirDireito(arv.dir);
System.out.println (arv.valor);
}
}
public void exibirRaiz()
{
System.out.println("raiz " + Raiz.valor);
}
public void exibirNoEsq()
{
exibirEsquerdo(Raiz);
}
public void exibirNoDir()
{
exibirDireito(Raiz);

225
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

}
public void exibirNo()
{
exibirNoEsq();
exibirRaiz();
exibirNoDir();
}
public void excluirNo (int item)
{
try
{
BIntNo tempNo, pai, filho, temp;
tempNo = Raiz;
pai = null;
filho = Raiz;
while (tempNo != null && tempNo.valor != item)
{
pai = tempNo;
if (item < tempNo.valor)
{
tempNo = tempNo.esq;
}
else
{
tempNo = tempNo.dir;
}
}
if (tempNo == null)
{
System.out.println("item no localizado!");
}
if (pai == null)
{
if (tempNo.dir == null)
{
Raiz = tempNo.esq;
}
else
{
if (tempNo.esq == null)
{
Raiz = tempNo.dir;
}
else
{

226
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

for (temp = tempNo, filho = tempNo.esq ; filho.dir !=


null ; temp = filho, filho = filho.dir);
if (filho != tempNo.esq)
{
temp.dir = filho.esq;
filho.esq = Raiz.esq;
}
filho.dir = Raiz.dir;
Raiz = filho;
}
}
}
else
{
if (tempNo.dir == null)
{
if (pai.esq == tempNo)
{
pai.esq = tempNo.esq;
}
else
{
pai.dir = tempNo.esq;
}
}
else
{
if (tempNo == null)
{
if (pai.esq == tempNo)
{
pai.esq = tempNo.dir;
}
else
{
pai.dir = tempNo.dir;
}
}
else
{
for (temp = tempNo, filho = tempNo.esq ; filho.dir !=
null ; temp = filho, filho = filho.dir);
if (filho != tempNo.esq)
{
temp.dir = filho.esq;
filho.esq = tempNo.esq;
}
filho.dir = tempNo.dir;
if (pai.esq == tempNo)
{

227
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

pai.esq = filho;
}
else
{
pai.dir = filho;
}
}
}
}
}
catch(NullPointerException erro)
{
// item no encontrado
}
}
}
class teste
{
public static void main (String args [])
{
ArvoreBinaria arv = new ArvoreBinaria();
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.inserirNo(Integer.parseInt(
JOptionPane.showInputDialog("Digite um
arv.exibirNo();
System.exit(0);
}
}

nmero inteiro")));
nmero inteiro")));
nmero inteiro")));
nmero inteiro")));
nmero inteiro")));

3. Desenvolva um algoritmo que receba 10 nmeros inteiros e que armazene numa estrutura de
rvore binria, de forma ordenada, somente os nmeros divisveis por trs. Esse algoritmo
deve, ainda, mostrar todos os elementos da rvore binria.
import javax.swing.*;
class BIntNo
{
int valor;
BIntNo esq, dir;
BIntNo(int novoValor)
228
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
valor = novoValor;
}
}
class ArvoreBinaria
{
private BIntNo Raiz;
private BIntNo inserir (BIntNo arvore, int novoNo)
{
if (arvore == null)
{
return new BIntNo (novoNo);
}
else
{
if (novoNo < arvore.valor)
{
arvore.esq = inserir (arvore.esq, novoNo);
}
else
{
arvore.dir = inserir (arvore.dir, novoNo);
}
}
return arvore;
}
public void inserirNo (int novoValor)
{
Raiz = inserir(Raiz, novoValor);
}
private void exibirEsquerdo (BIntNo arv)
{
if (arv != null)
{
exibirEsquerdo (arv.esq);
System.out.println(arv.valor);
}
}
private void exibirDireito (BIntNo arv)
{
if (arv != null)
{
exibirDireito(arv.dir);
System.out.println (arv.valor);
}
}

229
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public void exibirRaiz()


{
System.out.println("raiz " + Raiz.valor);
}
public void exibirNoEsq()
{
exibirEsquerdo(Raiz);
}
public void exibirNoDir()
{
exibirDireito(Raiz);
}
public void exibirNo()
{
exibirNoEsq();
exibirRaiz();
exibirNoDir();
}
public void excluirNo (int item)
{
try
{
BIntNo tempNo, pai, filho, temp;
tempNo = Raiz;
pai = null;
filho = Raiz;
while (tempNo != null && tempNo.valor != item)
{
pai = tempNo;
if (item < tempNo.valor)
{
tempNo = tempNo.esq;
}
else
{
tempNo = tempNo.dir;
}
}
if (tempNo == null)
{
System.out.println("item no localizado!");
}
if (pai == null)
{

230
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

if (tempNo.dir == null)
{
Raiz = tempNo.esq;
}
else
{
if (tempNo.esq == null)
{
Raiz = tempNo.dir;
}
else
{
for (temp = tempNo, filho = tempNo.esq ; filho.dir !=
null ; temp = filho, filho = filho.dir);
if (filho != tempNo.esq)
{
temp.dir = filho.esq;
filho.esq = Raiz.esq;
}
filho.dir = Raiz.dir;
Raiz = filho;
}
}
}
else
{
if (tempNo.dir == null)
{
if (pai.esq == tempNo)
{
pai.esq = tempNo.esq;
}
else
{
pai.dir = tempNo.esq;
}
}
else
{
if (tempNo == null)
{
if (pai.esq == tempNo)
{
pai.esq = tempNo.dir;
}
else
{
pai.dir = tempNo.dir;
}
}

231
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

else
{
for (temp = tempNo, filho = tempNo.esq ; filho.dir !=
null ; temp = filho, filho = filho.dir);
if (filho != tempNo.esq)
{
temp.dir = filho.esq;
filho.esq = tempNo.esq;
}
filho.dir = tempNo.dir;
if (pai.esq == tempNo)
{
pai.esq = filho;
}
else
{
pai.dir = filho;
}
}
}
}
}
catch(NullPointerException erro)
{
// item no encontrado
}
}
}
class teste
{
public static void main (String args [])
{
int i, num;
ArvoreBinaria arv = new ArvoreBinaria();
for (i = 1 ; i <= 10 ; i++)
{
num = Integer.parseInt( JOptionPane.showInputDialog("Digite um
nmero inteiro"));
if (num % 3 == 0)
{
arv.inserirNo(num);
}
}
arv.exibirNo();
System.exit(0);
}
}

232
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

9.7. Exerccios de rvores


Os algoritmos abaixo devem ser desenvolvidos em pseudocdigo e com a utilizao da estrutura
de dados de rvore.
01. Desenhe a representao de rvore para a seguinte seqncia de operaes, considerando que a
rvore est inicialmente vazia:
a. Inserir (10);
b. Inserir (7);
c. Inserir (18);
d. Inserir(5);
e. Inserir (8);
f. Inserir (20);
g. MostrarRaiz( );
i. MostrarEsq ( );
j. MostrarDir ( );
k. Remover (18);
l. MostrarDir( );
m. Remover (10);
n. MostrarRaiz( );

02. Quais sero as sadas dos mtodos preOrdem, inOrdem e posOrdem aplicados na rvore
abaixo?

32

56

17

12

89

20

51

25

Figura 7.

233
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

03. Escreva a funo ehFolha(no NoArvore) que receba como parmetro a referncia a um n
de uma rvore binria e que retorne VERDADEIRO, se o n no tiver descendentes, e FALSO
caso o n tenha descendentes.
04. Escreva uma funo recursiva numFolhas(raiz NoArvore) que receba como parmetro a
referncia ao n raiz de uma rvore binria e que retorne a quantidade de folhas (ns terminais)
dessa rvore. Sugesto: Utilize a funo da questo anterior.
05. ref uma referncia do primeiro n de uma lista ligada cujos ns contm nmeros reais.
Escreva uma funo que receba ref como parmetro e que retorne a quantidade de ns da lista
ligada, que pode, eventualmente, estar vazia.
06. primeiro a referncia ao primeiro n de uma lista ligada no vazia. Os ns dessa lista contm
valores numricos em ordem crescente (primeiro aponta para o n com o menor valor).
Escreva um procedimento que receba como parmetros primeiro e um valor numrico n,
inserindo um n contendo n de tal forma que a lista continue ordenada.
07. Desenvolva um algoritmo que receba do usurio os elementos de uma expresso matemtica
escrita na forma infixa e que armazene numa rvore binria, de forma que, cada operador ou
operando da expresso matemtica dever pertencer a um n da rvore binria. A ordem dos
elementos na rvore binria deve garantir que a sada apresentada ao usurio seja a ordem em
que a expresso deve ser calculada, considerando a precedncia dos operadores.
08. Desenvolva um algoritmo que receba do usurio letras que sero armazenadas numa rvore
binria. O algoritmo deve exibir um menu de opo para o usurio poder escolher entre inserir
uma nova letra, excluir uma letra existente ou exibir o contedo de toda a rvore. Alm disso,
esse algoritmo deve contar a quantidade de palavras que o usurio inserir na rvore binria.
09. Desenvolva um algoritmo que receba do usurio nmeros inteiros que sero armazenados numa
rvore binria e que retorne a quantidade de nmeros pares armazenados nos ns da rvore
binria e a soma dos nmeros inteiros da rvore binria.
10. Desenvolva um algoritmo que receba do usurio nmeros inteiros que sero armazenados numa
rvore binria, de forma que o primeiro nmero inserido na raiz e os nmeros seguintes sejam
inseridos direita de um n, caso o nmero a ser inserido for maior do que o do n. Caso o
nmero a ser inserido for menor do que o do n, ele deve ser inserido esquerda de um n. O
algoritmo deve mostrar os elementos da rvore binria e a soma dos nmeros inteiros da rvore
binria.
11. Desenvolva um algoritmo que receba do usurio nmeros reais que sero armazenados numa
rvore binria de forma que o primeiro nmero inserido na raiz e os nmeros seguintes sejam
inseridos direita de um n, caso o nmero a ser inserido for maior do que o do n. Caso o
nmero a ser inserido for menor do que o do n, ele deve ser inserido esquerda de um n.O
algoritmo deve mostrar o nmero de ns folhas da rvore binria e a altura da rvore binria.

234
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

12. Desenvolva um algoritmo que receba do usurio letras que sero armazenados numa rvore
binria de forma que a primeira letra inserida na raiz e as prximas letras inseridas direita de
um n, caso a letra a ser inserida for maior do que a do n. Caso a letra a ser inserida for menor
do que a do n, ele deve ser inserida esquerda de um n. O algoritmo deve mostrar o nmero
de ns da rvore binria que possuem apenas um n filho.
13. Desenvolva um algoritmo que construa duas rvores binrias com nmeros inteiros fornecidos
pelo usurio e que verifique se as duas rvores binrias so iguais.
14. Desenvolva um algoritmo que construa uma rvore binria com nmeros reais fornecidos pelo
usurio e que, depois, construa uma cpia dessa rvore binria.
15. Desenvolva um algoritmo que receba do usurio uma expresso matemtica na forma infixa numa
rvore binria, que resolva o clculo matemtico e que mostre ao usurio o valor correto.
16. Desenvolva um algoritmo que receba do usurio uma expresso matemtica na forma prefixa
numa rvore binria, que resolva o clculo matemtico e que mostre ao usurio o valor correto.
17. Desenvolva um algoritmo que receba do usurio uma expresso matemtica na forma posfixa
numa rvore binria, resolva o clculo matemtico e mostre ao usurio o valor correto.
18. Desenvolva um algoritmo que determina se uma rvore binria completa.
19. Desenvolva um algoritmo que receba do usurio uma expresso matemtica na forma infixa que
ser armazenada numa rvore binria e que mostre a verso infixa da expresso que contenha
somente os parnteses necessrios.
20. Desenvolva um algoritmo que receba do usurio nmeros inteiros numa rvore binria e que
calcule e mostre o nmero de ns direita e o nmero de ns esquerda dessa rvore binria.
21. Desenvolva um algoritmo que receba do usurio letras numa rvore binria e que remova todos
os ns folhas dessa rvore binria. O algoritmo deve mostrar as letras da rvore binria antes da
remoo e depois da remoo.
22. Desenvolva um algoritmo que receba do usurio letras numa rvore binria e que remova todos
os ns cujos elementos sejam vogais. O algoritmo deve mostrar as letras da rvore binria antes
e depois da remoo.
23. Para percursos em rvores binrias, existe um percurso chamado pr-ordem. Nesse percurso,
devemos seguir este roteiro: visitar o n, percorrer a subrvore esquerda e percorrer a
subrvore direita. Com base nessas informaes, desenvolva um algoritmo que receba
nmeros inteiros numa rvore binria e que mostre seus elementos percorrendo a rvore em
pr-ordem.

235
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

24. Para percursos em rvores binrias, existe um percurso chamado ps-ordem. Nesse percurso,
devemos seguir este roteiro: percorrer a subrvore esquerda, percorrer a subrvore direita e
visitar o n. Com base nessas informaes, desenvolva um algoritmo que receba nmeros
inteiros numa rvore binria e que mostre seus elementos percorrendo a rvore em ps-ordem.
25. Para percursos em rvores binrias, existe um percurso chamado in-ordem. Nesse percurso,
devemos seguir este roteiro: percorrer a subrvore esquerda, visitar o n e percorrer a
subrvore direita. Com base nessas informaes, desenvolva um algoritmo que receba
nmeros reais numa rvore binria e que mostre seus elementos percorrendo a rvore em
in-ordem.
26. Desenvolva um algoritmo que considere um labirinto qualquer representado por uma matriz
25 x 25, que encontre um caminho entre o ponto de entrada e o ponto de sada, que armazene
as posies j percorridas e que seja capaz de voltar em um caminho que no tenha sada.
Utilizar a estrutura de rvore binria. Neste exerccio, o usurio deve escolher o caminho que
deve ser percorrido via console e, para isso, deve definir padres de movimentao, como, por
exemplo, para a direita, esquerda, para cima e para baixo.

236
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
237
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
238
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
239
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
240
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
241
Copyright Faculdade IBTA

IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
242
Copyright Faculdade IBTA