algoritmos de manipulação de estruturas elementares de dados
DESCRIPTION
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. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/1.jpg)
Algoritmos de manipulação de estruturas elementares de dados
Pilhas e Filas
Prof. Rosana Palazon
![Page 2: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/2.jpg)
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.
![Page 3: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/3.jpg)
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.
![Page 4: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/4.jpg)
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)..
![Page 5: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/5.jpg)
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.
![Page 6: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/6.jpg)
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(*)
![Page 7: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/7.jpg)
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);}
![Page 8: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/8.jpg)
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;}
![Page 9: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/9.jpg)
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");}
![Page 10: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/10.jpg)
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 = %.0f\n",pilha_pop(pi)); break; case 3 : //mostra mostra_pilha(pi); break; } //switch printf("\n"); system("pause"); } while(opmenu!=4); }
![Page 11: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/11.jpg)
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.
![Page 12: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/12.jpg)
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 (*)
![Page 13: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/13.jpg)
Fila – Implementação em C usando vetor.
#include <stdio.h>#include <stdlib.h>#define N 5typedef 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);}
![Page 14: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/14.jpg)
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;
}
![Page 15: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/15.jpg)
Fila – Implementação em C usando vetorvoid 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");
}
![Page 16: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/16.jpg)
Fila – Implementação em C usando vetormain(){
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);
}
![Page 17: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/17.jpg)
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
![Page 18: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/18.jpg)
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;
![Page 19: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/19.jpg)
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;
![Page 20: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/20.jpg)
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 (*)
![Page 21: Algoritmos de manipulação de estruturas elementares de dados](https://reader036.vdocuments.pub/reader036/viewer/2022081520/56814e3b550346895dbba3d0/html5/thumbnails/21.jpg)
Referências Bibliográficas1. 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/