A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Pilhas e Filas Denise Guliato Faculdade de Computação – UFU www.facom.ufu.br/~guliato Vários slides foram adaptados de Nina Edelwais e Renata Galante Estrutura.

Apresentações semelhantes


Apresentação em tema: "Pilhas e Filas Denise Guliato Faculdade de Computação – UFU www.facom.ufu.br/~guliato Vários slides foram adaptados de Nina Edelwais e Renata Galante Estrutura."— Transcrição da apresentação:

1 Pilhas e Filas Denise Guliato Faculdade de Computação – UFU Vários slides foram adaptados de Nina Edelwais e Renata Galante Estrutura de Dados – Série de Livros Didáticos - Informática - UFRGS

2 Pilhas e filas Disciplina restrita acesso permitido somente em alguns nodos Com disciplina restrita de organização e acesso a seus nodos Listas lineares especiais

3 Pilha Listas lineares especiais mais usuais Pilhas e filas Fila LIFO Last In First Out o último componente inserido é o primeiro a ser retirado FIFO First In First Out o primeiro componente inserido é também o primeiro a ser retirado

4 Consultas ExclusõesInserções Topo Base Pilhas e Filas Início Final Inserções Exclusões e Consultas PILHA FILA

5 Pilhas

6 Consultas ExclusõesInserções Topo Base Criar uma pilha vazia Inserir um elemento no topo da pilha Remover um elemento do topo de pilha Consultar o topo da pilha Destruir a pilha Verificar se é cheia Verificar se é vazia Operações sobre Pilhas Pilhas

7 TAD Pilha Dados: numeros inteiros Operações: E_cheia entrada: o endereço da pilha processo: verifica se pilha esta na condição de cheia saida: 1 se cheia, 0 caso contrário

8 TAD Pilha E_vazia entrada: endereço da pilha processo: verifica se a pilha está na condição de vazia saida: 1 se vazia, 0 caso contrario

9 TAD Pilha Cria_pilha entrada: nenhuma processo: aloca a pilha e a coloca na condição de vazia saida: endereço da pilha

10 TAD Pilha Push entrada: endereço da lista e o elemento processo: insere elemento no topo da pilha e atualiza pilha saida: 1 se sucesso, 0 se fracasso

11 TAD Pilha Pop entrada: endereço da lista processo: remove elemento do topo da pilha e atualiza pilha saida: endereço do elemento no topo da pilha ou NULL se pilha é vazia

12 TAD Pilha Top entrada: endereço da lista processo: consulta o topo da pilha saida: endereço do elemento no topo da pilha ou NULL se pilha é vazia

13 TAD Pilha Libera_pilha entrada: endereço da lista processo: libera toda area alocada para a pilha saida: nenhuma

14 Pilhas Pilhas Pilhas implementadas por contiguidade física

15 Pilha - contiguidade física LIMITE Topo Base Pilha Índices do arranjo Pilha – contiguidade física Implementada sobre um arranjo Índices de controle da pilha: BASE da pilha TOPO atual da pilha LIMITE máximo que pode ser ocupado pela pilha

16 Exemplo de manipulação de uma pilha MAX-1 TOPO BASE PILHA MAX-1 TOPO BASE 3 7 MAX-1 TOPO BASE MAX-1 TOPO BASE 3 7 MAX-1 TOPO BASE Retorna “7” 1. Inicializar pilha de valores inteiros,a partir do índice 0, máximo 10 nós 2. Inserir nodo com valor 3 3. Inserir nodo com valor 7 4. Inserir nodo com valor 5 5. Remover nodo do topo 6. Consultar pilha Pilha – contiguidade física PILHA Retorna “5”

17 Pilha – contiguidade física struct stack { int pilha[MAX]; int topo; }; typedef struct stack *Pilha; Tipo de dados utilizado nos algoritmos para pilha implementada por contiguidade física:

18 MAX - 1 Topo Base Pilha 1. Alocar área para a pilha 2. Indicar que a pilha está vazia Exemplo: Base  0 Topo  – 1 MAX  10 Criação da pilha Pilha – contiguidade física

19 Pilha Cria_pilha(void) { Pilha Ptp; Ptp = (Pilha) malloc(sizeof(struct stack)); if (Ptp != NULL) Ptp->topo = -1; return Ptp; } Algoritmo: criação de uma pilha Pilha Cria_pilha(void) Pilha – contiguidade física

20 Verifica se pilha é cheia int E_cheia(Pilha Ptp) int E_vazia(Pilha Ptp) int E_cheia(Pilha Ptp) { if (Ptp->topo == MAX-1) return 1; else return 0; } int E_vazia(Pilha Ptp) { if (Ptp->topo == -1) return 1; else return 0; }

21 MAX -1 Topo Base Pilha MAX - 1 Topo Base Pilha Operação PUSH Inserção de um elemento na pilha Pilha – contiguidade física

