Denise Guliato Faculdade de Computação – UFU

Denise Guliato Faculdade de Computação – UFU www.facom.ufu.br/~guliato
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

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

Pilha Fila Listas lineares especiais mais usuais
Pilhas e filas Listas lineares especiais mais usuais 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 Pilha Fila

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

Pilhas

Operações sobre Pilhas
Consultas Exclusões Inserçõ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

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

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

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

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

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

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

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

Pilhas Pilhas implementadas por contiguidade física

Pilha – contiguidade física
LIMITE Topo Base Pilha 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 Índices do arranjo

Exemplo de manipulação de uma pilha 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 Retorna “5” Retorna “7” MAX-1 9 8 7 6 5 4 3 2 1 MAX-1 MAX-1 9 8 7 6 5 4 3 2 1 9 8 7 6 5 4 3 2 1 9 8 7 6 5 4 3 2 1 9 8 7 6 5 4 3 2 1 MAX-1 MAX-1 TOPO 5 TOPO 7 7 TOPO 7 BASE BASE 3 BASE 3 BASE 3 BASE 3 TOPO TOPO PILHA PILHA PILHA PILHA PILHA

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

Criação da pilha 9 8 7 6 5 4 3 2 1 MAX - 1 1. Alocar área para a pilha 2. Indicar que a pilha está vazia Exemplo: Base Base  0 Topo  – 1 MAX  10 Topo Pilha

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

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

Inserção de um elemento na pilha Operação PUSH 9 8 7 6 5 4 3 2 1 9 8 7 6 5 4 3 2 1 MAX -1 MAX - 1 Topo Topo Base Base Pilha Pilha

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

Remoção de um elemento da pilha Operação POP MAX - 1 Topo Base Pilha 9 8 7 6 5 4 3 2 1 9 8 7 6 5 4 3 2 1 MAX - 1 Topo Base Pilha

Algoritmo: Remover elemento do topo de Pilha
int* Pop(Pilha *Ptp) 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; } int* Pop(Pilha *Ptp)//acho que não faz sentido retornar um endereco que devera ser invalido { if ((*Ptp)->topo == -1) return NULL; return &((*Ptp)->pilha[(*Ptp)->topo--]); }

Consulta o topa da pilha 9 8 7 6 5 4 3 2 1 MAX - 1 Acesso somente ao elemento do topo da pilha Topo ? Base Pilha

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

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

paeas.h 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);

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.

Pilhas Pilhas implementadas por encadeamento

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

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

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

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

Algoritmo: Inserir nodo em Pilha Encadeada int Push(Pilha *Ptp, int elem) 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; }

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

Algoritmo: Desempilha nodo de Pilha Encadeada int* Pop(Pilha* Ptp) 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; }

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

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

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

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

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

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.

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.

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

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

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

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

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

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) 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 enquanto ( pilha não eh vazia) desempilha topo e coloca na expressao pos-fixa fim enquanto Fim da função símbolo topo de pilha Precedencia(‘(‘, op) --- false Precedencia (op,’(‘) ---- false, exceto op=‘)’ Precedencia (op,’)’) -----false, exceto op=‘(‘ Precedencia (‘)’, op) --- indefinido

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.

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

Denise Guliato Faculdade de Computação – UFU

Apresentações semelhantes

Apresentação em tema: "Denise Guliato Faculdade de Computação – UFU"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Denise Guliato Faculdade de Computação – UFU

Apresentações semelhantes

Apresentação em tema: "Denise Guliato Faculdade de Computação – UFU"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback