Pilhas

Professor Srgio Furgeri

Pilhas
Pilha um tipo de lista onde todas as operaes de insero e remoo so feitas na mesma
extremidade (Topo).
O primeiro a entrar o ltimo a sair e o ltimo a entrar o primeiro a sair (LIFO Last-In
First-Out).
Trata-se de uma estrutura dinmica (pode aumentar ou diminuir durante a existncia).
Exemplos Fsicos:
Guardanapo do topo
Entra

Sai
Topo

Uma pilha de pratos

mola
Um porta-guardanapos

Suporta trs operaes bsicas:

Top (topo) acessa o elemento do topo.
Push (empure) insere um elemento no topo.
Pop (salte) remove um elemento do topo.

Exemplo de Instrues
Top(P) acessa o elemento localizado no topo da Pilha P.
Pop(P) remove e retorna o elemento posicionado no topo da Pilha P (diminui o tamanho
da pilha).
Push(P, X) acrescenta o elemento X no topo da Pilha P (aumenta o tamanho da pilha).

Pgina 1

Pilhas

Professor Srgio Furgeri

Exemplo do uso das instrues da Pilha (representao linear).

Operao
----------------Push(P, a)
Push(P, b)
Push(P, c)
Pop(P)
Pop(P)
Push(P, d)
Push(P, e)
Top(P, d)
Pop(P, d)
Pop(P, d)

Estado da Pilha
P:[ ]
P:[ a ]
P:[ b, a ]
P:[ c, b, a ]
P:[ b, a ]
P:[ a ]
P:[ d, a ]
P:[ e, d, a ]
P:[ e, d, a ]
P:[ d, a ]
P:[ a ]

Resultado
--------------------------------------------------------c
b
----------------------------e
e
d

Representao grfica das Pilhas

an

topo

an - 1

P:[ an, an 1, ..., a2, a1 ]

...
a2
a1

base

Exemplos de operaes com Pilha e sua representao grfica.

b
a

c
b
a

Push(P, a)

Push(P, b)

Push(P, c)

Pop(P)

d
a

e
d
a

d
a

Push(P, d)

Push(P, e)

Pop(P)

b
a

a
Pop(P)

Pop(P)

Pop(P)

Pgina 2

Pilhas

Professor Srgio Furgeri

Vantagens da representao Grfica

-

Grficos so interpretados mais rapidamente.

mais eficiente, pois sugere que nenhum elemento precisa ser deslocado durante a
insero ou remoo.

Limites da Pilha
No mundo real uma pilha limitada pelo cho e pelo teto.
* No possvel inserir elementos infinitamente.
* No possvel remover elementos infinitamente.
No computador os limites da pilha se refere a quantidade de memria usada para
represent-la.
Operaes Essenciais para uma Pilha
Init: inicializa uma pilha no estado vazia; Init(P)
IsEmpty: verifica se a pilha est vazia; IsEmpty(P)
IsFull: verifica se a pilha est cheia. IsFull(P)
Exemplo em Pascal do uso de Pilhas.
Programa para converter decimal em binrio
program Dec_Bin;
uses Pilhas;
var P: Pilha;
x, n: integer;
begin
writeln (Digite um inteiro decimal positivo: );
readln (n);
Init(P);
{torna pilha vazia}
repeat
x:= n mod 2;
Push (P, x);
n:= n div 2;
until n=0;

{calcula o resto}
{empilha o resto}
(calcula quociente)
{quociente 0, pra}

write (Correspondente binrio: );

end.

while not IsEmpty(P) do

begin
x:= Pop(P);
write(x);
end;

{pilha vazia, pra}

{desempilha o resto}
{imprime o resto}

Pgina 3

Pilhas

Professor Srgio Furgeri

Pilhas no controle de chamadas e retornos a rotinas

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

program Pilhas;
var
procedure um;
begin
writeln(Um);
dois;
end;
procedure dois;
begin
writeln(Dois);
tres;
end;
procedure tres;
begin
writeln(Trs);
end;
begin
um;
dois;
tres;
end.

