Pilhas e Filas

Denise Guliato
Faculdade de Computao UFU
www.facom.ufu.br/~guliato

Vrios slides foram adaptados de Nina Edelwais e Renata Galante
Estrutura de Dados Srie de Livros Didticos - Informtica - UFRGS

Pilhas e filas
Disciplina restrita

acesso permitido
somente em alguns nodos
Com disciplina restrita de
organizao e acesso a seus
nodos
Listas lineares especiais
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
tambm o primeiro a ser retirado
Consultas
Excluses Inseres
Topo
Base
Pilhas e Filas
Incio Final
Inseres
Excluses
e
Consultas
PILHA
FILA
Pilhas
Consultas
Excluses Inseres
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
Operaes sobre Pilhas
Pilhas
TAD Pilha
Dados: numeros inteiros

Operaes:
E_cheia
entrada: o endereo da pilha
processo: verifica se pilha esta na condio de
cheia
saida: 1 se cheia, 0 caso contrrio

TAD Pilha
E_vazia
entrada: endereo da pilha
processo: verifica se a pilha est na condio
de vazia
saida: 1 se vazia, 0 caso contrario

TAD Pilha
Cria_pilha
entrada: nenhuma
processo: aloca a pilha e a coloca na condio
de vazia
saida: endereo da pilha

TAD Pilha
Push
entrada: endereo 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: endereo da lista
processo: remove elemento do topo da pilha e
atualiza pilha
saida: endereo do elemento no topo da pilha
ou NULL se pilha vazia

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

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

Pilhas
Pilhas implementadas
por contiguidade fsica
Pilha - contiguidade fsica
LIMITE
Topo
Base
Pilha
ndices
do arranjo
Pilha contiguidade fsica
Implementada sobre um arranjo

ndices de controle da pilha:
BASE da pilha
TOPO atual da pilha
LIMITE mximo que pode ser
ocupado pela pilha

Exemplo de manipulao de uma pilha
MAX-1
TOPO
BASE
PILHA
9
8
7
6
5
4
3
2
1
0
3
MAX-1
TOPO
BASE
3
7
MAX-1
TOPO
BASE
3
7
5
MAX-1
TOPO
BASE
3
7
MAX-1
TOPO
BASE
Retorna 7
1. Inicializar pilha de valores inteiros,a partir do ndice 0, mximo 10 ns
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 fsica
PILHA PILHA PILHA PILHA
9
8
7
6
5
4
3
2
1
0
9
8
7
6
5
4
3
2
1
0
9
8
7
6
5
4
3
2
1
0
9
8
7
6
5
4
3
2
1
0
Retorna 5
Pilha contiguidade fsica
struct stack {
int pilha[MAX];
int topo;
};
typedef struct stack *Pilha;

Tipo de dados utilizado nos algoritmos para pilha implementada
por contiguidade fsica:
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
Criao da pilha
Pilha contiguidade fsica
9
8
7
6
5
4
3
2
1
0
Pilha Cria_pilha(void)
{
Pilha Ptp;
Ptp = (Pilha) malloc(sizeof(struct stack));
if (Ptp != NULL)
Ptp->topo = -1;
return Ptp;
}
Algoritmo: criao de uma pilha
Pilha Cria_pilha(void)
Pilha contiguidade fsica
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;
}
MAX -1
Topo
Base
Pilha
MAX - 1
Topo
Base
Pilha
9
8
7
6
5
4
3
2
1
0
Operao PUSH
Insero de um elemento na pilha
Pilha contiguidade fsica
9
8
7
6
5
4
3
2
1
0
Pilha contiguidade fsica
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;
}
MAX - 1
Topo
Base
Pilha
MAX - 1
Topo
Base
Pilha
Operao POP
Pilha contiguidade fsica
Remoo de um elemento da pilha
9
8
7
6
5
4
3
2
1
0
9
8
7
6
5
4
3
2
1
0
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: Remover elemento do topo de Pilha
int* Pop(Pilha *Ptp)

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

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: Consultar o elemento do topo de Pilha
int* Top(Pilha Ptp)
int* Top(Pilha Ptp)
{
if (Ptp->topo == -1)
return NULL;
return &(Ptp->pilha[Ptp->topo]);
}
Destruio da pilha
void Libera_pilha(Pilha* Ptp)
void Libera_pilha(Pilha *Ptp)
{
free(*Ptp);
(*Ptp)=NULL;
}
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
Exerccio para entregar dia 17/06
Implemente o TAD utilizando uma estrutura de dados
com alocao esttica e acesso sequencial
Implemente uma funo que, usando o TAD Pilha,
verifique se uma dada palavra representada como
uma STRING (que no contenha brancos) uma
palndromo (palavras que no 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.
Faa um programa que leia uma string (conjunto de
palavras separadas por brancos) e indique quais
palavras da string so palindromos e quais no so.

Pilhas
Pilhas implementadas
por encadeamento
Base
Topo
inseres
remoes
?
consultas
PtPilha
Info Elo
Topo da pilha
Base da pilha
Endereo 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:
Pilha por encadeamento
Criao de pilha encadeada
Pilha criada vazia

Atribuir endereo nulo para apontador que contm
o endereo do topo da pilha
Algoritmo: Criar Pilha Encadeada
Pilha Cria_pilha(void)
Pilha por encadeamento
Pilha Cria_pilha(void)
{
return NULL;
}
Topo
Insero de um nodo em pilha encadeada
Topo
Pilha por encadeamento
Novo nodo inserido sempre no topo da pilha
PtPilha PtPilha
Topo
Novo nodo
Base Base
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
PtPilha
Topo
Desempilha um nodo de uma pilha encadeada
Pilha por encadeamento
Topo
PtPilha
Base Base
S pode ser removido o nodo do topo da pilha
Nodo a ser removido
Pilha por encadeamento
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;
}
Consulta pilha encadeada
Pilha por encadeamento
S pode ser acessado o nodo do topo da pilha
Topo
PtPilha
Base
Nodo que pode ser
acessado
Pilha por encadeamento
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;
}
PtPilha = nil
Base
Topo
Base
Topo
Base
Topo
Base
Topo
PtPilha
PtPilha
PtPilha
Destruio de uma pilha encadeada
Pilha por encadeamento
Liberar espao ocupado pelos nodos, sempre a partir do topo
da pilha
No final: apontador para o topo = endereo nulo
Pilha por encadeamento
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)
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;
}
Exerccio
Implemente o TAD Pilha utilizando alocao
dinmica de memria e acesso encadeado.

