Estrutura de Dados

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
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.4. Ordenao em Java ......................................................................................................... 66
5.5. Exemplo de Ordenao em Pseueocdigo ...................................................................... 68
5.6. Exemplo de Ordenao em Java ..................................................................................... 70
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
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
2
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
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
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>;
...
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> ;
...
3
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
// construtor do registro
<nome tipo registro> (<tipo da var> <var1> , <tipo da var> <var2> , ... , <tipo da var>
<var3>)
{
<varivel1> = <var1>;
...
} // 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
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
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
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
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
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
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
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
RegistroAluno (String NA , int RA , double M)
{
NAluno = NA; // campo nome do aluno
RAluno = RA; // campo registro do aluno
Media = M; // campo mdia
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
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");
/* 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"));
/* recebe a mdia do aluno e armazena no campo Media
do vetor VetAluno na posio a/*
VetAluno[a].Media = Double.parseDouble(
"Digite a mdia do aluno"));
}
for ( a = 0 ; a <=19 ; a++ )
{
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
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);
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
fimregistro;
Declarar
// declarao de um vetor de registros do tipo RegistroFamilia
Membro[5] RegistroFamilia;
i numrico_inteiro; // declarao de uma varivel inteira
11
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

// recebe o nome e armazena no campo Nome do vetor Membro na posio i
ler (Membro[i].Nome);
// recebe a idade e armazena no campo Idade do vetor Membro na posio i
ler (Membro[i].Idade);
// recebe a altura e armazena no campo Altura do vetor Membro na posio i
ler (Membro[i].Altura);
fimpara;
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
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

// recebe o nome e armazena no campo Nome do vetor Vet na posio i
ler (Vet[i].Nome);
// recebe a idade e armazena no campo Idade do vetor Vet na posio i
ler (Vet[i].Idade);
// 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
// chamada da funo EntradaDados, enviando como parmetro o argumento Membro
// o retorno da funo EntradaDados ser armazenado no vetor Membro
Membro EntradaDados (Membro);
Membro[i].Altura);
fimpara;
fim_algoritmo.
fim_algoritmo_global.
13
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
{
String Nome; // campo nome
int Idade; // campo idade
double Altura; // campo altura
RegistroFamilia (String N , int I , double A)
{
Nome = N; // campo nome
Idade = I; // campo idade
Altura = A; // campo altura
class Exemplo1
{
{
// declarao de um Registro Membro do tipo RegistroFamlia
RegistroFamilia Membro = new RegistroFamilia ("" , 0 , 0.0 );
/* recebe o nome e armazena no campo Nome do registro
Membro*/
Membro.Nome = JOptionPane.showInputDialog("Digite o nome");
/* recebe a idade e armazena no campo Idade do registro
Membro*/
Membro.Idade = Integer.parseInt(
JOptionPane.showInputDialog("Digite a idade"));
/* recebe a altura e armazena no campo Altura do registro
Membro*/
Membro.Altura = Double.parseDouble(
JOptionPane.showInputDialog("Digite a altura"));
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
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 Exemplo2
{
{
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++)
{
/* recebe o nome e armazena no campo Nome do vetor
Membro na posio i*/
Membro[i].Nome = JOptionPane.showInputDialog(
"Digite o nome");
/* recebe a idade e armazena no campo Idade do vetor
Membro na posio i*/
Membro[i].Idade = Integer.parseInt(
/* recebe a altura e armazena no campo Altura do vetor
Membro na posio i*/
Membro[i].Altura = Double.parseDouble(
"Digite a altura"));
15
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
}
for (i=0 ; i<5 ; i++)
{
System.out.println ("A pessoa " + Membro[i].Nome +
" de Idade " + Membro[i].Idade + "
tem altura " + Membro[i].Altura);
}
System.exit(0);
} // fim da classe
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 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++)
{
/* recebe o nome e armazena no campo Nome do vetor Vet
na posio i*/
Vet[i].Nome = JOptionPane.showInputDialog(
"Digite o nome");
/* recebe a idade e armazena no campo Idade do vetor
Vet na posio i*/
16
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
Vet[i].Idade = Integer.parseInt(
/* 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
{
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++)
{
" de Idade " + Membro[i].Idade +
" tem altura " + Membro[i].Altura);
}
System.exit(0);
} // 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
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
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
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
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
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
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.
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
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
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
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
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
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
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

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);
escrever ("A pessoa " , Membro.Nome , " de Idade " , Membro.Idade , " tem altura " ,
Membro.Altura);
fechar (ArqFamilia); // fechando o arquivo ArqFamilia
fim_algoritmo.
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
fimregistro;
30
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

fimarquivo;
Declarar
/* l registro com todos os campos do arquivo ArqFamilia e armazena no vetor de registro
Membro na posio i*/
lerarq (ArqFamilia,Membro[i]);
fimpara;
Membro[i].Altura);
fimpara;
fim_algoritmo.
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
fimregistro;
31
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
RegistroFamilia [ ] EntradaDados (Vet[ ] RegistroFamilia)

incio
Definir
fimarquivo;
Declarar
/* l registro com todos os campos do arquivo ArqFamilia e armazena no vetor de registro
Vet na posio i*/
lerarq (ArqFamilia,Vet[i]);
fimpara;
retornar Vet; // retorno do vetor Vet
fim_mdulo;
SaidaDados (Vet[ ] RegistroFamilia)
incio
Definir
fimarquivo;
Declarar
/* grava registro com todos os campos do vetor de registro Vet na posio i no arquivo
ArqFamilia*/
gravar (ArqFamilia,Vet[i]);
fimpara;
32
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
fim_mdulo;
Algoritmo Exemplo3
incio_algoritmo
Declarar
// chamada da funo EntradaDados, enviando como parmetro o argumento Membro[ ]
// o retorno da funo EntradaDados ser armazenado no vetor Membro[ ]
Membro EntradaDados (Membro);
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

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.
{
{
33
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

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());
System.out.println ("A pessoa " + Membro.Nome + " de Idade "
+ Membro.Idade + " tem altura " + Membro.Altura);
ArqFamilia.close(); // fechando arquivo
System.exit(0);
} // fim da classe
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.
{
{
34
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

class Exemplo2
{
{
int i;
for (i=0 ; i<5 ; i++)
{
}
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(
}
for (i=0 ; i<5 ; i++)
{
}
System.exit(0);
} // fim da classe
35
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
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 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
{
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
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(
/* L a altura e armazena no campo Altura do registro
Membro*/
Vet[i].Altura = Double.parseDouble(
}
BArqFamilia.close(); // fechando arquivo
return Vet; // retorno do vetor Vet
/* 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;
/* abre um arquivo de gravao e armazena o nome deste
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));
/* 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));
}
37
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
int i;
for (i=0 ; i<5 ; 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++)
{
}
SaidaDados(Membro);
System.exit(0);
} // 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
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
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
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
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
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
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
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
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
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
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
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
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)
passando como parmetro o valor inteiro 1. (chamada 3)
passando com parmetro o valor inteiro 0. (chamada 4)
, 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.
multiplicao, ou seja, 2, para a chamada 2.
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
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 da classe
A explicao da execuo deste programa em Java o mesmo que do algoritmo em
pseudocdigo.
51
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
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
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
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 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
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 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 da classe
56
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!.
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
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.
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 + ...

Srie = 1/1 - 2/4 + 3/6 - 4/8 + 5/10 - 6/12 + ... - 50/100.
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.

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
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
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
26
38
11
47
95
compara 38 e 11 - efetua a troca
26
11
38
47
95
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
11
26
38
47
95
final do terceiro processo
60
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
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.
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
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.
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
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

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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

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

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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

public static void quicksort(int p, int q, int vetor[])
{
int x;
if (p < q)
{
x = particao(p, 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 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
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;
}
5.5. Exemplo de Ordenao em Pseudocdigo

Desenvolva um algoritmo que ordena 10 nmeros inteiros, utilizando a tcnica do bubblesort.
68
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.

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;
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
fimpara;
escrever(s);
fimalgoritmo.

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

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
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);
}
}

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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
int x;
if (p < q)
{
x = particao(p, 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;
}
{
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

Desenvolva um algoritmo que ordena 10 nmeros inteiros, utilizando a tcnica do mergesort.
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
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;
}
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
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.
elemento do vetor em ordem crescente. Utilizar bubblesort e mostrar passo a passo a execuo
do algoritmo.
elemento do vetor em ordem crescente. Utilizar quicksort e mostrar passo a passo a execuo do
algoritmo.
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.
elementos do vetor em ordem decrescente. Utilizar bubblesort e mostrar passo a passo a
execuo do algoritmo.
elementos do vetor em ordem decrescente. Utilizar quicksort e mostrar passo a passo a execuo
do algoritmo.
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.
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
3 x 5 e que coloque os elementos da matriz em ordem crescente. Utilizar quicksort e mostrar
3 x 5 e que coloque os elementos da matriz em ordem crescente. Utilizar mergesort e mostrar
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.
no vetor em ordem alfabtica. Utilizar bubblesort e mostrar passo a passo a execuo do
algoritmo.
no vetor em ordem alfabtica. Utilizar quicksort e mostrar passo a passo a execuo do algoritmo.
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.
fornecido pelo usurio. Utilizar bubblesort e mostrar passo a passo a execuo do algoritmo.
fornecido pelo usurio. Utilizar quicksort e mostrar passo a passo a execuo do algoritmo.
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
encontrar os dados de um funcionrio. Utilizar bubblesort e mostrar passo a passo a execuo do
algoritmo.
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.
encontrar os dados de um funcionrio. Utilizar mergesort e mostrar passo a passo a execuo do
algoritmo.
77
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
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
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
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
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
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
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
{
}
}
84
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);
25
topo = 1
topo = 0
32
25
topo = 1
85
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);
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
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
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
topo -1 numrico_inteiro; // campo topo
vetor [ tamanho] numrico_real; // campo vetor de capacidade
fimregistro;
lgico PilhaVazia( )
incio_mdulo
se (topo = -1)
ento
seno
retornar falso;
fimse;
fim_mdulo;
lgico PilhaCheia( )
incio_mdulo
se (topo >= tamanho-1)
ento
seno
retornar falso;
fimse;
fim_mdulo;
Empilhar (elemento numrico_real)
88
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
incio_mdulo
ento
topo topo + 1;
seno
escrever("Pilha Cheia");
fimse;
fim_mdulo;
numrico_real Desempilhar ()
incio_mdulo
Declarar
desempilhado 0.0 numrico_real;
se (PilhaVazia())
ento
seno
topo topo - 1;
fimse;
fim_mdulo;
ElementoTopo( )
incio_mdulo
se (topo >= 0)
ento
escrever ("O elemento do topo " , vetor[topo]);
seno
fimse;
fim_mdulo;
MostrarPilha( )
incio_mdulo;
Declarar
89
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
i numrico_inteiro;
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
vetor [ tamanho] alfanumrico; // campo vetor de capacidade
fimregistro;
lgico PilhaVazia( )
incio_mdulo
90
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
se (topo = -1)
ento
seno
retornar falso;
fimse;
fim_mdulo;
lgico PilhaCheia( )
incio_mdulo
ento
seno
retornar falso;
fimse;
fim_mdulo;
Empilhar (elemento alfanumrico)
incio_mdulo
ento
topo topo + 1;
seno
fimse;
fim_mdulo;
alfanumrico Desempilhar ()
incio_mdulo
Declarar
desempilhado 0 alfanumrico;
se (PilhaVazia())
ento
91
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
seno
topo topo - 1;
fimse;
fim_mdulo;
ElementoTopo( )
incio_mdulo
se (topo >= 0)
ento
seno
fimse;
fim_mdulo;
MostrarPilha( )
incio_mdulo;
Declarar
i numrico_inteiro;
fimpara;
fim_mdulo;
fim_algoritmo.
Algoritmo Exemplo2
inicio_algoritmo
Declarar
alfaPilha1 novo Pilha(5);
alfaPilha2 novo Pilha(5);
i, j numrico_inteiro;
entrada alfanumrico;
92
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())
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
vetor [ tamanho] numrico_inteiro; // campo vetor de capacidade
fimregistro;
lgico PilhaVazia( )
incio_mdulo
se (topo = -1)
ento
seno
retornar falso;
fimse;
fim_mdulo;
93
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
lgico PilhaCheia( )
incio_mdulo
ento
seno
retornar falso;
fimse;
fim_mdulo;
Empilhar (elemento numrico_inteiro)
incio_mdulo
ento
topo topo + 1;
seno
fimse;
fim_mdulo;
int Desempilhar ()
incio_mdulo
Declarar
desempilhado 0 numrico_inteiro;
se (PilhaVazia())
ento
seno
topo topo - 1;
fimse;
fim_mdulo;
ElementoTopo( )
94
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
incio_mdulo
se (topo >= 0)
ento
seno
fimse;
fim_mdulo;
MostrarPilha( )
incio_mdulo;
Declarar
i numrico_inteiro;
fimpara;
fim_mdulo;
fim_algoritmo.
Algoritmo Exemplo3
incio_algoritmo
Declarar
intPilha novo Pilha(10);
entrada i numrico_inteiro;
escrever("Digite um nmero inteiro");
ler(entrada);
se ((entrada mod 3) = 0)
ento
intPilha.Empilhar(entrada);
fimse;
fimpara;
intPilha.MostrarPilha( );
fim_algoritmo.
95
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
class Pilha
{
int tamanho;
int topo;
double vetor [ ];
Pilha (int tam)
{
topo = -1;
tamanho = tam;
vetor = new double[tam];
}
{
if (topo == -1)
{
return true;
}
else
{
return false;
}
}
{
{
return true;
}
else
{
return false;
}
}
public void Empilhar (double elemento)
{
{
96
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
topo = topo + 1;
}
else
{
}
}
public double Desempilhar ()
{
double desempilhado = 0.0;
if (PilhaVazia())
{
}
else
{
topo = topo 1;
}
}
{
if (topo >= 0)
{
}
else
{
}
}
{
int i;
for (i = topo ; i >= 0 ; i)
{
System.out.println("Elemento "+ vetor[i] +" posio " + i);
}
}
}
class Exemplo1
{
97
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);
}
}
vogais ordenadas numa estrutura de pilha.
class Pilha
{
int tamanho;
int topo;
char vetor [ ];
Pilha (int tam)
{
topo = -1;
tamanho = tam;
vetor = new char[tam];
}
{
if (topo == -1)
{
return true;
}
else
{
return false;
}
}
{
98
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
return true;
}
else
{
return false;
}
}
public void Empilhar (char elemento)
{
{
topo = topo + 1;
}
else
{
}
}
public char Desempilhar ()
{
char desempilhado = 0;
if (PilhaVazia())
{
}
else
{
topo = topo 1;
}
}
{
if (topo >= 0)
{
}
else
{
}
}
99
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
int i;
for (i = topo ; i >= 0 ; i)
{
}
}
}
class Exemplo2
{
{
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))
{
}
alfaPilha1.Empilhar(entrada);
while (!alfaPilha2.PilhaVazia())
{
}
}
alfaPilha1.MostrarPilha( );
System.exit(0);
}
}
100
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.
class Pilha
{
int tamanho;
int topo;
int vetor [ ];
Pilha (int tam)
{
topo = -1;
tamanho = tam;
}
{
if (topo == -1)
{
return true;
}
else
{
return false;
}
}
{
{
return true;
}
else
{
return false;
}
}
public void Empilhar (int elemento)
{
{
topo = topo + 1;
}
else
101
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
}
}
public int Desempilhar ()
{
int desempilhado = 0;
if (PilhaVazia())
{
}
else
{
topo = topo 1;
}
}
{
if (topo >= 0)
{
}
else
{
}
}
{
int i;
for (i = topo ; i >= 0 ; i)
{
}
}
}
class Exemplo3
{
{
Pilha intPilha = new Pilha(10);
int entrada, i;
102
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

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
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.
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
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.
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
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
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.
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
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

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
Logo, o CPF completo : 111.222.333-96
108
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

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
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
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
seno
retornar falso;
111
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
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
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
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;
}
// 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
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
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;
}
o primeiro elemento que est na fila.
public void ElementoInicio( )
{
if (!FilaVazia())
{
System.out.println("O primeiro elemento " + vetor[inicio]);
}
else
{
}
}
116
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
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
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
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
120
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

vetor [ tamanho] numrico_real; // armazena os elementos da fila
fimregistro;
lgico FilaVazia( )
incio_mdulo
se (total = 0)
ento
seno
retornar falso;
fimse;
fim_mdulo;
lgico FilaCheia( )
incio_mdulo
ento
seno
retornar falso;
fimse;
fim_mdulo;
Enfileirar (elemento numrico_real)
incio_mdulo
ento
fim fim + 1;
total total + 1;
ento
fim 0;
fimse;
seno
121
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;
ento
inicio 0;
fimse;
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
122
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;
entrada escrever(Digite um valor real);
ler(entrada)
realFila.Enfileirar(entrada);
fimpara;
realFila.MostrarFila( );
fim_algoritmo.
vogais ordenadas numa estrutura de fila.
Algoritmo Fila
incio_algoritmo
Definir
123
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

vetor [ tamanho] alfanumrico; // armazena os elementos da fila
fimregistro;
lgico FilaVazia( )
incio_mdulo
se (total = 0)
ento
seno
retornar falso;
fimse;
fim_mdulo;
lgico FilaCheia( )
incio_mdulo
ento
seno
retornar falso;
fimse;
fim_mdulo;
Enfileirar (elemento alfanumrico)
incio_mdulo
ento
fim fim + 1;
total total + 1;
ento
fim 0;
fimse;
seno
124
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
seno
inicio inicio + 1;
total total 1;
ento
inicio 0;
fimse;
fim_mdulo;
ElementoInicio( )
incio_mdulo
se (no FilaVazia())
ento
seno
fimse;
fim_mdulo;
MostrarFila( )
incio_mdulo
Declarar
aux inicio;
125
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

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;
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
ok falso;
fimse;
alfaFila.Enfileirar(aux);
126
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
fimpara;
se (ok)
ento
fimse;
fimse;
fimpara;
alfaFila.MostrarFila( );
fim_algoritmo.
fila somente os nmeros divisveis por trs, e depois mostre todos os elementos da fila.
Algoritmo Fila
incio_algoritmo
Definir
vetor [ tamanho] numrico_inteiro; // armazena os elementos da fila
fimregistro;
lgico FilaVazia( )
incio_mdulo
se (total = 0)
ento
seno
retornar falso;
fimse;
fim_mdulo;
lgico FilaCheia( )
incio_mdulo
127
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ento
seno
retornar falso;
fimse;
fim_mdulo;
Enfileirar (elemento numrico_inteiro)
incio_mdulo
ento
fim fim + 1;
total total + 1;
ento
fim 0;
fimse;
seno
fimse;
fim_mdulo;
numrico_inteiro Desenfileirar ()
incio_mdulo
Declarar
desenfileirado 0 numrico_inteiro;
se (FilaVazia())
ento
seno
inicio inicio + 1;
total total 1;
ento
128
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
inicio 0;
fimse;
fim_mdulo;
ElementoInicio( )
incio_mdulo
se (no FilaVazia())
ento
seno
fimse;
fim_mdulo;
MostrarFila( )
incio_mdulo
Declarar
aux inicio;
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
i numrico_inteiro;
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
class Fila
{
double vetor[];
Fila(int tam)
{
inicio = 0;
fim = 0;
total = 0;
tamanho = tam;
vetor = new double[tam];
}
{
if (total == 0)
{
return true;
}
else
{
return false;
}
}
130
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
{
return true;
}
else
{
return false;
}
}
public void Enfileirar (double elemento)
{
if (! FilaCheia( ))
{
fim = fim + 1;
total = total + 1;
if (fim >= tamanho)
{
fim = 0;
}
}
else
{
}
}
public double Desenfileirar ()
{
double desenfileirado = 0.0;
if (FilaVazia())
{
}
else
{
total = total 1;
{
inicio = 0;
}
}
}
131
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
if (!FilaVazia())
{
System.out.println("O primeiro elemento "+ vetor[inicio]);
}
else
{
}
}
{
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
{
{
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
vogais ordenadas numa estrutura de fila.
class Fila
{
char vetor[];
Fila(int tam)
{
inicio = 0;
fim = 0;
total = 0;
tamanho = tam;
vetor = new char[tam];
}
{
if (total == 0)
{
return true;
}
else
{
return false;
}
}
{
{
return true;
}
else
{
return false;
}
}
public void Enfileirar (char elemento)
{
if (! FilaCheia( ))
{
fim = fim + 1;
133
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
total = total + 1;
if (fim >= tamanho)
{
fim = 0;
}
}
else
{
}
}

public char Desenfileirar ()
{
char desenfileirado = 0.0;
if (FilaVazia())
{
}
else
{
total = total 1;
{
inicio = 0;
}
}
}
{
if (!FilaVazia())
{
System.out.println("O primeiro elemento "+ vetor[inicio]);
}
else
{
}
}
{
int i, aux;
aux = inicio;
134
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
for (i = 1 ; i <= total ; i++)

{
+
" posio " + i);
aux = aux + 1;
if (aux >= tamanho)
{
aux = 0;
}
}
}
}
class Exemplo2
{
{
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())
{
}
else
{
int total = alfaFila.total;
for (j = 1 ; j <= total ; j++)
{
aux = alfaFila.Desenfileirar();
if (entrada < aux && ok )
{
ok = false;
}
alfaFila.Enfileirar(aux);
}
if (ok)
{
}
}
}
135
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
alfaFila.MostrarFila();
System.exit(0);
}
}
fila somente os nmeros divisveis por trs, e depois mostre todos os elementos da fila.
class Fila
{
int vetor[];
Fila(int tam)
{
inicio = 0;
fim = 0;
total = 0;
tamanho = tam;
}
{
if (total == 0)
{
return true;
}
else
{
return false;
}
}
{
{
return true;
}
else
{
return false;
}
}
136
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
public void Enfileirar (int elemento)

{
if (! FilaCheia( ))
{
fim = fim + 1;
total = total + 1;
if (fim >= tamanho)
{
fim = 0;
}
}
else
{
}
}

public int Desenfileirar ()
{
int desenfileirado = 0;
if (FilaVazia())
{
}
else
{
total = total - 1;
{
inicio = 0;
}
}
}
137
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
if (!FilaVazia())
{
System.out.println("O primeiro elemento " + vetor[inicio]);
}
else
{
}
}
{
int i, aux;
aux = inicio;
for (i = 1 ; i <= total ; i++)
{
+
" posio " + i);
aux = aux + 1;
if (aux >= tamanho)
{
aux = 0;
}
}
}
}
class Exemplo3
{
{
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
}
}
7.7. Exerccios de Filas

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
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.
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.
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.
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
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.
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)
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
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)

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

operandos X e Y;
141
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

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.

Com base nessas informaes, resolva os exerccios 20, 21, 22, 23 e 24.
dessa expresso. O algoritmo deve utilizar as estruturas de dados de fila.
expresso escrita na forma posfixa. O algoritmo deve utilizar as estruturas de dados de fila.
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.
escrita na forma prefixa. O algoritmo deve utilizar as estrutura de dados de fila.
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
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
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.
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.
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.
posio
nmero
* soma = 1 * 1 + 2 * 1 + 3 * 3 + 4 * 3 + 5 * 3 + 6 * 0 = 39
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
total1 =
(numi * (11 i))
i=1

10
total2 =
(numi * (12 i))
i=1

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

144
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
8. Estrutura de Lista Ligada

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
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
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
seno
retornar falso;
fimse;
fim_mdulo;
147
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
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
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;

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
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
ento
escrever (O ltimo elemento da lista ligada , ultimo.elemento);
seno
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;
se (NoTemp.elemento = elemento)
ento
escrever ("No " , NoTemp.elemento , " posio " , i);
retornar NoTemp;
fimse;
i i + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar nulo;
151
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;
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
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
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)
{
int NroNos, posAux = 1;
NroNos = ContarNos( );
if (posicao <= 1)
{
}
else
{
if (posicao > NroNos)
{
154
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
}
else
{
while (posAux < (posicao 1))
{
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 NoAnt = null;
if (primeiro.elemento == elemento)
{
primeiro = primeiro.prox;
}
else
{
while (NoTemp != null && NoTemp.elemento != elemento)
{
NoAnt = NoTemp;
}
if(NoTemp != null)
{
NoAnt.prox = NoTemp.prox;
}
if (NoTemp == ultimo)
{
ultimo = NoAnt;
}
}
}
155
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.
{
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
{
}
}
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
}
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;
{
System.out.println("Elemento " + NoTemp.elemento + " posio "
+ i);
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
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
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
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
primeiro nulo No;
ultimo nulo No;
fimregistro;
lgico ListaVazia( )
incio_mdulo
ento
seno
retornar falso;
fimse;
fim_mdulo;
160
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

incio_mdulo
se (ListaVazia())
ento
ultimo novoNo;
seno
fimse;
primeiro novoNo;
fim_mdulo;
incio_mdulo
se (ListaVazia())
ento
primeiro novoNo;
seno
ultimo.prox novoNo;
fimse;
ultimo novoNo;
fim_mdulo;
incio_mdulo
Declarar
NoTemp primeiro No;
NoTemp NoTemp.prox;
fimenquanto;
retornar tamanho;
fim_mdulo;
161
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

incio_mdulo
Declarar
NoTemp primeiro No;
NroNos, posAux 1 numrico_inteiro;
se (posicao <= 1)
ento
seno
ento
seno
NoTemp NoTemp.prox;
posAux posAux + 1;
fimenquanto;
NoTemp.prox NovoNo;
fimse;
fimse;
fim_mdulo;
Remover (elemento numrico_real)
incio_mdulo
Declarar
NoTemp primeiro No;
NoAnt nulo No;
ento
seno
enquanto (NoTemp <> nulo e NoTemp.elemento <> elemento)
162
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
NoAnt NoTemp;
NoTemp NoTemp.prox;
fimenquanto;
se (NoTemp <> nulo)
ento
fimse;
ento
ultimo NoAnt;
fimse;
fimse;
fim_mdulo;
ElementoInicio( )
incio_mdulo
ento
seno
fimse;
fim_mdulo;
ElementoFinal( )
incio_mdulo
ento
seno
fimse;
fim_mdulo;
No BuscaNo (elemento numrico_real)
incio_mdulo
163
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
Declarar
NoTemp primeiro No;
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;
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
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.
incio_algoritmo
primeiro nulo No;
ultimo nulo No;
fimregistro;
lgico ListaVazia( )
incio_mdulo
ento
seno
retornar falso;
fimse;
fim_mdulo;
165
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

incio_mdulo
se (ListaVazia())
ento
ultimo novoNo;
seno
fimse;
primeiro novoNo;
fim_mdulo;
incio_mdulo
se (ListaVazia())
ento
primeiro novoNo;
seno
ultimo.prox novoNo;
fimse;
ultimo novoNo;
fim_mdulo;
incio_mdulo
Declarar
NoTemp primeiro No;
NoTemp NoTemp.prox;
fimenquanto;
retornar tamanho;
fim_mdulo;
incio_mdulo
166
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
Declarar
NoTemp primeiro No;
se (posicao <= 1)
ento
seno
ento
seno
NoTemp NoTemp.prox;
posAux posAux + 1;
fimenquanto;
NoTemp.prox NovoNo;
fimse;
fimse;
fim_mdulo;
Remover (elemento alfanumrico)
incio_mdulo
Declarar
NoTemp primeiro No;
NoAnt nulo No
ento
seno
enquanto (NoTemp nulo e NoTemp.elemento elemento)
NoAnt NoTemp;
NoTemp NoTemp.prox;
167
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
fimenquanto;
se (NoTemp <> nulo)
ento
fimse;
ento
ultimo NoAnt;
fimse;
fimse;
fim_mdulo;
ElementoInicio( )
incio_mdulo
ento
seno
fimse;
fim_mdulo;
ElementoFinal( )
incio_mdulo
ento
seno
fimse;
fim_mdulo;
No BuscaNo (elemento alfanumrico)
incio_mdulo
Declarar
NoTemp primeiro No;
168
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

ento
retornar NoTemp;
fimse;
i i + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar nulo;
fim_mdulo;
MostrarLista( )
incio_mdulo
Declarar
NoTemp primeiro No;
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;
ler(num);
se (alfaLista.primeiro = nulo)
ento
169
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.
incio_algoritmo
primeiro nulo No;
ultimo nulo No;
fimregistro;
lgico ListaVazia( )
incio_mdulo
ento
170
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
seno
retornar falso;
fimse;
fim_mdulo;
incio_mdulo
se (ListaVazia())
ento
ultimo novoNo;
seno
fimse;
primeiro novoNo;
fim_mdulo;
incio_mdulo
se (ListaVazia())
ento
primeiro novoNo;
seno
ultimo.prox novoNo;
fimse;
ultimo novoNo;
fim_mdulo;
incio_mdulo
Declarar
NoTemp primeiro No;
NoTemp NoTemp.prox;
171
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
fimenquanto;
retornar tamanho;
fim_mdulo;
incio_mdulo
Declarar
NoTemp primeiro No;
se (posicao <= 1)
ento
seno
ento
seno
NoTemp NoTemp.prox;
posAux posAux + 1;
fimenquanto;
NoTemp.prox NovoNo;
fimse;
fimse;
fim_mdulo;
Remover (elemento numrico_inteiro)
incio_mdulo
Declarar
NoTemp primeiro No;
NoAnt nulo No;
ento
172
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
seno
enquanto (NoTemp <> nulo e NoTemp.elemento elemento)
NoAnt NoTemp;
NoTemp NoTemp.prox;
fimenquanto;
se (NoTemp <> nulo)
ento
fimse;
ento
ultimo NoAnt;
fimse;
fimse;
fim_mdulo;
ElementoInicio( )
incio_mdulo
ento
seno
fimse;
fim_mdulo;
ElementoFinal( )
incio_mdulo
ento
seno
fimse;
fim_mdulo;
173
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
No BuscaNo (elemento numrico_inteiro)

incio_mdulo
Declarar
NoTemp primeiro No;
ento
retornar NoTemp;
fimse;
i i + 1;
NoTemp NoTemp.prox;
fimenquanto;
retornar nulo;
fim_mdulo;
MostrarLista( )
incio_mdulo
Declarar
NoTemp primeiro No;
NoTemp NoTemp.prox;
i i + 1;
fimenquanto;
fim_mdulo;
fimalgoritmo.
Algoritmo Exemplo3
incio_algoritmo
Declarar
intLista = novo ListaLigada();
i, num numrico_inteiro;
174
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

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.
class No
{
double elemento;
No prox;
No (double elem)
{
elemento = elem;
prox = null;
}
}
class ListaLigada
{
ListaLigada ()
{
primeiro = null;
ultimo = null;
}
{
{
return true;
}
else
175
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
return false;
}
}
{
if (ListaVazia())
{
ultimo = novoNo;
}
else
{
}
primeiro = novoNo;
}
{
if (ListaVazia())
{
primeiro = novoNo;
}
else
{
}
ultimo = novoNo;
}
{
int tamanho = 0;
{
}
return tamanho;
}
{
176
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
if (posicao <= 1)
{
}
else
{
{
}
else
{
{
}
}
}
}
public void Remover (double elemento)
{
No NoAnt = null;
{
}
else
{
{
NoAnt = NoTemp;
}
if(NoTemp != null)
{
}
{
ultimo = NoAnt;
}
}
}
177
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
if (! ListaVazia())
{
primeiro.elemento);
}
else
{
}
}
{
if (! ListaVazia())
{
System.out.println("O ltimo elemento "+
ultimo.elemento);
}
else
{
}
}
public No BuscarNo (double elemento)
{
int i = 1;
{
{
+ i);
return NoTemp;
}
i = i + 1;
}
return null;
}
{
int i = 1;
178
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
System.out.println("Elemento " + NoTemp.elemento + " posio
" + i);
i = i + 1;
}
}
}
class Exemplo1
{
{
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.
class No
{
char elemento;
No prox;
No (char elem)
{
elemento = elem;
prox = null;
}
}
class ListaLigada
{
179
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
ListaLigada ()
{
primeiro = null;
ultimo = null;
}
{
{
return true;
}
else
{
return false;
}
}
{
if (ListaVazia())
{
ultimo = novoNo;
}
else
{
}
primeiro = novoNo;
}
{
if (ListaVazia())
{
primeiro = novoNo;
}
else
{
}
ultimo = novoNo;
}
{
int tamanho = 0;
180
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
}
return tamanho;
}
{
if (posicao <= 1)
{
}
else
{
{
}
else
{
{
}
}
}
}
public void Remover (char elemento)
{
No NoAnt = null;
{
}
else
{
181
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
NoAnt = NoTemp;
}
if(NoTemp != null)
{
}
{
ultimo = NoAnt;
}
}
}
{
if (! ListaVazia())
{
primeiro.elemento);
}
else
{
}
}
{
if (! ListaVazia())
{
ultimo.elemento);
}
else
{
}
}
public No BuscarNo (char elemento)
{
int i = 1;
{
182
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
+ i);
return NoTemp;
}
i = i + 1;
}
return null;
}
{
int i = 1;
{
" + i);
i = i + 1;
}
}
}
class Exemplo2
{
{
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
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.
class No
{
int elemento;
No prox;
No (int elem)
{
elemento = elem;
prox = null;
}
}
class ListaLigada
{
ListaLigada ()
{
primeiro = null;
ultimo = null;
}
{
{
return true;
}
else
{
return false;
}
}
184
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
if (ListaVazia())
{
ultimo = novoNo;
}
else
{
}
primeiro = novoNo;
}
{
if (ListaVazia())
{
primeiro = novoNo;
}
else
{
}
ultimo = novoNo;
}
{
int tamanho = 0;
{
}
return tamanho;
}
{
if (posicao <= 1)
{
}
185
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
else
{
{
}
else
{
{
}
}
}
}
public void Remover (int elemento)
{
No NoAnt = null;
{
}
else
{
{
NoAnt = NoTemp;
}
if(NoTemp != null)
{
}
{
ultimo = NoAnt;
}
}
}
{
if (! ListaVazia())
186
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
primeiro.elemento);
}
else
{
}
}
{
if (! ListaVazia())
{
ultimo.elemento);
}
else
{
}
}
public No BuscarNo (int elemento)
{
int i = 1;
{
{
+ i);
return NoTemp;
}
i = i + 1;
}
return null;
}
{
int i = 1;
{
187
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

" + i);
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

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
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.
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.
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.
caracteres que o representam e que so: 0 e 1. Podemos representar um nmero decimal em
189
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.
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.
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

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.

Com base nessas informaes, resolva os exerccios 11, 12, 13, 14 e 15.
dessa expresso. O algoritmo deve utilizar as estruturas de dados de listas ligadas.
expresso escrita na forma posfixa. O algoritmo deve utilizar as estruturas de dados de listas
ligadas.
expresso escrita na forma infixa. O algoritmo deve utilizar as estruturas de dados de listas
ligadas.
190
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.
escrita na forma prefixa. O algoritmo deve utilizar as estrutura de dados de listas ligadas.
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.
carros e que possua um nico porto para entrada e sada de carros na extremidade 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.
carros e que possua um nico porto para entrada e sada de carros no centro 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
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.
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)
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)

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

i=1

10

i=1

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

9. Estrutura de rvores

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
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
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
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
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
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
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
ento
200
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
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;
ento
temp.dir filho.esq;
filho.esq tempNo.esq;
fimse;
filho.dir tempNo.dir;
ento
pai.esq filho;
seno
pai.dir filho;
fimse;
fimse;
fimse;
fimse;
fimenquanto;
fimmdulo;
201
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)
{
System.out.println(arv.valor);
}
}
public void exibirNoEsq()
{
}
202
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)
{
System.out.println (arv.valor);
}
}
public void exibirNoDir()
{
}
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
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 (pai.esq == tempNo)
{
pai.esq = tempNo.esq;
}
else
{
pai.dir = tempNo.esq;
}
}
else
{
if (tempNo == null)
{
{
pai.esq = tempNo.dir;
}
else
204
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
pai.dir = tempNo.dir;
}
}
else
{
{
filho.esq = tempNo.esq;
}
filho.dir = tempNo.dir;
{
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
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
seno
ento
seno
fimse;
fimse;
retornar arvore;
fim_mdulo;
incio_mdulo
fim_mdulo;
incio_mdulo
se (arv <> nulo)
ento
fimse;
fim_mdulo;
exibirNoEsq()
incio_mdulo
206
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
fim_mdulo;
incio_mdulo
se (arv <> nulo)
ento
fimse;
fim_mdulo;
exibirNoDir()
incio_mdulo
fim_mdulo;
incio_mdulo
exibirNoEsq( );
exibirRaiz( );
exibirNoDir( );
fim_mdulo;
exibirRaiz()
incio_mdulo
fim_mdulo;
incio_mdulo
tempNo Raiz;
pai null;
filho Raiz;
pai tempNo;
207
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
ento
tempNo tempNo.esq;
seno
tempNo tempNo.dir;
fimse;
se (tempNo = nulo)
ento
fimse;
se (pai = nulo)
ento
ento
Raiz tempNo.esq;
seno
ento
Raiz tempNo.dir;
seno
fimpara;
ento
temp.dir filho.esq;
filho.esq Raiz.esq;
fimse;
filho.dir Raiz.dir;
Raiz filho;
fimse;
fimse;
seno
ento
ento
pai.esq tempNo.esq;
208
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
seno
pai.dir tempNo.esq;
fimse;
seno
se (tempNo = nulo)
ento
ento
pai.esq tempNo.dir;
seno
pai.dir tempNo.dir;
fimse;
seno
fimpara;
ento
temp.dir filho.esq;
fimse;
ento
pai.esq filho;
seno
pai.dir filho;
fimse;
fimse;
fimse;
fimse;
fimenquanto;
fimmdulo;
fim_algoritmo.
Algoritmo teste
incio_algoritmo
209
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
fimregistro;
Fim_algoritmo.
incio_algoritmo
Declarar
Raiz BIntNo;
BIntNo inserir (arvore BIntNo, novoNo numrico_inteiro)
incio_mdulo
210
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
se (arvore = nulo)
ento
seno
ento
seno
fimse;
fimse;
retornar arvore;
fim_mdulo;
incio_mdulo
fim_mdulo;
incio_mdulo
se (arv <> nulo)
ento
fimse;
fim_mdulo;
exibirNoEsq()
incio_mdulo
fim_mdulo;
211
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

incio_mdulo
se (arv <> nulo)
ento
fimse;
fim_mdulo;
exibirNoDir()
incio_mdulo
fim_mdulo;
incio_mdulo
exibirNoEsq( );
exibirRaiz( );
exibirNoDir( );
fim_mdulo;
exibirRaiz()
incio_mdulo
fim_mdulo;
incio_mdulo
tempNo Raiz;
pai null;
filho Raiz;
pai tempNo;
ento
tempNo tempNo.esq;
212
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
seno
tempNo tempNo.dir;
fimse;
se (tempNo = nulo)
ento
fimse;
se (pai = nulo)
ento
ento
Raiz tempNo.esq;
seno
ento
Raiz tempNo.dir;
seno
fimpara;
ento
temp.dir filho.esq;
filho.esq Raiz.esq;
fimse;
filho.dir Raiz.dir;
Raiz filho;
fimse;
fimse;
seno
ento
ento
pai.esq tempNo.esq;
seno
pai.dir tempNo.esq;
213
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
fimse;
seno
se (tempNo = nulo)
ento
ento
pai.esq tempNo.dir;
seno
pai.dir tempNo.dir;
fimse;
seno
fimpara;
ento
temp.dir filho.esq;
fimse;
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

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.
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
fimregistro;
Fim_algoritmo.
incio_algoritmo
Declarar
Raiz BIntNo;
BIntNo inserir ( rvore BIntNo, novoNo numrico_inteiro)
incio_mdulo
se ( rvore = nulo)
ento
215
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
seno
ento
seno
fimse;
fimse;
retornar arvore;
fim_mdulo;
incio_mdulo
fim_mdulo;
incio_mdulo
se (arv <> nulo)
ento
fimse;
fim_mdulo;
exibirNoEsq()
incio_mdulo
fim_mdulo;
incio_mdulo
se (arv <> nulo)
ento
fimse;
216
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
fim_mdulo;
exibirNoDir()
incio_mdulo
fim_mdulo;
incio_mdulo
exibirNoEsq( );
exibirRaiz( );
exibirNoDir( );
fim_mdulo;
exibirRaiz()
incio_mdulo
fim_mdulo;
incio_mdulo
tempNo Raiz;
pai null;
filho Raiz;
pai tempNo;
ento
tempNo tempNo.esq;
seno
tempNo tempNo.dir;
fimse;
se (tempNo = nulo)
ento
fimse;
217
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
se (pai = nulo)
ento
ento
Raiz tempNo.esq;
seno
ento
Raiz tempNo.dir;
seno
fimpara;
ento
temp.dir filho.esq;
filho.esq Raiz.esq;
fimse;
filho.dir Raiz.dir;
Raiz filho;
fimse;
fimse;
seno
ento
ento
pai.esq tempNo.esq;
seno
pai.dir tempNo.esq;
fimse;
seno
se (tempNo = nulo)
ento
ento
pai.esq tempNo.dir;
218
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
seno
pai.dir tempNo.dir;
fimse;
seno
fimpara;
ento
temp.dir filho.esq;
fimse;
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;
ler(num);
se (num mod 3 = 0)
ento
arv.inserirNo(num);
219
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.
class BIntNo
{
int valor;
BIntNo esq, dir;
BIntNo(int novoValor)
{
valor = novoValor;
}
}
class ArvoreBinaria
{
private BIntNo Raiz;
{
if (arvore == null)
{
}
else
{
{
}
else
{
}
}
return arvore;
}
220
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
}
{
if (arv != null)
{
}
}
{
if (arv != null)
{
}
}
{
}
{
}
{
}
public void exibirNo()
{
exibirNoEsq();
exibirRaiz();
exibirNoDir();
}
{
try
{
221
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
tempNo = Raiz;
pai = null;
filho = Raiz;
{
pai = tempNo;
{
}
else
{
}
}
if (tempNo == null)
{
}
if (pai == null)
{
{
Raiz = tempNo.esq;
}
else
{
{
Raiz = tempNo.dir;
}
else
{
{
}
Raiz = filho;
}
}
}
else
{
{
222
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
}
else
{
}
}
else
{
if (tempNo == null)
{
{
}
else
{
}
}
else
{
{
}
{
pai.esq = filho;
}
else
{
pai.dir = filho;
}
}
}
}
}
{
}
}
}
223
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.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.
class BIntNo
{
int valor;
BIntNo esq, dir;
{
valor = novoValor;
}
}
class ArvoreBinaria
{
{
if (arvore == null)
{
}
224
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
else
{
{
}
else
{
}
}
return arvore;
}
{
}
{
if (arv != null)
{
}
}
{
if (arv != null)
{
}
}
{
}
{
}
{
225
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
}
{
exibirNoEsq();
exibirRaiz();
exibirNoDir();
}
{
try
{
tempNo = Raiz;
pai = null;
filho = Raiz;
{
pai = tempNo;
{
}
else
{
}
}
if (tempNo == null)
{
}
if (pai == null)
{
{
Raiz = tempNo.esq;
}
else
{
{
Raiz = tempNo.dir;
}
else
{
226
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
}
Raiz = filho;
}
}
}
else
{
{
{
}
else
{
}
}
else
{
if (tempNo == null)
{
{
}
else
{
}
}
else
{
{
}
{
227
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
pai.esq = filho;
}
else
{
pai.dir = filho;
}
}
}
}
}
{
}
}
}
class teste
{
{
arv.exibirNo();
System.exit(0);
}
}
nmero inteiro")));
nmero inteiro")));
nmero inteiro")));
nmero inteiro")));
nmero inteiro")));
rvore binria, de forma ordenada, somente os nmeros divisveis por trs. Esse algoritmo
deve, ainda, mostrar todos os elementos da rvore binria.
class BIntNo
{
int valor;
BIntNo esq, dir;
228
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
valor = novoValor;
}
}
class ArvoreBinaria
{
{
if (arvore == null)
{
}
else
{
{
}
else
{
}
}
return arvore;
}
{
}
{
if (arv != null)
{
}
}
{
if (arv != null)
{
}
}
229
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II

{
}
{
}
{
}
{
exibirNoEsq();
exibirRaiz();
exibirNoDir();
}
{
try
{
tempNo = Raiz;
pai = null;
filho = Raiz;
{
pai = tempNo;
{
}
else
{
}
}
if (tempNo == null)
{
}
if (pai == null)
{
230
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
{
Raiz = tempNo.esq;
}
else
{
{
Raiz = tempNo.dir;
}
else
{
{
}
Raiz = filho;
}
}
}
else
{
{
{
}
else
{
}
}
else
{
if (tempNo == null)
{
{
}
else
{
}
}
231
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
else
{
{
}
{
pai.esq = filho;
}
else
{
pai.dir = filho;
}
}
}
}
}
{
}
}
}
class teste
{
{
int i, num;
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
9.7. Exerccios de rvores

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
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
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
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
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
237
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
238
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
239
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
240
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
241
IBTA 3233
ADS / BD / RC / SI
Estrutura de Dados
Semestre II
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
______________________________________________________________________________
242

Estrutura de Dados

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Estrutura de Dados

Enviado por

Direitos autorais:

Formatos disponíveis

ESTRUTURA DE DADOS

Autora: Lucy Mari Tabuti

Revises: Dezembro de 2005 por Lucy M. Tabuti

2 Edio 6 Impresso 2008

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

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

2. Estrutura de Dados Heterognea - Registros

2.1. Definio de Registros

<tipo da varivel> <varivel3> ;

2.2. Declarao de Registros

2.3. Atribuindo Valores ao Registro

2.4. Mostrando os Elementos de um Registro

2.5. Uso de Vetores de Registros

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

2.6. Exemplos de Registros em Pseudocdigo

Idade numrico_inteiro; // campo idade

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

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

2.7. Exemplos de Registros em Java

2.8. Exerccios de Registros

analista de recursos humanos

chefe de recursos humanos

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

c. Classificar por ordem de nome os registros cadastrados.

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

3.1. Definio de Arquivo

3.2. Declarao de Arquivos

3.3. Manipulao de Arquivos

3.3.1. Abertura de Arquivo em Pseudocdigo e em Java

3.3.2. Fechamento de arquivo em pseudocdigo e em Java

fechar (<nome do arquivo>);

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

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

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

3.4. Exemplo de Arquivos em Pseudocdigo

// definio do tipo registro RegistroFamilia com os campos abaixo

tipo ArquivoFamilia = arquivo de RegistroFamilia

RegistroFamilia [ ] EntradaDados (Vet[ ] RegistroFamilia)

3.5. Exemplo de Arquivos em Java

} // fim da definio do tipo registro

} // fim do construtor do registro

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

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

3.6. Exerccios de Arquivos

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

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

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

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

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

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

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

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

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

de fitas premiadas com um Oscar.

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

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

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

4.1. Definio de Recurso

4.2. Uso da Recurso em Pseudocdigo e em Java

se o problema pequeno, resolva-o diretamente;

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

Outra soluo recursiva em pseudocdigo:

numrico_inteiro maximo2 (n numrico_inteiro , v[ ] numrico_inteiro)