Seqncia de linhas armazenados na Pilha:

8
23

23

14
8
23

8
23

23

24

14
24

24

25

Exerccios
1. Mostre a situao da pilha P, inicialmente vazia, aps a execuo de cada uma das
operaes a seguir:
Push (P, a);

Push (P, b);

Push (P, c);

Push (P, Top (P));

Push (P, Pop (P));

Pop (P);

Push (P, e);

Pop (P);

Pgina 4

Pilhas

Professor Srgio Furgeri

1 Resoluo (vertical)

2 Resoluo (horizontal)

Push (P, a);

Push (P, a);

Push (P, b);

Push (P, Pop (P));

a

Push (P, b);

b
a

Push (P, e);

Push (P, Top (P));

Push (P, Top (P));

c
b
a

Push (P, Top (P));

a

c
c
b
a

c
a

Push (P, Pop (P));

c
c
b
a

Pop (P);

Push (P, c);

Push (P, c);

b
a

e
c
a
e
e
c
a
c
c
a

Pop (P);

Push (P, c);

Pop (P);

c
b
a
e
c
b
a
c
b
a

2. Usando uma pilha, escreva um programa para ler uma frase e imprimi-la de trs
para frente (com as letras invertidas como um espelho).
Pgina 5

Pilhas

Professor Srgio Furgeri

program Inverte;
uses Pilhas;
var P: Pilha;
x, n: integer;
f:string;
begin
writeln ('Entre com uma frase: ');
readln (f);
Init(P);
{torna pilha vazia}
for n:=1 to length(f) do
push(P, f[n]);
while not IsEmpty(P) do {pilha vazia, para}
write(pop(P));
end.

3. Escreva uma rotina que usa uma pilha para verificar se uma dada cadeia de
caracteres uo no palndroma. Exemplo: subinoonibus uma palavra
palndroma.
program Palindroma;
uses
Pilhas;
var
E, S: string;
i: integer;
P: Pinha;
begin
writeln(Frase: );
readln(E);

{obtm frase normal}

Init(P);
for i:=1 to length(E) do
Push(P,S[i]);

{pe caracteres na pilha}

S:= ;
while not IsEmpty(P) do
{cria frase invertida}
S:=S+Pop(P);
if E=S then writeln(A frase palndroma);
else writeln(A frase no palndroma);
end.

Este Exerccio exemplifica a funo bsica de uma pilha: criar funes! Vemos ainda
que a funo IsEmpty(), em conjunto como comando while, ideal para codificar um
looping que esvazia a pilha, e que o operador +, em Pascal, pode ser usado para
anexar um caractere ao final de uma cadeia (ou para concatenar duas cadeias
quaisquer!).
4. Considerando as ilustraes a seguir, mostre a sequncia de operaes Push e Pop
que devem ser realizadas sobre as pilhas X, Y e Z para que, partindo do estado
inicial, possamos chegar ao estado final.

Pgina 6

Pilhas

Professor Srgio Furgeri

a)
d
c
b
a
(X)

b
d
a
c
(Y)

(Z)

(X)

estado inicial

(Y)

estado final

1
4
2
8
3
(X)

(Z)

8
4
1
3
2
(Y)

(Z)

(X)

estado inicial

(Y)

(Z)

estado final

b)
Resoluo A
Push(Y, Pop(X))
Push(Z, Pop(X))
Push(Y, Pop(X))
Push(Z, Pop(X))
Push(X, Pop(Y))
Push(Z, Pop(Y))
Push(Z, Pop(X))

Resoluo B
Push(Y, Pop(X))
Push(Y, Pop(X))
Push(Z, Pop(X))
Push(Y, Pop(X))
Push(Z, Pop(X))
Push(X, Pop(Y))
Push(X, Pop(Y))
Push(Z, Pop(Y))
Push(Z, Pop(X))
Push(Z, Pop(X))

5. Esquematize a situao da pilha de controle de programa, em cada momento

durante a execuo, para os programas a seguir:
a)
routine A
1 print A
2 call B
3 return

