1. Pilhas (Stacks)
Uma Pilha uma estrutura de dados do tipo LIFO (Last In First Out), cujo funcionamento
inspirado no de uma pilha natural, na qual o ltimo elemento a ser inserido sempre o
primeiro a ser retirado. Um exemplo de uma pilha o caso de uma stack.

out
5
1

Definio:
T uma sequncia finita de elementos do tipo T,
Uma pilha de elementos do tipo
conjuntamente com as seguintes operaes:
,
Criar uma stack vazia; Testar se a stack est vazia; Inserir um elemento na Stack se
esta no se encontrar cheia; Retirar um elemento da Stack se esta no se encontra
vazia, e Obter o elemento do topo da stack se esta no se encontra vazia.

1.1. Mtodo
tipo abstracto de dados, permite a
A implementao de uma pilha como u
definio abstracta dos aspectos essenciais de comportamento e funcionamento de um
objecto sem a definio de quaisquer aspectos de implementao. Uma pilha tem por
norma as seguintes funcionalidade:
Colocar e retirar dados da pilha.
,
push Empilha guardar um elemento n a pilha
,
pop Desempilha retirar um elemento da pilha
,
top Topo retornar o topo elemento do topo da pilha
Testar se a pilha est vazia ou cheia.
,
full PilhaCheia Verificar se a pilha est cheia (no pode guardar mais
elementos).
,
empty - PilhaVazia Verificar se a pilha est vazia (no contm elementos)
Inicializar ou limpar:
,
InicializaPilha Colocar a pilha num estado pronto a ser utilizada
A implementao de uma pilha pode ser efectuada atravs da utilizao de diferentes
estruturas de dados (vectores, listas ligadas, rvores, etc.). De seguida, apresenta-se duas
implementao de uma pilha atravs da utilizao de vectores e listas ligadas.


  !#"$" %&'($ ))

*
+

1 de 7

-./ 012
32 415627

1.2. Implementao em C++ usando vectores

1.2.1. Pilha usando Arrays
Vantagens:
E
Facilidade de implementao.
Desvantagens:
E
Vectores possuem um espao limitado para armazenamento de dados.
E
Necessidade de definir um espao grande o suficiente para a pilha.
E
Necessidade de um indicador para o topo da pilha.

//file name : pilha.hpp

class PILHA
{
public:
PILHA();
~PILHA();
bool push(int elemento); // inserir um elemento
int pop();
// remover um elemento
bool empty();
// lista vazia?
bool full();
// lista cheia?
int top();
// retornar o topo da pilha (no retira elemento)
private:
const int MAXPILHA
100
int topo;
// indica o n. de elementos da pilha
int erro;
int dados[MAXPILHA];
};
//file name: pilha.cpp
PILHA::PILHA()
{
topo = 0;
// pilha vazia
erro = 0;
// sem erros
}
PILHA::~PILHA()
{ }
bool PILHA::push(int elemento)
{
if ( full() )
{
erro = 1; // erro: pilha cheia
return(false);
}
else
{

8.9 :;1:<92 =<!-#>?:> 1@&1AB? CC

-D:.+91

2 de 7

FGH IJK
LK MJNOKP

dados[topo] = elemento;
topo = topo + 1;
return(true);
}
}
int PILHA::pop()
{
if ( empty() )
{
erro = 2; // erro: pilha vazia
return(-1);
}
else
{
topo = topo - 1;
return(dados[topo]);
}
}
bool PILHA::empty()
{
return(topo == 0);
}
bool PILHA::full()
{
return(topo == MAXPILHA);
}
int PILHA::top()
{
if ( empty() )
{
erro = 2; // erro: pilha vazia
return(-1);
}
else
{
return(dados[topo-1]);
}
}

1.3. Implementao em C++ usando listas ligadas

1.3.1. Pilha usando Listas Ligadas
Vantagens:
^
No existe nmero mximo de elementos a armazenar (s limitado pelo
espao da memria do computador).

QGR STJSURK VU!F#WXSW JY&JZ[X \\

F]SG+RJ

3 de 7

