Aula04

Pilhas,Filas
rvores
UAB - IFTM
Prof. Roitier Campos Gonalves
Estrutura de Dados
Licenciatura em Computao
2015

Pilhas
Para entendermos o funcionamento de uma estrutura de pilha,
podemos fazer uma analogia com uma pilha de pratos. Se quisermos
adicionar um prato na pilha, o colocamos no topo. Para pegar um
prato da pilha, retiramos o do topo. Assim, temos que retirar o prato
do topo para ter acesso ao prximo prato. A estrutura de pilha
funciona de maneira anloga. Cada novo elemento inserido no topo
e s temos acesso ao elemento do topo da pilha. Portanto As pilhas
so estruturas baseadas no princpio LIFO (last in, first out), na qual os
dados que foram inseridos por ltimo na pilha sero os primeiros a
serem removidos.
Existem trs operaes bsicas que devem ser implementadas
numa estrutura de pilha: operao para empilhar um novo elemento,
inserindo-o no topo, operao para desempilhar um elemento,
removendo-o do topo e a operao para consultar qual elemento est
no topo da pilha. comum nos referirmos a essas operaes pelos
termos em ingls push (empilhar) e pop (desempilhar).

Pilhaesttica
OperaesBsicas:Inserirelemento
Todo elemento que vai ser inserido em uma pilha
colocado no final da estrutura. Observe a ilustrao da chegada
de trs livros colocados na pilha.

