Pilhas

Ficha
Stack
Pilhas
Uma questão importante no estudo da computação é o entendimento das estruturas de dados, dentre as
quais temos filas, pilhas, listas ligadas, entre outras. Vamos entender aqui o funcionamento das pilhas e
como implementar uma pilha simples em Java.
O que é uma estrutura de dados?
A estrutura de dados é o coração de diversos programas bem elaborados, saber qual tipo de estrutura
utilizar é essencial para construir um aplicativo de qualidade. A estrutura de dados é na verdade a forma
de organizar e armazenar informações para que estas possam posteriormente ser utilizadas de modo
eficiente.
O que é uma pilha?
A pilha é uma das estruturas de dados e trabalha com o formato LIFO (o último a entrar é o primeiro a sair,
“Last In, First Out”, em inglês). Lembre-se da pilha como uma pilha de livros, em que o primeiro livro que
foi inserido na pilha, normalmente é o último que sai dela, enquanto o último adicionado é o primeiro a ser
retirado, como vemos na Figura 1.
Figura 1. Pilhas em Java

A estrutura da pilha, segundo Farias “são estruturas de dados do tipo LIFO (last-in first-out), onde o último
elemento a ser inserido, será o primeiro a ser retirado. Assim, uma pilha permite acesso a apenas um item
de dados - o último inserido. Para processar o penúltimo item inserido, deve-se remover o último”.
A pilha é considerada uma estrutura de dados simples, sendo fácil de implementar. Em uma análise
simples, poderia ser utilizada, por exemplo, em um carregamento de um caminhão, pois se o caminhão
tiver 4 entregas, a última entrega colocada dentro do caminhão deve ser a primeira a sair, caso contrário,
pode dar mais trabalho para descarregar.
Um outro caso de pilha simples de se entender é o caso do entregador de pizza.
O entregador deve entregar três pizzas em locais diferentes, se ele colocar na ordem de entrega, o que vai
ocorrer é que a primeira pizza colocada no baú é a primeira pizza a ser entregue, de forma que todas as
outras pizzas estão sobre a primeira pizza, então qual a melhor lógica?
1|Page
Mudar a ordem: a primeira pizza no baú deve ser a última a ser entregue e a última pizza do baú, a
primeira a ser entregue. Neste caso, ao chegar na casa do cliente, o entregador apenas pega a primeira
pizza que está no baú e entrega ao cliente.
Este exemplo foi proposto inicialmente por Takai, apresentando uma rota de entrega de quatro pizzas,
sendo a seguinte ordem:
1. 1° entrega: Portuguesa
2. 2° entrega: Frango com catupiry
3. 3° entrega: Calabresa
4. 4º entrega: Quatro queijos
Assim, para armazenar no baú, a ordem deve ser invertida, ficando da seguinte forma:
 Portuguesa (topo do baú)
 Frango com catupiry
 Calabresa
 Quatro queijos