_`a bcd
ed fcghdi
w

O espao de memria utilizado alojado de forma dinmica, sendo s

utilizado o espao necessrio para armazenar os valores guardados na pilha.
w
Desvantagens:
A implementao fcil, contudo mais difcil que na utilizao de vectores.
//file name: pilha.hpp
class PILHA
{
public:
PILHA();
~PILHA();
bool push(int elemento); // inserir um elemento
int pop();
// remover um elemento
bool empty();
// lista vazia?
bool full();
// lista cheia?
private:
const int MAXPILHA
100
int topo;
int dados[MAXPILHA];
};

//file name: pilha.cpp

PILHA::PILHA()
{
inicio = NULL;
}
PILHA::~PILHA()
{
int valor;
while (! empty() )
{
valor = pop();
}
}
bool PILHA::push(int elemento)
{
struct no *apt;
if ((apt = new no) ==NULL)
{ // cout << "Erro: Memoria esgotada!\n";
return(false);
}
apt->valor=elemento;
apt->next = inicio;
inicio = apt;
return(true);
}

j`k lmclnkd on!_#pqlp cr&cstq uu

_vl`+kc

4 de 7

xyz {|}
~} |}

int PILHA::pop()
{ int valor;
struct no *apt;
if (empty()==true)
{return(0);}
else
{
valor = inicio->valor;
apt = inicio->next;
delete inicio;
inicio = apt;
return(valor);
}
}

bool PILHA::empty()
{
return(inicio==NULL);
}

1.4. Pilha - Compilao C++

Invocao do compilador:
g++ -wall -g -o <executvel> arq1.c arq2.c arqN.c

Parmetros:
-g indicar ao compilador para gerar cdigo para o debuger
-o nome do arquivo executvel que ser gerado
-wall indicar todos os erros e avisos

y |} !x# |&| 

xy+|

5 de 7

 
 

1.5. Pilha definida na STL (Standard Template Library)

Uma pilha um modelo de um contentor, que prov um subconjunto restringido de
funcionalidade de um CONTENTOR: prov insero, remoo, e inspeco do
elemento ao topo da pilha.
Pilha um modelo de um contentor, que implementado com base num tipo de
contentor da STL, sendo por omisso baseado no contentor deque da STL, podendo
contudo, ser utilizado outro contentor explicitamente.

1.5.1. Exemplo de utilizao da classe STACK

#include <stack>
// Standard Type Library
void main()
{
stack<int> S;
// igual a: stack<int, deque<int>>
S.push(8);
//guardar elemento 8
S.push(7);
S.push(4);
// verificar o n. de elementos ==3? Falso
assert(S.size() == 3);
assert(S.top() == 4); // Verificar se elemento do topo ==3
S.pop();
// retirar o elemento do topo da pilha
assert(S.top() == 7);
S.pop();
assert(S.top() == 8);
S.pop();
assert(S.empty());
// verificar se a pilha est vazia
}

1.6. Exemplos do uso de Pilhas

EXEMPLO I:
Programa para converter um nmero na base 10 para a base 2.
Algoritmo:
//Recebe: nmero na base decima
//Escreve: nmero na base binria
1. Criar uma Pilha vazia para guardar os restos da diviso
2. Enquanto o nmero a converter > 0
a. Guardar na Pilha o resto da diviso por 2
b. Dividir o nmero por 2
3. Escrever o nmero em binrio:
a. Retirar os nmeros da Pilha
b. e escrev-los no ecr
  !# & 

+

6 de 7

 
 

EXEMPLO II:
Programa para Verificao da Sintaxe.
Pretende-se escrever um programa que permita verificar se, num ficheiro contendo
cdigo C++, todos os "parntesis" esto devidamente acasalados.
Considere os seguintes: '(' e ')', '[' e ']', '{' e '}'.
a) Deve utilizar um stack da STL para ir guardando os parntesis esquerdos.
Quando encontrar um parntesis direito, este deve corresponder ao existente no
topo do stack. Se corresponder o elemento retirado do stack, se no
corresponder o programa termina com um erro.
b) Adicione ao programa a capacidade de ignorar os parntesis que surgem dentro
de comentrios ou entre plicas (' ') ou aspas (" ").

EXEMPLO III:
Escreva trs verses de uma classe stack. Ambas devem poder ser utilizadas no
programa do exerccio II sem necessidade de alterar o programa. Como tal devem ser
classes template. As duas verses so as seguintes:
a) Uma que se baseia na utilizao das classes list e/ou vector standard (esta muito
simples e serve s como preparao para as alneas seguintes).
b) Uma que se baseia na utilizao de uma lista ligada.
c) Uma que se baseia na utilizao de u vecto de baixo nvel.

1.7. Resumo
Uma Pilha um (ADT - Abstract Data Type) tipo abstracto de dados, na qual so
conhecidas os aspectos essenciais de comportamento e funcionamento de um object
sem qualquer relao com a estrutura interna do objecto, e a forma como este
implementado.

  !# & 

+

7 de 7