OperaesBsicas:Inserirelemento
/* Funcao para inserir um novo livro na if (tampilha <30) { /* Se ainda tem vaga
na pilha */
pilha */
void inserir () {

livro[tampilha] = ll;

int continuar;

Tampilha++;

do{

printf(\n\nInserido
Sucesso!!!!\n\n);

cabec();

printf(\nColocar livro no topo da else /* Pilha cheia*/

pilha \n);
printf(\nCodigo do livro: );
scanf(%d,&ll.codigo);
printf(\nTitulo do Livro: );
fflush(stdin);

printf(\n\nPilha
inserido!!!!\n\n);

com

cheia,

Livro

nao

printf(\n Continuar inserindo (1-sim/2nao)? );

scanf(%d,&continuar);

gets(ll.titulo);

}while (continuar == 1); // verifica se

quer continuar inserindo livros

// Inserir livro na pilha

OperaesBsicas:Consultartopodapilha
Em uma pilha, a consulta feita apenas do elemento
do topo, ou seja, o ltimo elemento a ser inserido. Assim,
teremos a informao de qual ser o prximo elemento a ser
retirado. Na ilustrao a seguir o elemento do topo da pilha
o livro de cdigo 4 e ttulo Fsica, armazenado na posio 3 do
vetor. Quando o vetor estiver vazio, apresentada uma
mensagem de pilha vazia ao usurio.

OperaesBsicas:Consultartopodapilha
printf(----------------------------------------------------\n);

/* Consultar topo da pilha*/

void consultatopo() {

cabec();
printf(\nConsulta
pilha\n);

topo

da

else
printf(\n\nA
vazia!!\n\n);

if (tampilha != 0) {

pilha

printf(\n\nCod Titulo \n);

printf(\n\nTecle enter
voltar para o menu\n);

printf(---------------------------------------------------\n);

getche();

printf(%2d
%-20s
livro[tampilha-1].codigo,
livro[tampilha-1].titulo);

\n,

esta
para

OperaesBsicas:Removertopodapilha
Em uma pilha, o elemento removido sempre o que
chegou h menos tempo, ou seja, o elemento da ltima posio
do vetor. Na ilustrao a seguir iremos remover o elemento do
topo da pilha, neste caso, o elemento da posio 3.
No h necessidade de deslocamentos.

OperaesBsicas:Removertopodapilha
/* remover um livro da pilha */
void retirapilha() {
int i, confrem, continuar;

if (confrem ==1) { // confirma que quer

remover
tampilha--;

do{ cabec();

printf(\n\n
Retirado
sucesso!!!!\n\n);

printf(\nRetira livro do topo da pilha \n);

if (tampilha != 0) {// verifica se tem

elementos na pilha

else // cancelou a remocao

printf(\n\nCodigo Titulo Editora\n);

printf(---------------------------------------------------\
n);
printf(%6d %-20s \n, livro[tampilha1].codigo, livro[tampilha-1].titulo);
printf(---------------------------------------------------\
n);

da

Pilha

com

printf(\n\n Retirada cancelada\n\n);

}
else // pilha vazia
printf(\n\nPilha vazia!!\n\n);
printf(\n\nDeseja retirar outro livro(1-sim, 2nao)? );
scanf(%d,&continuar);

printf(\n\nconfirma retirada do livro (1-sim,

2-nao)? );

}while (continuar ==1);

retirando livro da pilha

scanf(%d,&confrem);

//

continuar

OperaesBsicas:
Listagemdetodososelementosdapilha
A operao de listagem
possibilita a visualizao dos dados
de todos os elementos da pilha.
feita uma varredura no vetor e todos
os dados de todos os elementos so
apresentados ao usurio.

printf(----------------------------------------------------\n);
for (i=tampilha-1;i>=0;i--)
printf(%6d %-20s
livro[i].titulo);

\n,

livro[i].codigo,

printf(----------------------------------------------------\n);

O cdigo abaixo representa a

impresso de todos os elementos:
printf(\n\nQuantidade de livros na pilha =
%d\n,tampilha);

/* Lista todos os livros da pilha */

void listar () {

else

int i;

printf(\n\n Nao tem nenhum livro na

pilha);

cabec();
printf(\nListagem dos livros da pilha\n);

printf(\n\n\nTecle enter para voltar para o

menu\n);

if (tampilha != 0) {

getche();

printf(\n\nCodigo Titulo Editora\n);

Pilhadinmica
Operaesbsicas:Inserirelemento
Todo elemento que vai ser inserido em uma pilha
colocado no final da estrutura. Observe a ilustrao da chegada
de trs livros colocados na pilha.

Operaesbsicas:Inserirelemento
Cada elemento que chega, ser inserido no incio da
estrutura. Portando, o ponteiro inicio sempre modificado a cada
insero.
Na ilustrao a pilha inicia vazia, com o ponteiro incio
apontando para NULL (passo 1).
No (passo 2) um elemento inserido na pilha, por ser o
primeiro, ele no tem vizinho e o ponteiro incio passa a apontar
para o novo n (endereo 1080).
No (passo 3) um novo elemento inserido, o ponteiro
incio deve ser atualizado e o novo n deve apontar para o
elemento que estava no incio da pilha (endereo 1080).
No (passo 4), um novo elemento inserido e as
atualizaes dos ponteiros devem ser feitas.

Operaesbsicas:Inserirelemento
/* Funcao para inserir um novo no, no gets(titl);
inicio da pilha */
// Inserir livro na pilha
void inserir () {

tampilha++;

TLivro *novono;

//Aloca memoria para o novo livro

novono = (TLivro *) malloc(sizeof(TLivro));

int i, codl, continuar;

novono->codigo = codl;

char titl[30];

for (i=0;i<=29;i++)

do{

novono->titulo[i] =titl[i];

cabec();

novono->prox = inicio;

printf(\nColocar
pilha \n);

livro

no

printf(\nCodigo do livro: );
scanf(%d,&codl);

topo

da inicio = novono;
printf(\n\nInserido com Sucesso!!!!\n\n);
printf(\nContinuar inserindo (1-sim/2-nao)? );
scanf(%d,&continuar);

printf(\nTitulo do Livro: );

}while (continuar == 1); // verifica se quer

continuar inserindo livros

fflush(stdin);

Operaesbsicas:Consultartopodapilha
Em uma pilha, a
consulta feita apenas do
elemento do topo, ou seja, o
ltimo elemento a ser inserido,
que neste caso o elemento
apontado pelo ponteiro inicio.
Se o ponteiro incio
aponta para NULL significa que
a pilha est vazia.

/* Consultar livro do topo da pilha */

void consultatopo() {
cabec();
printf(\nConsulta topo da pilha\n\n);
if (inicio != NULL) {
printf(\n\nCodigo Titulo \n);
printf(-----------------------------------------------------\n);
printf(%6d
>titulo);

%-20s

\n,

inicio->codigo,

inicio-

printf(-----------------------------------------------------\n);
}
else
printf(\nA pilha est vazia!!\n\n);
printf(\n\nTecle enter para voltar para o menu\n);
getche();
}

Operaesbsicas:Removertopodapilha
Em uma pilha, o elemento removido sempre o que
chegou h menos tempo, ou seja, o elemento apontado pelo
ponteiro inicio. Na ilustrao iremos remover o elemento do topo
da pilha. O ponteiro incio deve ser atualizado, apontando para o
elemento que era vizinho do elemento removido.

Operaesbsicas:Removertopodapilha
/* remover livro do topo da pilha */

if (confrem ==1) { // confirma que quer remover

void retirapilha() {

inicio = inicio->prox;

int confrem, continuar;

free(noatual); // libera memoria do no removido

do{

tampilha--;

cabec();

printf(\n\n
Retirado
sucesso!!!!\n\n);

printf(\nRetira livro do topo da pilha \n);

noatual = inicio; //ponteiro que ira apontar para o
primeiro no
if (inicio != NULL) { // verifica se tem elementos
na pilha
printf(\n\nCodigo Titulo \n);
printf(---------------------------------------------------\n);
printf(%6d %-20s \n, inicio->codigo, inicio>titulo);
printf(---------------------------------------------------\n);
printf(\n\nconfirma retirada do livro (1-sim, 2nao)? );
scanf(%d,&confrem);

da

Pilha

com

}
else // cancelou a remocao
printf(\n\n Retirada cancelada\n\n);
}
else // pilha vazia
printf(\n\nPilha vazia!!\n\n);
printf(\n\nDeseja retirar outro livro(1-sim, 2nao)? );
scanf(%d,&continuar);
}while (continuar ==1); // continuar retirando
livro da pilha
}

Operaesbsicas:
Listagemdetodososelementosdapilha
A operao de listagem
possibilita a visualizao dos
dados de todos os elementos
da pilha. feita uma varredura
na pilha e todos os dados de
todos
os
elementos
so
apresentados ao usurio.

printf(%6d %-20s \n, noatual->codigo,

noatual->titulo);

/* Lista todos os livros da pilha */

void listar () {

else

noatual = inicio; // no auxiliar marca o inicio da lista

cabec();
printf(\nListagem dos livros da pilha\n\n);
if (inicio != NULL) {
printf(\n\nCodigo Titulo \n);

noatual = noatual->prox; // Faz noatual

apontar para proximo no
}
printf(----------------------------------------------------\n);
printf(\n\nQuantidade de livros na pilha =
%d\n,tampilha);

printf(\n\n
pilha);

Nao tem nenhum livro na

printf(\n\n\nTecle enter para voltar para o

menu\n);

printf(----------------------------------------------------\n);

getche();

while( noatual != NULL) { // percorre toda a pilha

AtividadeComplementar
1) A Figura 4.6 representa uma Insero do elemento B;
pilha implementada atravs de
Remoo;
um vetor de 10 posies.
Observe que so realizadas as Insero do elemento WW;
operaes de remoo e
insero na Pilha. Qual seria a
nova configurao da Pilha a) Quantos elementos aps as
aps as seguintes operaes:
remoes e inseres possui o
vetor?

Remoo;
b) Quantas posies aps as

Remoo;
remoes e inseres possui o

Remoo;
vetor?

Insero do elemento A;

c) Faa o desenho da nova

Pilha.

...AtividadeComplementar
2) Implemente uma Pilha
Esttica em linguagem C que
armazene como dados, 10
(dez) nomes de Pessoas.
Implemente as operaes de
insero, remoo e consulta.
Observao: colocar o cdigo
complemento

3) Implemente o cdigo da
questo anterior para Pilha
Dinmica. bservao: colocar
o cdigo complemento

Filas
Para determinadas aplicaes imposto um critrio que
restringe a insero e retirada dos elementos que compem um
conjunto de dados. O critrio escolhido impe uma ordem ao
conjunto de dados, ordem esta que, em geral, no depende da
ordem natural dos valores dos dados.
O principal critrio aplicados s FILAS FIFO ( First In
First Out), ou seja, o rimeiro que entra o primeiro que sai).
Desta forma, o critrio FIFO o que rege, por exemplo, o
funcionamento de uma fila de pessoas em um banco ou de um
caixa de supermercado: as pessoas so atendidas na ordem em
que chegaram, ou seja, as pessoas que iniciaram a fila sero
atendidas primeiro, na frente das que chegaram depois.
Obs: A pilha segue o critrio LIFO (Last In First Out).

Formasderepresentaodasfilas
A implementao de filas se distingue pela natureza dos
seus elementos (tipo do dado armazenado), pela maneira como
os elementos so armazenados (esttica ou dinamicamente) e
pelas operaes disponveis para o tratamento da fila. Portanto,
uma fila tambm pode ser representada, de duas formas:

Esttica: caracteriza-se por utilizar um vetor (estrutura

esttica) para representar a fila;
Dinmica: caracteriza-se por utilizar uma lista encadeada
(estrutura dinmica) para representar a fila.

Filaesttica
As filas podem usar vetor, ou seja, uma estrutura
esttica para armazenar os dados, como pode ser constatado na
figura a seguir. Um vetor de 10 (dez) posies, dos quais esto
sendo utilizadas 4 posies. No incio da Fila, posio 1 tem-se o
elemento A e no final da Fila, posio 4 tem-se o elemento D.
Observe que a Fila possui 4 elementos, mas o vetor suporta 10,
ou seja, existem 6 posies vazias.

OperaesBsicas
I. criar uma fila vazia;
II. inserir elemento no final da fila;
III. remover o elemento do incio da fila;
IV. consultar o primeiro da fila;
V. listar todos os elementos da fila.
Para um melhor entendimento do que seja uma fila,
temos a seguir a implementao de uma SIMULAO de fila de
matrculas no curso tcnico de informtica.

FilaVazia

Operaesbsicas:Inserirelementos
Todo elemento que vai ser inserido em uma fila
colocado no final da estrutura. Os alunos vo sendo inseridos por
ordem de chegada. No exemplo ilustrao a seguir so inseridos
3 alunos na fila. Ou seja, a fila estava vazia, agora tem 3
elementos.

Operaesbsicas:Inserirelementos
void inserir () {

scanf(%d,&Al.Polo);

int continuar;

if (tamfila <30) { /* Se ainda tem vaga na

fila */

do {

Aluno[tamfila] = Al;

printf(\n Chegada de novo aluno

na fila \n);

tamfila++;

printf(\n Numero da Matricula: );

printf(\n\nAluno
Sucesso!!!!\n\n);

Inserido

scanf(%d,&Al.Matricula);

else /* Fila cheia*/

printf(\n Nome: );

printf(\n\nFila
cheia,
inserido!!!!\n\n);

fflush(stdin);

printf(\n
nao)?);

gets(Al.Nome);
printf(\n
Polo
do
Batalha, 2-Valenca): );

Continuar

}while (continuar == 1);

}

Aluno

inserindo

scanf(%d,&continuar);

Aluno(1-

com

nao

(1-sim/2-

Operaesbsicas:Consultarprimeirodafila
Em uma fila, a consulta feita apenas do primeiro
elemento da fila. Assim, teremos a informao de qual ser o
prximo elemento a ser retirado. Na Figura a seguir, o primeiro
elemento da fila a aluna Maria, com matrcula 1212.

Operaesbsicas:Consultarprimeirodafila
void consultarprimeiro ( ) {
cabec();
printf(\nConsulta
aluno da fila\n);

primeiro

}
else

if (tamfila != 0) {
printf(\nMatricula
Polo\n);

printf(----------------------------------------------\n);

Nome

printf(---------------------------------------------\n);
printf(%4d %-15s %2d\n,
Aluno[0].Matricula,
Aluno[0].Nome, Aluno[0].Polo);

printf(\n\nA
vazia!!\n\n);

fila

printf(\n\nTecle enter
voltar para o menu\n);
getche();
}

est
para

Operaesbsicas:Removerprimeirodafila
Observando a Figura a seguir, em uma fila, o elemento removido
sempre o que chegou h mais tempo, ou seja, o elemento da primeira posio
do vetor. Na figura abaixo iremos remover o primeiro elemento da fila (neste
caso, Maria-1212). Os elementos seguintes devem ser deslocados uma
posio a frente. Com isso, o segundo elemento da fila passa a ser o primeiro,
o terceiro passa a ser o segundo e assim por diante.

Operaesbsicas:Removerprimeirodafila
void retirafila ( ) {

if (confrem ==1) {

int i, confrem, continuar;

for (i=0; i<tamfila; i++)

do{

Aluno[i] = Aluno[i+1];

printf(\nRetira primeiro aluno da fila \n);

if (tamfila != 0) {

tamfila--;
printf(\n\n Aluno retirado da fila com
sucesso!!!!\n\n);

printf(\n\nMatricula Nome Polo\n);

printf(-----------------------------------------\n);

else

printf(%4d
%-15s
Aluno[0].Matricula,

printf(\n\n Retirada cancelada\n\n);

%2d\n,

Aluno[0].Nome, Aluno[0].Polo);

else

printf(--------------------------------------------------\n);

printf(\n\nFila vazia!!\n\n);

2-nao)? );
printf(\n\n Confirma retirada do aluno (1sim,
scanf(%d,&confrem);

printf(\n\nDeseja retirar outro aluno(1-sim, 2nao)? );

scanf(%d,&continuar);
}while (continuar ==1);
}

Operaesbsicas:
Listagemdetodososelementosdafila
A operao de listagem
possibilita a visualizao dos
dados de todos os elementos
da fila. feita uma varredura
no vetor e todos os dados de
todos
os
elementos
so
apresentados.

void listar () {
int i;
cabec ( );
printf(\nListagem de alunos da fila\n);
if (tamfila != 0) {
printf(\nMatricula Nome Polo\n);
printf(--------------------------------------------\n);
for (i=0;i<tamfila;i++)
printf(%4d %-15s %2d\n,
Aluno[i].Matricula, Aluno[i].Nome, Aluno[i].Polo);
printf(--------------------------------------------------\n);
printf(\n\nQuantidade
%d\n,tamfila);

de

alunos

na

fila

}
else
printf(\n\n Nao tem nenhum aluno na fila);
printf(\n\n\nTecle enter para voltar para o menu\n);
getche ( );
}

TrabalhoII
Elabore um pequeno Artigo sobre FILA DINMICA. Este artigo deve
contemplar os seguintes aspectos de uma FILA DINMICA:

Conceituao;

Caractersticas da utilizao;

Implementao.

______________________________________________________________________________
______________________________________________________________________________
I. Data da entrega: 4 Etapa
II. Valor: 20Pontos;
III. Trabalho individual.

Conceitosrvores
A arvore uma lista na qual
cada elemento possui dois ou mais
sucessores, porm todos os elementos
possuem apenas um antecessor, como
pode ser observado na Figura a seguir:
A rvore uma estrutura til
em diversas aplicaes computacionais.
Tem aplicao para organizao de
sistemas de pesquisa e busca. Esta
caracterstica

especialmente
empregada na rea de computao
com inteligncia artificial.

rvores
A idia bsica a representao de uma rvore real,
onde do tronco principal podem sair vrios galhos, de cada galho
podem sair outros galhos. Porm, cada galho s sai de um nico
galho anterior.
O primeiro elemento que d origem aos demais
chamado de raiz da rvore ou n-raiz. Na Figura mostrada, o
elemento A o n-raiz.
Qualquer elemento da rvore chamado de n. A
quantidade de nveis a partir do n raiz at o n mais distante
denominado de altura da rvore. Os sucessores de um
determinado n so chamados de filhos ou n filho. O antecessor
de um n chamado de pai ou n pai.O elemento final de cada
ramificao (elemento sem ramificao) denominado de folha.

FIM
O nosso curso de Estrutura de Dados termina aqu.
Obrigado a todos.
Esperamos que todos tenham aproveitado o maximo
deste curso e que possam fazer bom uso do contedo aprendido.

Abraos!
Prof. Roitier