Algoritmos de manipulação de estruturas elementares de dados

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çã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 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 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"); }

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 = %.0f\n",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 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"); }

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 = %.0f\n",fila_retira(fi)); break; case 3 : //mostra mostra_fila(fi); break; }//switch printf("\n"); system("pause"); } while(opmenu!=4); }

17. 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).

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 • Forbellone,A.L; Eberspacher,H.F. Lógica de programação – A construção de algoritmos e estrutura de dados. Makron Books. • Schildt,H. C Completo e Total. Makron Books. • 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). • Feofillof, P. Projeto de algoritmos. http://www.ime.usp.br/~pf/algoritmos/