Algoritmos de manipulação de estruturas elementares de dados Pilhas e Filas Prof. Rosana Palazon.
Aula 05 - Pilhas e Filas
of 19
-
Upload
andrezinhocefet -
Category
Documents
-
view
17 -
download
1
description
Aula sobre Pilhas e Listas
Transcript of Aula 05 - Pilhas e Filas
-
CENTRO UNIVERSITRIO DE ENSINO SUPERIOR DO AMAZONAS
Aula 05 Pilhas e Filas
Prof. Andr Alves Nogueira, MSc.
2015
-
INTRODUO
O objetivo desta aula o de conceituar as
estruturas de dados: Pilhas e Filas abordando
suas diferentes implementaes e seus
mecanismos de manipulao.
-
Pilha e Fila Conceitos
Uma pilha, assim como uma fila, simplesmente uma lista linear de informaes.
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 responsvel pelo armazenamento e recuperao dos seus elementos.
Enquanto a fila obedece ao princpio FIFO (First In First Out), uma pilha (ou stack) manipulada pelo mecanismo LIFO (Last In First Out).
A analogia mais prxima que se faz de uma pilha compar-la a uma pilha de pratos, e a mais prxima de uma fila a prpria 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 funes).
As duas operaes bsicas armazenar e recuperar so implementadas por funes tradicionalmente
chamadas de push e pop, respectivamente.
A funo push() coloca um item na pilha e a funo pop()
recupera um item da pilha.
A regio de memria a ser utilizada como pilha pode ser
um vetor, ou uma rea alocada dinamicamente.
-
Pilha Representao Grfica
A
Ao:
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.
-
Interface do tipo Pilha
Operaes bsicas:
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 Implementao em C usando vetor.
#include
#include
#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);
}
-
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 Implementao em C usando vetor.
-
void pilha_libera(Pilha *p){
free(p);
}
void mostra_pilha(Pilha *p) {
printf("Contedo 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 Implementao em C usando vetor.
-
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 = %.0f\n",pilha_pop(pi));
break;
case 3 : //mostra
mostra_pilha(pi);
break;
} //switch
printf("\n");
system("pause");
} while(opmenu!=4);
}
Pilha Implementao em C usando vetor.
-
Atividade 6
Implementar as funes de uma pilha alocada dinamicamente, usando a estrutura abaixo:
typedef struct NoFloat {
float valor;
struct NoFloat *prox;
}NoPilha;
typedef struct {
int tamanho;
NoPilha *topoPilha;
}Pilha;
Operaes bsicas:
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
-
Filas - Conceitos
A estrutura de fila anloga 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 computao vemos este conceito sendo
implementado em filas de impresso.
Assim como as pilhas, uma fila tambm pode
ser implementada por meio de um vetor ou
de uma lista encadeada.
-
Interface do tipo Fila
Operaes bsicas:
criar uma fila vazia
inserir um elemento no fim
retirar um elemento do incio
verificar se a fila est vazia
liberar a estrutura fila
mostrar a fila (*)
-
Fila Implementao em C usando vetor.
#include
#include
#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);
}
-
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 Implementao em C usando vetor.
-
void fila_libera(Fila *f){
free(f);
}
void mostra_fila(Fila *f){
printf("Contedo da fila\n");
int i;
for(i=f->ini;in;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 Implementao 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 = %.0f\n",fila_retira(fi));
break;
case 3 : //mostra
mostra_fila(fi); break;
}//switch
printf("\n"); system("pause");
} while(opmenu!=4);
}
Fila Implementao em C usando vetor.
-
Filas e pilhas tm regras bastante rigorosas para acessar dados, e as operaes de recuperao tm carter destrutivo.
Listas encadeadas podem ser acessadas randmica(quando se tem o endereo do item), mas normalmente so acessadas sequencialmente, pois cada item de uma lista contm alm da informao um elo de ligao ao prximo item da cadeia, o que torna sua estrutura um pouco mais complexa.
Alm disso, a recuperao de um item da lista encadeada no causa a sua destruio. ( preciso uma operao de excluso especfica para esta finalidade).
Listas X Pilhas e Filas
-
Atividade 7
Implementar as funes de uma fila alocada dinamicamente, usando a estrutura abaixo:
typedef struct NoFloat {
float valor;
struct NoFloat *prox;
}NoFila;
typedef struct {
int tamanho;
NoFila *inicioFila;
}Fila;
Operaes bsicas:
criar uma fila vazia inserir um elemento no fim retirar um elemento verificar se a fila est vazia liberar a estrutura fila mostrar a fila