22 Algoritmo: Algoritmo: inserer elemento no topo da pilha int Push(Pilha *Ptp, int elem) { if ((*Ptp)->topo == MAX-1) return 0; (*Ptp)->topo++; (*Ptp)->pilha[(*Ptp)->topo] = elem; return 1; }

23 MAX - 1 Topo Base Pilha MAX - 1 Topo Base Pilha Operação POP Pilha – contiguidade física Remoção de um elemento da pilha

24 int* Pop(Pilha *Ptp) { int* elem; if ((*Ptp)->topo == -1) return NULL; elem = (int*)malloc(sizeof(int)); *elem = (*Ptp)->pilha[(*Ptp)->topo]; (*Ptp)->topo--; return elem; } Algoritmo: Algoritmo: Remover elemento do topo de Pilha int* Pop(Pilha *Ptp)

25 ? MAX - 1 Topo Base Pilha Pilha – contiguidade física Consulta o topa da pilha Acesso somente ao elemento do topo da pilha

26 int* Top(Pilha Ptp) { int* elem; if (Ptp->topo == -1) return NULL; elem = (int*)malloc(sizeof(int)); *elem = Ptp->pilha[Ptp->topo]; return elem; } Algoritmo: Algoritmo: Consultar o elemento do topo de Pilha int* Top(Pilha Ptp) { if (Ptp->topo == -1) return NULL; return &(Ptp->pilha[Ptp->topo]); }

27 Destruição da pilha void Libera_pilha(Pilha* Ptp) void Libera_pilha(Pilha *Ptp) { free(*Ptp); (*Ptp)=NULL; }

28 typedef struct stack *Pilha; int E_cheia(Pilha Ptp); int E_vazia(Pilha Ptp); Pilha Cria_pilha(void); int Push(Pilha *Ptp, int elem); int* Pop(Pilha *Ptp); int* Top(Pilha Ptp); void Libera_pilha(Pilha *Ptp); paeas.h

29 Exercício para entregar dia 17/06 Implemente o TAD utilizando uma estrutura de dados com alocação estática e acesso sequencial Implemente uma função que, usando o TAD Pilha, verifique se uma dada palavra representada como uma STRING (que não contenha brancos) é uma palíndromo (palavras que não se alteram quando lidas da direita para a esquerda ou da esquerda para a direita). ReExemplos: ANA, ADGHGDA. Retorne 1 se palavra é palindromo, e 0 caso contrario. Faça um programa que leia uma string (conjunto de palavras separadas por brancos) e indique quais palavras da string são palindromos e quais não são.

30 Pilhas Pilhas Pilhas implementadas por encadeamento

31 Base Topo inserções remoções ? consultas PtPilha Info Elo Topo da pilha Base da pilha Endereço do topo da pilha Pilha implementada por encadeamento struct no{ int info; struct no* elo; }; typedef struct no* Pilha; Tipo de dados utilizado nos algoritmos:

32 Pilha por encadeamento Criação de pilha encadeada Pilha criada vazia Atribuir endereço nulo para apontador que contém o endereço do topo da pilha

33 Algoritmo: Algoritmo: Criar Pilha Encadeada Pilha Cria_pilha(void) Pilha por encadeamento Pilha Cria_pilha(void) { return NULL; }

34 Topo Inserção de um nodo em pilha encadeada Topo Pilha por encadeamento Novo nodo inserido sempre no topo da pilha PtPilha Topo Novo nodo Base

35 int Push(Pilha *Ptp, int elem) { Pilha pt; pt= (Pilha)malloc(sizeof(struct no)); if (pt == NULL) return 0; pt->elo = (*Ptp); pt->info = elem; (*Ptp) = pt; return 1; } Algoritmo: Inserir nodo em Pilha Encadeada int Push(Pilha *Ptp, int elem) Pilha por encadeamento

36 PtPilha Topo Desempilha um nodo de uma pilha encadeada Pilha por encadeamento Topo PtPilha Base Só pode ser removido o nodo do topo da pilha Nodo a ser removido

37 Pilha por encadeamento Algoritmo: Desempilha nodo de Pilha Encadeada int* Pop(Pilha* Ptp) { int* elem; Pilha aux = (*Ptp); if ((*Ptp) == NULL) return NULL; elem = (int*) malloc(sizeof(int)); *elem = (*Ptp)->info; (*Ptp)= (*Ptp)->elo; free(aux); return elem; }

38 Consulta à pilha encadeada Pilha por encadeamento Só pode ser acessado o nodo do topo da pilha Topo PtPilha Base Nodo que pode ser acessado

39 Pilha por encadeamento Algoritmo: Consultar nodo do topo de Pilha Encadeada int* Top (Pilha Ptp) { int* elem; if (Ptp == NULL) return NULL; elem = (int*) malloc(sizeof(int)); *elem = Ptp->info; return elem; }

40 PtPilha = nil Base Topo Base Topo Base Topo Base Topo PtPilha Destruição de uma pilha encadeada Pilha por encadeamento Liberar espaço ocupado pelos nodos, sempre a partir do topo da pilha No final: apontador para o topo = endereço nulo