Para as tarefas temos: a criação da pilha, o empilhamento - push (ato de colocar uma caixa de pizza sobre
a outra), o ato de desempilhar - pop (na hora que o entregador tira a caixa de pilha para entregar ao
cliente), além de uma verificação se a pilha está cheia ou vazia (ato que o entregador faz ao verificar o
baú).
Uma pilha é uma estrutura de dados com padrão de acesso LIFO (Last-In, First-Out), ou seja, o último
elemento que é armazenado é obrigatoriamente o primeiro elemento a ser retirado.
Em Java, pilhas de objetos são implementadas por objetos da classe Stack. Os dois métodos
fundamentais
associados a uma estrutura de pilha devem permitir colocar um elemento no topo da pilha (método push())
e retirar o
elemento no topo da pilha (método pop()).
Outras funcionalidades associadas a esta classe incluem os métodos peek() (qual o objeto que está no
topo da pilha?),
search() (a que profundidade encontra-se o objeto especificado?) e boolean empty() (pilha está vazia?).[/i]
LIFO é um acrônimo para a expressão inglesa Last In, First Out que, em português significa último a
entrar, primeiro a sair. Em ciência da computação, refere-se a estruturas de dados do tipo pilha. [É
equivalente a, que significa First In, Last Out e pode também ser referida como pilha.
O conceito de pilha é amplamente utilizado na informática, como, por exemplo, durante a execução de um
programa, para o armazenamento de valores de variável local a um bloco e também para conter o
endereço de retorno do trecho de programa que chamou a função ou procedimento atualmente em
execução
2|Page
Em ciência da computação, LIFO (acrônimo para a expressão inglesa Last In, First Out que, em português
significa último a entrar, primeiro a sair) refere-se a estruturas de dados do tipo pilha. É equivalente a
FILO, que significa First In, Last Out . O conceito de pilha é amplamente utilizado na informática, como, por
exemplo, durante a execução de um programa, para o armazenamento de valores de variável local a um
bloco e também para conter o endereço de retorno do trecho de programa que chamamos
Vamos iniciar nosso programa declarando objetos da classe String, onde cada um receberá um valor
inicial baseado em nome próprio. São oito objetos: chan, hasan, chico, arnold, elza, clarice, silvio e
richard.Tais objetos e seus respectivos valores serão incrementados na nossa estrutura de pilha.
public class TestaStack {
public static void main(String[] args) {
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza",
clarice =
“Clarice”, silvio = “Silvio”, richard = “Richard”;
}
}
No passo anterior declaramos os objetos que serão incrementados na pilha. Agora, vamos declarar a
pilha. Tal estrutura corresponde à classe Stack na linguagem de programação Java.
O nosso objeto da classe Stack será nomeado explicitamente de nossaPilha da seguinte
maneira: Stack<String> nossaPilha = new Stack<String>();
Uma observação importante é quanto à classe esperada para nossa pilha. Neste caso é informado que
durante a criação da pilha ela deverá conter objetos String. Essa particularidade está no nome de classe
colocado entre “<” e “>”.
[import java.util.Stack;
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =
Stack<String> nossaPilha = new Stack<String>();
}
}
3|Page
Para exibir informações sobre uma pilha, você pode utilizar a instrução System.out.println(nossaPilha);.
Entretanto, a saída será sucinta e com os elementos dispostos em ordem crescente e na horizontal.
Exemplo: [Chan, Hassan, Chico, Clarice, Silvio, Richard] ( Richard é o topo e Chan é a Base ).
Para uma representação que facilite a compreensão da estrutura da pilha e envolva prática, vamos utilizar
o seguinte bloco de instruções:
if (nossaPilha.isEmpty()) {
System.out.println("A PILHA ESTÁ VAZIA!");
}
else {
System.out .println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
for (int i = nossaPilha.size() - 1; i > -1; i--) {
System.out.println(nossaPilha.get(i) + "\t\t" + i);
}
System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size());
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek() + "\" no índice " +
nossaPilha.indexOf(nossaPilha.peek()));
}
Inicialmente vamos nos certificar que a pilha contenha elementos, caso o
método nossaPilha.isEmpty() retorne o valor booleano true, o usuário será advertido que a pilha está
vazia.
Caso a pilha contenha elementos, a repetição for (int i = nossaPilha.size() - 1; i > -1; i--){} percorrerá todos
os elementos da lista na forma decrescente, exibindo o valor e índice correspondente. ATENÇÃO: int i =
nossaPilha.size() - 1 corresponde o topo da lista, considerando que o método nossaPilha.size() retorna o
número de elementos e os índice inicial da pilha é 0, a subtração de 1 elemento é necessária. Em i > -
1 informa que a repetição deverá ocorrer até que o índice da pilha seja válido/existente (maior ou igual a
0). O i-- é o decremento do índice (não esqueça que a exibição dos elementos será de maneira análoga a
objetos empilhados).
Em System.out.println("\nNÚMERO DE ELEMENTOS: " + nossaPilha.size()); o método .size() retorna
a quantidade de elementos disponíveis.
Em System.out.println("ELEMENTO NO TOPO: “” + nossaPilha.peek() + “” no índice " +
nossaPilha.indexOf(nossaPilha.peek())); o método nossaPilha.peek() retorna o elemento no topo da pilha.
Em indexOf(nossaPilha.peek()) teremos o índice do elemento ao topo da pilha.
Execute o programa após acrescentar o código citado. Obs. A pilha estará vazia!
import java.util.Stack;
4|Page
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice
= “Clarice”, silvio = “Silvio”, richard = “Richard”;
} else {
System.out.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
}
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek() + "\" no índice " +
nossaPilha.indexOf
(nossaPilha.peek()));
}
}
}
A partir de agora vamos interagir diretamente na pilha. O primeiro passo será acrescentar elementos a
pilha. O método push() é o responsável por incrementar elementos na pilha. O primeiro elemento a ser
incrementado será chan: nossaPilha.push(chan);
Execute o programa após acrescentar o código citado. Observe a ilustração e a saída do programa!
String chan = "Chan", hassan = "Hassan", chico = "Chico", arnold = "Arnold", elza = "Elza", clarice =

// Passo 1: Incrementar Chan
nossaPilha.push(chan);
// EXIBINDO INFORMAÇÕES SOBRE A PILHA
} else {
5|Page
}
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()+ "\" no índice
" + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}
Elemento Índice
Chan 0
NÚMERO DE ELEMENTOS: 1
ELEMENTO NO TOPO: “Chan” no índice 0
Para praticar vamos incrementar hassan: nossaPilha.push(hassan);
// DECLARANDO NOSSOS ELEMENTOS/OBJETOS
=
// DECLARANDO A PILHA
// Passo 2: Incrementar Hassan
nossaPilha.push(hassan);
} else {
6|Page
}
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()
+ "\" no índice " + nossaPilha.indexOf(nossaPilha.peek()));
}
}
}
Hassan 1
Chan 0
ELEMENTO NO TOPO: “Hassan” no índice 1
Agora vamos incrementar dois elementos: nossaPilha.push(chico) e nossaPilha.push(elza).
=
// Passo 3: Incrementar Chico e Elza
nossaPilha.push(chico);
nossaPilha.push(elza);
7|Page
} else {
}
}
}
Elza 3
Chico 2
Hassan 1
Chan 0
ELEMENTO NO TOPO: “Elza” no índice 3
Este passo consiste em retirar o elemento do topo da pilha. O método pop() é responsável por tal ação. A
instrução nossaPilha.pop(); retira o elemento clarice e o topo passa a ser chico.

