Estruturas de seleção

Algoritmos de manipulação de
estruturas elementares de dados
Pilhas e Filas
Prof. Rosana Palazon
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.
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.
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)..
Pilha – Representação Gráfica (2).
Ação:
1. push (A)
2. push (B)
3. push (C)
4. pop ( ) – recupera C
C
5. push (D)
6. pop ( ) – recupera D
B
B
B
B
B
A
A
A
A
A
A
A
1.
2.
3.
4.
5.
6.
7.
7. pop ( ) – recupera B
8. pop ( ) – recupera A
D
8.
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(*)
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);
}
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;
}
Pilha – Implementação em C
usando vetor (cont)
void pilha_libera(Pilha *p){
free(p);
}
void mostra_pilha(Pilha *p) {
printf("Conteúdo da pilha\n");
for(int i=p->n-1;i>=0;i--)
printf("%0.f\n",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 pilha\n");
printf("4. Fim\n");
}
Pilha – Implementação em C usando vetor
main(){
(cont)
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 = %.0f\n",pilha_pop(pi));
break;
case 3 : //mostra
mostra_pilha(pi);
break;
} //switch
printf("\n");
system("pause");
} while(opmenu!=4);
}
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.
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 (*)
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);
}
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;
}
Fila – Implementação em C usando
vetor
void fila_libera(Fila *f){
free(f);
}
void mostra_fila(Fila *f){
printf("Conteúdo da fila\n");
int i;
for(i=f->ini;i<f->n;i++)
printf("%0.f\n",f->vet[i]);
printf("\n");
}
void menu(){
system("cls");
printf("Escolha uma das opcoes do menu: \n");
printf("1. Enfilera\n");
printf("2. Retira \n");
printf("3. Mostra a fila\n");
printf("4. Fim\n");
}
Fila – Implementação em C usando
main(){
vetor
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 = %.0f\n",fila_retira(fi));
break;
case 3 : //mostra
mostra_fila(fi); break;
}//switch
printf("\n"); system("pause");
} while(opmenu!=4);
}
Listas X Pilhas e Filas

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).
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;
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;
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 (*)
Referências Bibliográficas
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/
1.