����� ������� �����������

����� ������������� ���!�#"�$���" ��%&��'�(�$ )�) ��*����+���1 de 7

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. I out Definição: Uma pilha de elementos do tipo T” é uma sequência finita de elementos do tipo “T” , conjuntamente com as seguintes operações: , Criar uma stack vazia; Testar se a stack está vazia; Inserir um elemento na Stack se

esta não se encontrar cheia; Retirar um elemento da Stack se esta não se encontra vazia, e Obter o elemento do topo da stack se esta não se encontra vazia.

1.1. Método

A implementação de uma pilha como u “ tipo abstracto de dados” , permite a definição abstracta dos aspectos essenciais de comportamento e funcionamento de um objecto sem a definição de quaisquer aspectos de implementação. Uma pilha tem por norma as seguintes funcionalidade:

Colocar e retirar dados da pilha. , push - Empilha – guardar um elemento na 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 (não pode guardar mais

elementos). , empty - PilhaVazia – Verificar se a pilha está vazia (não contém elementos) Inicializar ou limpar: , InicializaPilha – Colocar a pilha num estado “pronto” a ser utili zada

A implementação de uma pilha pode ser efectuada através da utili zação de diferentes estruturas de dados (vectores, listas ligadas, árvores, etc.). De seguida, apresenta-se duas implementação de uma pilha através da utili zação de vectores e listas ligadas.

5 1

-�.�/ 0�1�23�2 4�1�5�6�2�7

8�.�9 :�;�1�:�<�9�2 =�<!-#>�?�:�> 1�@&1�A�B�? C�C -�D�:�.+9�12 de 7

1.2. Implementação em C++ usando vectores

1.2.1. Pilha usando Arrays

Vantagens: E Facilidade de implementação. Desvantagens: E Vectores possuem um espaço limitado para armazenamento de dados. E Necessidade de definir um espaço 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 (não 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 {

F�G�H I�J�KL�K M�J�N�O�K�P

Q�G�R S�T�J�S�U�R�K V�U!F#W�X�S�W J�Y&J�Z�[�X \�\ F�]�S�G+R�J3 de 7

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(dad os[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. Implementação em C++ usando listas ligadas

1.3.1. Pilha usando Listas Ligadas

Vantagens: ^ Não existe número máximo de elementos a armazenar (só limi tado pelo espaço da memória do computador).

_�`�a b�c�de�d f�c�g�h�d�i

j�`�k l�m�c�l�n�k�d o�n!_#p�q�l�p c�r&c�s�t�q u�u _�v�l�`+k�c4 de 7

w

O espaço de memória utili zado é alojado de forma dinâmica, sendo só utili zado o espaço necessário para armazenar os valores guardados na pilha.

Desvantagens: w

A implementação é fácil , contudo mais difícil que na utili zação 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); }

x�y�z {�|�}~�} ��|�����}��

��y�� ����|�������} ���!x#������� |��&|������ ��� x�����y+��|5 de 7

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 - Compilação “ C++”

�Invocação do compilador: g++ -wall -g -o <executável> arq1.c arq2.c … arqN.c

�Parâmetros: -g indicar ao compilador para gerar código para o debuger -o nome do arquivo executável que será gerado -wall indicar todos os erros e avisos

����� �������� �����������

����� �������� ���� ¡� !�#¢�£���¢ ��¤&��¥�¦�£ §�§ ��¨����+���6 de 7

1.5. Pilha definida na STL (Standard Template L ibrary )

Uma pilha é um modelo de um contentor, que provê um subconjunto restringido de

funcionalidade de um CONTENTOR: provê inserção, remoção, e inspecção do

elemento ao topo da pilha.

Pilha é um modelo de um contentor, que é implementado com base num tipo de

contentor da STL, sendo por omissão baseado no contentor “deque” da STL, podendo

contudo, ser utilizado outro contentor explicitamente.

1.5.1. Exemplo de utili zação 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 número na base 10 para a base 2. Algoritmo: //Recebe: número na base decima //Escreve: número na base binária 1. Criar uma Pilha vazia para guardar os restos da divisão 2. Enquanto o número a converter > 0

a. Guardar na Pilha o resto da divisão por 2 b. Dividir o número por 2

3. Escrever o número em binário: a. Retirar os números da Pilha b. e escrevê-los no ecrã

©�ª�« ¬�­�®¯�® °�­�±�²�®�³

´�ª�µ ¶�·�­�¶�¸�µ�® ¹�¸!©#º�»�¶�º ­�¼&­�½�¾�» ¿�¿ ©�À�¶�ª+µ�­7 de 7

EXEMPLO I I:

Programa para Verificação da Sintaxe. Pretende-se escrever um programa que permita verificar se, num ficheiro contendo código C++, todos os "parêntesis" estão devidamente acasalados. Considere os seguintes: '(' e ')', '[' e ']', '{' e '} '. a) Deve utilizar um stack da STL para ir guardando os parêntesis esquerdos.

Quando encontrar um parêntesis direito, este deve corresponder ao existente no topo do stack. Se corresponder o elemento é retirado do stack, se não corresponder o programa termina com um erro.

b) Adicione ao programa a capacidade de ignorar os parêntesis que surgem dentro de comentários ou entre plicas (' ') ou aspas (" ").

EXEMPLO I II: Escreva três versões de uma classe stack. Ambas devem poder ser utili zadas no programa do exercício II sem necessidade de alterar o programa. Como tal devem ser classes template. As duas versões são as seguintes: a) Uma que se baseia na utilização das classes list e/ou vector standard (esta é muito

simples e serve só como preparação para as alíneas seguintes). b) Uma que se baseia na utili zação de uma lista ligada. c) Uma que se baseia na utili zação de u vecto de baixo nível.

1.7. Resumo

Uma Pilha é um (ADT - Abstract Data Type) tipo abstracto de dados, na qual são conhecidas os aspectos essenciais de comportamento e funcionamento de um objectsem qualquer relação com a estrutura interna do objecto, e a forma como este é implementado.