41 Pilha por encadeamento Algoritmo: Destruir Pilha Encadeada void Libera_pilha(Pilha*Ptp) { Pilha aux; while ((*Ptp) != NULL) { aux = (*Ptp); (*Ptp) = (*Ptp)->elo; free(aux); }

42 Verifica de pilha esta cheia int E_cheia(Pilha Ptp) Verifica de pilha esta vazia int E_vazia(Pilha Ptp) int E_cheia(Pilha Ptp) { return 0; } int E_vazia(Pilha Ptp) { if (Ptp == NULL) return 1; else return 0; }

43 Exercício Implemente o TAD Pilha utilizando alocação dinâmica de memória e acesso encadeado. Teste o programa para reconhecer quais palavras são palíndromos em uma dada frase.

44 Aplicação da estrutura de dados Pilha em avaliação de expressões aritméticas Forma das expressões Considere: Operandos: [0,...,9] Operadores:[+,-,/,x,^] Delimitadores: [(,)] Exemplos: * 5 = 17 (2 + 3) * 5 = 25 As operações são efetuadas de acordo com a ordem de precedência dos operadores; Os parênteses alteram a ordem natural de avaliação dos operadores.

45 Proponham um algoritmo para avaliar expressões aritméticas 22 – 56 / 2; (22-56)/2; 40/(2x(3-1) +6); 2^3x4; 2^(3x4); ?

46 Notação Polonesa Proposta pelo lógico polones Jan lukasiewiscz em ? Permite escrever uma expressao aritmética em que a precedencia é implicita

47 Notação Polonesa expressão: x – (3 – 4) (2 + 4)/(3 -1) (2+4)/(3-1)x4 2^2*3-4+1/2/(1+1) forma pós- fixada x / – / 4 x 2 2 ^ 3 * 4 – 1 2 / / + forma pré- fixada + 2 x – 3 4 / x / *^ / /

48 Forma pós-fixada para avaliar expressoes aritmeticas usando pilha float avalia_expressao(char *pos-fixada) float avalia_expressao(char *pos-fixada) Inicio Ptp aponta para uma pilha vazia Enquanto (nao processou toda expressao pos-fixada) Inicio simbolo = token; se (simbolo é um operando) empilha simbolo na pilha Ptp senao inicio operando2 = desempilha elemento da pilha Ptp operando1 = desempilha elemento da pilha Ptp valor = operando1 simbolo operando2 empilha valor na pilha Ptp fim se Fim enquanto Retorna (desempilha o elemento da pilha Ptp) Fim da funçao

49 Como transformar uma expressão na forma infixa para pos-fixa??? -Expressões entre parênteses devem ser convertidos de tal forma que possam ser tratadas como um único operando. -Somente operadores são empilhados. Um operador é empilhado apenas se possui precedência maior que o operador no topo da pilha. -Abre parênteses é sempre empilhado -Fecha parênteses nunca é empilhado (menor precedência).Todos os operadores são desempilhados até encontrar um ‘(‘. -Operandos e operadores desempilhados são colocados na expressão na forma pós-fixa

50 Algoritmo: char* pos-fixa(char* in-fixa) Inicio inicializa pilha de operadores e aloca area do tamanho da expressao in-fixa enquanto (não processou toda a expressao in-fixa) inicio simbolo = token se (simbolo é operando) coloca simbolo na expressao pos-fixa senao inicio enquanto (pilha não eh vazia E precedencia(topo da pilha, simbolo) inicio topo = desempilha coloca topo na expressao pos-fixa fim enquanto se (pilha eh vazia OU simbolo # ‘)’ ) empilha simbolo senao enquanto ( (topo = desempilha) != ‘(‘) coloca topo na expressao pos-fixa; fim se fim enquanto enquanto ( pilha não eh vazia) desempilha topo e coloca na expressao pos-fixa fim enquanto Fim da função Precedencia(‘(‘, op) --- false Precedencia (op,’(‘) ---- false, exceto op=‘)’ Precedencia (op,’)’) -----false, exceto op=‘(‘ Precedencia (‘)’, op) --- indefinido símbolo topo de pilha

51 Exercício usando pilha (entregar dia 30/06 ) Escreva uma função que transforma uma expressão da forma in-fixa para a forma pós- fixa. Escreva uma função que avalie uma expressão na forma pós-fixa Escreva um programa que entra com a expressão aritmética pela linha de comando e avalia a expressão.

52 Exercício usando pilha – cont. Os operandos são números reais (positivos e negativos); Os operadores são: {+,-,x,/,^} Os delimitadores são: {(,)} Ex: 3.4 x 5 + ( 2.1 – 12 ) ( / 2.1) ^ 3


Carregar ppt "Pilhas e Filas Denise Guliato Faculdade de Computação – UFU www.facom.ufu.br/~guliato Vários slides foram adaptados de Nina Edelwais e Renata Galante Estrutura."

Apresentações semelhantes


Anúncios Google