routine B
4 call C
5 call D
6 return

routine C
7 call D
8 print C
9 return

routine D
10 print D
11 return
Pgina 7

Pilhas

Professor Srgio Furgeri

b)
routine A
1 print A
2 call B
3 return

routine B
4 print B
5 call C
6 return
Resoluo A
P: [ ]
P: [3]
P: [5,3]
P: [8,5,3]
P: [5,3]
P: [3]
P: [6,3]
P: [3]
P: [ ]

routine C
7 print C
8 call B
9 return
Resoluo B
P: []
P: [3]
P: [6,3]
P: [9,6,3]
P: [6,9,6,3]
P: [9,6,9,6,3]

Implementao de Pilhas em Pascal

Caractersticas da Pilha:
os elementos so armazenados em seqncia.
a incluso e excluso no requer movimentao de dados.
Por essas caractersticas a alocao sequencial apropriada.
Para tal podem ser usados:
Vetor: armazena os elementos da Pilha.
ndice: permite o acesso aos elementos.
Para criar uma pilha pode ser usada a estrutura RECORD:
1. const MAX = 50;
2. type Elem = char;
3.
Pilha = record
4.
topo: integer;
5.
memo: array[1..MAX] of Elem;
6.
end;
7. var
P: Pilha;

Pgina 8

Pilhas

Professor Srgio Furgeri

Exemplo de armazenamento da Pilha P[c, b, a]

P.memo armazena os elementos da pilha
P: 3

1 2 3

...
4 5 6

...

MAX

P.topo indica a posio do ltimo elemento inserido

Base

Algoritmos para Manipulao da Pilha

a) Inicializao da Pilha
procedure Init(var P:Pilha);
begin
P.topo:= 0;
end;

Consideraes:
No necessrio atribuir valores iniciais aos elementos do vetor ao inicializar a
pilha (irrelevante).
Como o vetor possui elementos entre 1..MAX, no pode haver contedo na posio
0.
P.memo armazena valores indefinidos
P: ?

...

1 2 3

5 6 7

...

MAX

P.topo com valor indica que a pilha est vazia, pois no h nenhum
elemento nessa posio (Pilha vazia P:[ ]).
P.topo mantm o ndice do ltimo elemento inserido.
O argumento P, recebido pela rotina Init, passagem por referncia (possibilita que
qualquer pilha seja inicializada, independentemente de seu nome).
b) Limites da Pilha
function IsEmpty(var P:Pilha): boolean;
begin
if P.topo= 0 then IsEmpty:= true
else
IsEmpty:= false;
end;

Verifica o cho (Topo=0)

Pgina 9

Pilhas

Professor Srgio Furgeri

function IsFull(var P:Pilha): boolean;

begin
if P.topo = max then
IsFull:= true
else
IsFull:= false;
end;

Verifica o cho (Topo=0)

Consideraes
Por que usar funo no lugar de procedimento?
Quando a Pilha est vazia?
Quando a Pilha est cheia?
A passagem por referncia dada, mas no obrigatria, uma vez que no existe
a necessidade de se alterar o valor da Pilha. Entretanto, no necessrio criar
uma nova varivel para copiar a pilha na memria (quanto > MAX > Tempo)
c) Inserindo elementos na Pilha.
procedure Push(var P:Pilha; x:Elem);
begin
if not IsFull(P) then
begin
P.topo:= P.topo + 1;
P.memo[P.topo]:= x;
end
else
writeln(Stack Overflow!);
end;

Consideraes:
Existe espao? Se no, ocorre Stack Overflow.
Inserir o novo elemento no topo.
Incrementar o valor do topo.

d
c

IsFull (P) verifica se h

P.topo := P.topo + 1 altera
P.memo [ P.topo ] := x
armazena o elemento
espao na pilha
a posio do topo da pilha
(3)
(1)
(2)
Passos bsicos para inserir um elemento na pilha

Pgina 10

Pilhas

Professor Srgio Furgeri

