Escolar Documentos
Profissional Documentos
Cultura Documentos
Parte 5
1.1. Introdução
No estudo das Estruturas de Dados e seus algoritmos, algumas estruturas são consagradas pelos seus
significados e utilidade na computação. Acabam por representar padrões de soluções para determinados
tipos de problemas, como é o caso das Pilhas.
A definição de uma estrutura de dados do tipo Pilha visa soluções para determinados problemas que
somente o conceito de empilhar ou desempilhar elementos resolveria, ou seja, uma estrutura de dados
que permite o acesso somente ao último elemento inserido e que organiza os dados em ordem de
inclusão.
Essa estrutura, como conceito consagrado, é amplamente utilizada em diversos contextos desde
arquitetura de computadores, sistemas operacionais ou, até mesmo, em linguagens de programação. Em
aplicativos, a utilização do conceito de Pilha vai do simples Desfazer/Refazer até à resolução de expressões
com notação pós-fixada.
1.2. Pilhas
1.2.1. Conceito
Uma Pilha é um tipo de estrutura de dados que mantém um conjunto de elementos, que podem ser
armazenados em várias outras estruturas como vetores ou objetos mais sofisticados. Naturalmente o
conceito se traduz em um Tipo Abstrato de Dados – TAD, que permite o acesso a somente um item do
conjunto de elementos armazenado: sempre o último item inserido na estrutura, ou seja, sempre o topo.
A permissão somente ao item do Topo se dá por uma razão obvia até mesmo pelo nome Pilha.
Dependendo do tipo de elemento armazenado no conjunto, poderia ser desastroso a tentativa de acesso
a elementos que não fossem o topo. Imaginem tal situação usando como exemplo uma pilha de pratos.
O risco seria enorme, além do esforço, conforme figura a seguir.
1
A proibição de acesso aos demais itens do conjunto armazenado não é mera liberalidade, é conceito. O
acesso a qualquer item do conjunto, que não seja o último elemento inserido, pode representar não
somente uma quebra no conceito, pode inclusive inviabilizar a solução de um problema.
As operações de Desfazer/Refazer, tão útil em determinados aplicativos. Como seria se ao digitar a famosa
combinação CTRL+Z o aplicativo desfizesse não a última ação realizada e sim a primeira? Certamente
causaria horrores em muitas pessoas.
As Pilhas são estruturas do tipo LIFO - Last-in First-out: último a entrar e primeiro a sair. Isso implica dizer
que o elemento a ser manipulado sempre será o último elemento inserido. Na base da pilha fica o
elemento que foi inserido primeiro e no topo fica o último elemento inserido. Para que seja possível o
acesso ao primeiro elemento inserido é necessário desempilhar todos os demais elementos.
Quando um prato é lavado, após seu uso, ele é recolocado na pilha de pratos limpos, sempre no topo.
Esse prato recém-colocado na pilha passa a ser o último, e o primeiro que será retirado quando
precisarmos usar um prato novamente.
Essa é a ideia geral de uma estrutura de dados do tipo pilha. Nela, os dados são inseridos na pilha
(empilhados), e acessados em ordem inversa (o último a ser inserido é sempre o primeiro a ser utilizado).
Colocar um elemento no topo de uma pilha é uma operação que recebe um nome especial: push. Já a
remoção de um elemento do topo da pilha é uma operação denominada pop.
Por conta deste modo de operação, as pilhas são classificadas como estruturas de dados de
armazenamento Last-In, First-Out – LIFO, “o último a entrar é o primeiro a sair”, pois o último item inserido
na pilha é sempre o primeiro a ser removido (ou lido).
2
1.2.3. Implementação de um TAD Pilha
Podemos implementar uma estrutura do tipo Pilha de várias formas e baseadas em várias outras
estruturas. Para fins didáticos e respeitando as limitações do Visual G, nos prenderemos aos conceitos e
a uma implementação baseada em Vetor, como forma de armazenamento dos elementos.
A ideia de construção de um TAD deve se afirmar neste momento, tendo em vista que existem certas
formalidades para acesso aos elementos de uma Pilha e, nesse sentido, nada melhor para impor condições
ou personalizar a forma de acesso aos dados do que uma implementação baseada em TAD.
De plano, o TAD a ser implementado deverá conter uma estrutura de armazenamento de dados, o vetor,
e deverá conter todas as operações necessárias para a manipulação da pilha, quais sejam:
A diferença entre o TAD que implementaremos a seguir e outras estruturas residirá no tipo de dado que
será armazenado. Neste exemplo, trabalharemos um TAD Pilha de números inteiros, mas poderíamos
trabalhar TAD Pilha para armazenar registros, por exemplo.
O TAD em questão armazenou a pilha em um vetor de inteiros, de acordo com a capacidade da linguagem
do Visual G. Em linguagens mais sofisticadas, pode-se implementar usando recursos de orientação a
objetos mais avançados.
3
1.2.4. Código-Fonte do TAD Pilha
Algoritmo "tadPilhaNumerosInteiros"
procedimento inicializaLista
inicio
para i de 1 ate capacidade faca
pilha[i] <- valorPadrao
fimpara
qtdeElementos <- 0
topo <- 0
fimprocedimento
procedimento mostrarPilha
var _i : inteiro
inicio
escreval("Pilha:")
escreval("======")
para _i de topo ate 1 passo -1 faca
escreval(pilha[_i])
fimpara
fimprocedimento
procedimento mostrarTopo
inicio
se topo > 0 entao
escreval("Topo: ", pilha[topo])
senao
escreval("Pilha vazia.")
fimse
fimprocedimento
4
funcao pilhaCheia : logico
inicio
retorne qtdeElementos = capacidade
fimfuncao
procedimento imprimirMenu()
inicio
escreval("Menu para operacionar o TAD Pilha")
escreval("=================================")
escreval("Opção 1:............Mostrar Pilha")
escreval("Opção 2:.............Mostrar Topo")
escreval("Opção 3:.............Pilha Vazia?")
escreval("Opção 4:.................Empilhar")
escreval("Opção 5:..............Desempilhar")
escreval("Opção 6:........Qtde de Elementos")
escreval("Opção 7:.....................Sair")
escreva("Digite sua opção:..............:")
fimprocedimento
5
Var
pilha : vetor[1..30] de inteiro
qtdeElementos, capacidade, topo : inteiro
valorPadrao, novoElemento, elementoDesempilhado : inteiro
opcao, i : inteiro
Inicio
valorPadrao <- -999999
capacidade <- 10
inicializaLista
ImprimirMenu
leia(opcao)
enquanto opcao <> 7 faca
se opcao = 1 entao
limpatela
mostrarPilha
escreval
escreval
senao
se opcao = 2 entao
limpatela
mostrarTopo
escreval
escreval
senao
se opcao = 3 entao
limpatela
se pilhaVazia entao
escreval("Pilha Vazia")
senao
escreval("Pilha com Elementos")
fimse
escreval
escreval
senao
6
se opcao = 4 entao
se nao pilhaCheia entao
limpatela
novoElemento <- LerValor
empilha(novoElemento)
escreval
escreval
senao
limpatela
escreval("Pilha Cheia!")
escreval
escreval
fimse
senao
se opcao = 5 entao
se nao pilhaVazia entao
limpatela
elementoDesempilhado <- desempilha
escreval("Elemento: ", elementoDesempilhado)
escreval
escreval
senao
limpatela
escreval("Pilha Vazia!")
escreval
escreval
fimse
senao
se opcao = 6 entao
limpatela
escreval("Qtde de elementos na pilha: ",
qtdeElementos)
escreval
escreval
fimse
fimse
fimse
fimse
fimse
fimse
imprimirMenu
leia(opcao)
fimenquanto
Fimalgoritmo