Teste o programa para reconhecer quais
palavras so palndromos em uma dada frase.
Aplicao da estrutura de dados Pilha
em avaliao de expresses aritmticas
Forma das expresses
Considere:
Operandos: [0,...,9]
Operadores:[+,-,/,x,^]
Delimitadores: [(,)]
Exemplos:
2 + 3 * 5 = 17
(2 + 3) * 5 = 25
As operaes so efetuadas de acordo com
a ordem de precedncia dos operadores;
Os parnteses alteram a ordem natural de
avaliao dos operadores.
Proponham um algoritmo para avaliar
expresses aritmticas

22 56 / 2;
(22-56)/2;
40/(2x(3-1) +6);
2^3x4;
2^(3x4);

?
Notao Polonesa
Proposta pelo lgico polones Jan lukasiewiscz
em ?

Permite escrever uma expressao aritmtica em
que a precedencia implicita

Notao Polonesa
expresso: --
--------
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 ps-
fixada
2 5 3 x +
2 3 + 4 -
2 3 4 - +
2 4 + 3 1 - /
2 4 + 3 1 / 4 x
2 2 ^ 3 * 4 1 2 / 1 1 + / +



forma pr-
fixada
+ 2 x 5 3
- + 2 3 4
+ 2 3 4
/ + 2 4 -3 1
x / +2 4-3 1 4
+ -*^2 2 3 4 / / 1 2 + 1 1
Forma ps-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 funao





Como transformar uma expresso na forma infixa para
pos-fixa???
- Expresses entre parnteses devem ser convertidos de
tal forma que possam ser tratadas como um nico
operando.
- Somente operadores so empilhados . Um operador
empilhado apenas se possui precedncia maior que o
operador no topo da pilha.
- Abre parnteses sempre empilhado
- Fecha parnteses nunca empilhado (menor
precedncia).Todos os operadores so desempilhados at
encontrar um (.
- Operandos e operadores desempilhados so colocados
na expresso na forma ps-fixa
Algoritmo: char* pos-fixa(char* in-fixa)
Inicio
inicializa pilha de operadores e aloca area do tamanho da expressao in-fixa
enquanto (no processou toda a expressao in-fixa)
inicio
simbolo = token
se (simbolo operando)
coloca simbolo na expressao pos-fixa
senao inicio
enquanto (pilha no 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 se
fim enquanto
enquanto ( pilha no eh vazia)
desempilha topo e coloca na expressao pos-fixa fim enquanto

Fim da funo

Precedencia((, op) --- false
Precedencia (op,() ---- false, exceto op=)
Precedencia (op,)) -----false, exceto op=(
Precedencia (), op) --- indefinido
smbolo
topo de pilha
Exerccio usando pilha (entregar dia
30/06 )
Escreva uma funo que transforma uma
expresso da forma in-fixa para a forma ps-
fixa.

Escreva uma funo que avalie uma expresso
na forma ps-fixa

Escreva um programa que entra com a
expresso aritmtica pela linha de comando e
avalia a expresso.
Exerccio usando pilha cont.
Os operandos so nmeros reais (positivos e
negativos);
Os operadores so: {+,-,x,/,^}
Os delimitadores so: {(,)}

Ex: 3.4 x 5 + ( 2.1 12 )
(-23 + 24.3 / 2.1) ^ 3