Aborda algumas das estruturas de dados como Pilhas e Filas com teoria e exemplos.

1. Algoritmos de manipulação de
estruturas elementares de dados
Pilhas e Filas
Prof. Rosana Palazon

2. INTRODUÇÃO
 O objetivo desta aula é o de conceituar as
estruturas de dados: Pilhas e Filas abordando
suas diferentes implementações e seus
mecanismos de manipulação.

3. Pilha e Fila – Conceitos
 Uma pilha, assim como uma fila, é simplesmente uma
lista linear de informações (2).
 Tanto a pilha como a fila podem ser implementadas por
meio de uma lista encadeada ou de um vetor.
 O que difere uma pilha de uma fila é o mecanismo
responsável pelo armazenamento e recuperação dos seus
elementos (2).
 Enquanto a fila obedece ao princípio FIFO (First In First
Out), uma pilha (ou stack) é manipulada pelo mecanismo
LIFO (Last In First Out). (1)
 A analogia mais próxima que se faz de uma pilha é
compará-la a uma pilha de pratos (2), e a mais próxima de
uma fila é a própria fila única de um banco ou
supermercado.

4. Pilha - Conceitos
 O conceito de pilha é usado em muitos softwares de
sistemas incluindo compiladores e interpretadores. (A
maioria dos compiladores C usa pilha quando passa
argumentos para funções) (2)..
 As duas operações básicas – armazenar e recuperar –
são implementadas por funções tradicionalmente
chamadas de push e pop, respectivamente (2)..
 A função push() coloca um item na pilha e a função pop()
recupera um item da pilha.
 A região de memória a ser utilizada como pilha pode ser
um vetor, ou uma área alocada dinamicamente (2)..

5. Pilha – Representação Gráfica (2).
A
Ação:
1. push (A)
2. push (B)
3. push (C)
4. pop ( ) – recupera C
5. push (D)
6. pop ( ) – recupera D
7. pop ( ) – recupera B
8. pop ( ) – recupera A
B
A
C
B
A
B
A
D
B
A
B
A A
1. 2. 3. 4. 5. 6. 7. 8.

6. Interface do tipo Pilha
 Operações básicas:
 criar uma pilha vazia
 inserir um elemento (push)
 retirar um elemento (pop)
 verificar se a pilha está vazia
 liberar a estrutura pilha
 mostrar a pilha(*)

7. Pilha – Implementação em C
usando vetor.
#include <stdio.h>
#include <stdlib.h>
#define N 50
typedef struct pilha{
int n;
float vet[N];
}Pilha;
Pilha *pilha_cria(){
Pilha *p=(Pilha*)malloc(sizeof(Pilha));
p->n=0;
return p;
}
int pilha_vazia(Pilha *p){
return(p->n==0);
}

8. Pilha – Implementação em C
usando vetor (cont)
void pilha_push(Pilha *p, float v) {
if(p->n==N){
printf("Capacidade da pilha esgotada.n");
exit (1); //aborta o programa
} //insere novo elemento
p->vet[p->n]=v;
p->n++;
}
float pilha_pop(Pilha *p){
float v;
if(pilha_vazia(p)){
printf("Pilha vazia.n");
exit (1);
} //retira o elemento da pilha
v=p->vet[p->n-1];
p->n--;
return v;
}

9. Pilha – Implementação em C
usando vetor (cont)
void pilha_libera(Pilha *p){
free(p);
}
void mostra_pilha(Pilha *p) {
printf("Conteúdo da pilhan");
for(int i=p->n-1;i>=0;i--)
printf("%0.fn",p->vet[i]);
printf("n");
}
void menu(){
system("cls");
printf("Escolha uma das opcoes do menu: n");
printf("1. Empilha (push)n");
printf("2. Retira (pop)n");
printf("3. Mostra a pilhan");
printf("4. Fimn");
}

10. Pilha – Implementação em C usando vetor
(cont)
main(){
Pilha *pi=pilha_cria();
int opmenu;
float item;
do{
menu();
scanf("%d", &opmenu);
switch (opmenu) {
case 1 : //insere
printf("Digite o valor a ser empilhado: ");
scanf("%f", &item);
pilha_push(pi,item);
break;
case 2 : //retira
printf("Elemento retirado = %.0fn",pilha_pop(pi));
break;
case 3 : //mostra
mostra_pilha(pi);
break;
} //switch
printf("n");
system("pause");
} while(opmenu!=4);
}

11. Filas - Conceitos
 A estrutura de fila é análoga ao conceito que
temos de filas em geral. O primeiro a chegar
é sempre o primeiro a sair, e a entrada de
novos elementos sempre se dá no fim da fila.
 Em computação vemos este conceito sendo
implementado em filas de impressão(3).
 Assim como as pilhas, uma fila também pode
ser implementada por meio de um vetor ou
de uma lista encadeada.

12. Interface do tipo Fila
 Operações básicas:
 criar uma fila vazia
 inserir um elemento no fim
 retirar um elemento do início
 verificar se a fila está vazia
 liberar a estrutura fila
 mostrar a fila (*)

13. Fila – Implementação em C
usando vetor.
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct fila{
int n;
int ini;
float vet[N];
}Fila;
Fila *fila_cria(){
Fila *f=(Fila*)malloc(sizeof(Fila));
f->n=0;
f->ini=0;
return f;
}
int fila_vazia(Fila *f){
return(f->ini==5||f->n==0);
}

14. Fila – Implementação em C usando
vetor
void fila_insere (Fila *f, float v) {
if(f->n==N){ //fila cheia
printf("Capacidade da fila esgotada.n");
return; //retorna ao programa
} //insere novo elemento
f->vet[f->n]=v;
f->n++;
}
float fila_retira(Fila *f){
float v;
if(fila_vazia(f)){
printf("fila vazia.n");
return -1;
} //retira o elemento da fila
v=f->vet[f->ini];
f->ini++;
return v;
}

15. Fila – Implementação em C usando
vetor
void fila_libera(Fila *f){
free(f);
}
void mostra_fila(Fila *f){
printf("Conteúdo da filan");
int i;
for(i=f->ini;i<f->n;i++)
printf("%0.fn",f->vet[i]);
printf("n");
}
void menu(){
system("cls");
printf("Escolha uma das opcoes do menu: n");
printf("1. Enfileran");
printf("2. Retira n");
printf("3. Mostra a filan");
printf("4. Fimn");
}

16. Fila – Implementação em C usando
vetor
main(){
Fila *fi=fila_cria();
int opmenu; float item;
do{
menu();
scanf("%d", &opmenu);
switch (opmenu){
case 1 : //insere
printf("Digite o valor a ser enfileirado: ");
scanf("%f", &item);
fila_insere(fi,item); break;
case 2 : //retira
printf("Elemento retirado = %.0fn",fila_retira(fi));
break;
case 3 : //mostra
mostra_fila(fi); break;
}//switch
printf("n"); system("pause");
} while(opmenu!=4);
}

17.  Filas e pilhas têm regras bastante rigorosas para acessar dados, e
as operações de recuperação têm caráter destrutivo (3).
 Pilhas e filas implementadas em vetores usam regiões contíguas de
memória, listas não necessariamente(2).
 Listas encadeadas podem ser acessadas randômica(quando se tem
o endereço do item), mas normalmente são acessadas
sequencialmente, pois cada item de uma lista contem além da
informação um elo de ligação ao próximo item da cadeia, o que
torna sua estrutura um pouco mais complexa(4) .
 Além disso, a recuperação de um item da lista encadeada não
causa a sua destruição. (É preciso uma operação de exclusão
específica para esta finalidade) (2).
Listas X Pilhas e Filas

18. Atividades
1. Implementar a interface pilha usando lista, como se
segue:
typedef struct lista {
float valor;
struct lista *prox;
}Lista;
typedef struct {
Lista *li;
}Pilha;

19. Atividades (cont)
2. Implementar a interface fila usando lista, como se
segue:
typedef struct lista {
float valor;
struct lista *prox;
}Lista;
typedef struct {
Lista *ini;
Lista *fim;
}Fila;

20. Atividades (cont)
 Operações básicas:
 criar uma pilha/fila vazia
 inserir um elemento no fim
 retirar um elemento
 verificar se a pilha/fila está vazia
 liberar a estrutura pilha/fila
 mostrar a pilha/fila (*)

21. Referências Bibliográficas
1. Forbellone,A.L; Eberspacher,H.F. Lógica de
programação – A construção de algoritmos e
estrutura de dados. Makron Books.
2. Schildt,H. C Completo e Total. Makron Books.
3. Celes, W.; Cerqueira,R.;Rangel, J. L.
Introdução a estrutura de dados – uma
introdução com técnicas de programação em C.
Campus/Sociedade Brasileira de Computação
(SBC).
4. Feofillof, P. Projeto de algoritmos.
http://www.ime.usp.br/~pf/algoritmos/