=
8|Page
// Passo 4: Decrementar elemento Elza do topo
nossaPilha.pop();
} else {
System.out
.println("NOSSA PILHA...\n\nElemento\tÍndice\n----------------------");
}
}
}
}
Chico 2
Hassan 1
Chan 0
ELEMENTO NO TOPO: “Chico” no índice 2
Agora vamos incrementar outro elemento: nossaPilha.push(clarice);
9|Page
=
nossaPilha.pop();
// Passo 5: Incrementar Clarice
nossaPilha.push(clarice);
} else {
System.out
}
}
}
}
10 | P a g e
Clarice 3
Chico 2
Hassan 1
Chan 0
ELEMENTO NO TOPO: “Clarice” no índice 3
Agora vamos incrementar dois elementos: nossaPilha.push(silvio); e nossaPilha.push(richard);.
=
nossaPilha.pop();
// Passo 6: Incrementar Silvio e Richard
nossaPilha.push(silvio);
nossaPilha.push(richard);
11 | P a g e
} else {
System.out
}
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()+ "\" no índice " +
}
}
}
Richard 5
Silvio 4
Clarice 3
Chico 2
Hassan 1
Chan 0
ELEMENTO NO TOPO: “Richard” no índice 5
Uma das facilidades herdadas da classe Stack é a possibilidade de substituir qualquer elemento da

pilha através do método set(). Em nossaPilha.set(0, arnold); vamos substituir o elemento na
base chamado chan pelo elemento arnold. Perceba ordem da passagem de parâmetros do
método: set(“índice desejado”,”elemento que ira substituir”);.
=
12 | P a g e
nossaPilha.pop();
// Passo 7: Substituir elemento na pilha. Chan por Arnold!
nossaPilha.set(0, arnold);
} else {
}
}
}
}
Richard 5
Silvio 4
13 | P a g e
Clarice 3
Chico 2
Hassan 1
Arnold 0
O último passo é limpar a pilha. O método clear() retira instantaneamente todos os elementos.
=
nossaPilha.pop();
// Passo 7: Substituir elemento na pilha. Chan por Arnold!
14 | P a g e
nossaPilha.set(0, arnold);
// Passo FINAL: Limpar a pilha
nossaPilha.clear();
} else {
System.out
}
}
}
Outro método essencial da classe Stack é o search(). Este recurso localiza valores na pilha, retornando a
distância do elemento a partir do topo. Quando não é possível encontrar o valor desejado, o retorno do
método será o inteiro negativo -1.
ATENÇÃO: Para compreender essa relação entre a distância do elemento a partir do topo, considere:
uma pilha com 6 elementos onde o a distância do elemento no topo é 1 e na base corresponde a 6.
Que tal testar o seguinte programa (agora exibindo a distância de cada elemento em relação ao topo)…
public class TestaStackSearch {
=
nossaPilha.push(arnold);
15 | P a g e
}
else {
System.out.println("NOSSA PILHA...\n\nElemento\tÍndice\tDistância do topo\n----");
for (int i = nossaPilha.size() - 1; i > -1; i–) {
System.out.println(nossaPilha.get(i) + “\t\t” + i + “\t”+ (nossaPilha.size() - i));
}
System.out.println("ELEMENTO NO TOPO: \"" + nossaPilha.peek()+ "\" no índice " +
}
}
Richard 5 1
Silvio 4 2
Clarice 3 3
Chico 2 4
Hassan 1 5
Arnold 0 6
Acrescente o código abaixo antes da exibição das informações da pilha. Perceba o valor da distância a
partir do topo em cada um dos elementos pesquisados.
// Localizar
System.out.println(nossaPilha.search("Chan"));
System.out.println(nossaPilha.search("Richard"));
System.out.println(nossaPilha.search("Silvio"));
System.out.println(nossaPilha.search("Hassan"));
16 | P a g e
17 | P a g e

Pilhas

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Pilhas

Enviado por

Direitos autorais:

Formatos disponíveis

Ficha

Figura 1. Pilhas em Java

Stack<String> nossaPilha = new Stack<String>();

// DECLARANDO NOSSOS ELEMENTOS/OBJETOS

Uma das facilidades herdadas da classe Stack é a possibilidade de substituir qualquer elemento da

Você também pode gostar