d) Retirando elementos da Pilha.

procedure Pop(var P:Pilha):Elem;
begin
if not IsEmpty (P) then
begin
Pop := P.memo [P.topo];
P.topo:= P.topo - 1;
end
else
writeln(Stack Overflow!);
end;

Consideraes:
A Pilha est vazia?
Remover sempre do topo.
Retornar o elemento e decrementaro topo.
Ao tentar retirar um elemento com a Pilha vazia ocorre Stack Underflow.
A remoo apenas lgica.
d

c
b

c
b

c
b

IsEmpty (P) verifica se

h elementos na pilha
(1)

P.topo := P.topo + 1 altera

a posio do topo da pilha
(2)

P.memo [ P.topo ] := x
armazena o elemento
(3)

Passos bsicos para remover um elemento da pilha

e) Conhecendo o elemento do topo
function Top(var P:Pilha):Elem;
begin
if not IsEmpty(P) then
Top:= P.memo[P.topo]
else
writeln (Stack Underflow);
end;

Consideraes:
No altera o estado da Pilha.
Retorna o elemento do topo.

Unit Pilhas
unit Pilhas;
interface

Pgina 11

Pilhas

Professor Srgio Furgeri

const
type

max = 50;
Elem = char;
Pilha = record
topo: integer;
memo: array[1..max] of
end;

procedure
function
function
procedure
function
function

Elem;

Init(var P:Pilha);
IsEmpty(var P:Pilha):boolean;
IsFull(var P:Pilha):boolean;
Push(var P:Pilha; x:Elem);
Pop(var P:Pilha):Elem;
Top(var P:Pilha):Elem;

implementation
procedure Init(var P:Pilha);
begin
P.topo: = 0;
end;
function IsEmpty(var P:Pilha):boolean;
begin
if P.topo= 0 then IsEmpty:= true
else
IsEmpty:= false;
end;
function IsFull(var P:Pilha):boolean;
begin
if P.topo= max then
IsFull:= true
else
IsFull:= false;
end;
procedure Push(var P:Pilha; x:Elem);
begin
if not IsFull(P) then
begin
P.topo:= P.topo + 1;
P.memo[P.topo]:= x;
end
else
writeln (Stack Overflow!);
end;
procedure Pop(var P:Pilha):Elem;
begin
if not IsEmpty(P) then
begin
Pop:= P.memo [P.topo];
P.topo:= P.topo - 1;
end
else
writeln (Stack Overflow!);
end;
function Top(var P:Pilha):Elem;
begin

Pgina 12

Pilhas

Professor Srgio Furgeri

if not IsEmpty (P) then
Top:= P.memo[P.topo]
else
writeln (Stack Underflow!);
end;

end.

Exerccios:
1. Uma alternativa para organizar os dados de uma pilha consiste no uso de um vetor
M[0..n], onde M[0] usado para manter o ndice de topo e M[1], M[2], ..., M[n] so
usados para armazenar os elementos contidos na pilha:
a) Que restrio existe ao tipo dos elementos que a pilha poder contm?
R: Como a pilha criada a partir de um vetor, os elementos da pilha devem ser
todos do mesmo tipo (inteiro, real, char ...) salvo quando em tipo possa ser
convertido em outro tipo.
b) Esquematize a representao grfica para a pilha P:[d, c, b, a].
Topo

d
c
b
a
(P)

Base

c) Implemente as rotinas para inserir e remover elementos da pilha.

2. possvel manter duas pilhas num nico vetor, bastando que uma pilha tenha como
base a primeira posio do vetor e a outra, a ltima. As pilhas tero de crescer uma de
encontro outra.
Pilha da esquerda

Pilha da direita

d ... z

x n-3

... n-3 n-2 n-1

a) Qual a vantagem do esquema de armazenamento, com relao a espao?

R: Usar duas pilhas com o espao reservado a apenas uma. Desvantagem: os
elementos precisam ser do mesmo tipo.
b) Implemente o tipo Pilha, utilizando esta organizao de dados.

Pgina 13