Aula 8

Estrutura de
Dados
Profa. Divani Barbosa Gavinier
Profa. Divani Barbosa Gavinier
Aula 6 – parte 2

PILHAS
Uma pilha (stack) é uma estrutura de dados em
que todas as operações de remoção e inserção
são realizadas pela mesma extremidade,
denominada como topo.
Sempre que houver uma
remoção, o elemento
removido é o que está na
estrutura há menos tempo
Essa política é conhecida pela sigla LIFO de
“Last In First Out” (ultimo a entrar primeiro a
sair).

Exemplos
Somente o elemento do topo é acessível
↓
São poucas as operações que podem ser
realizadas sobre uma pilha

Classe
int topo;
int tam_max;
double[] itens;
push: Insere itens na pilha (empilha)
pop: Retira itens da pilha (desempilha)
top: Retorna um item da pilha sem desempilhar
empty: Verifica se a pilha esta vazia
full: Verifica se a pilha esta cheia
size: Retorna o tamanho da pilha
Métodos
Campos Construtor
public Pilha(int n) {
itens = new double[n];
tam_max = n;
topo = 0;
}

Colocar uma informação na
pilha
push
Empilha

PUSH
Algoritmo 1
Entrada: Valor do item a ser adicionado na pilha (valor)
Saída: Não tem retorno
inicio
itens[ topo ]  valor
topo  topo + 1
fim
1
2
3
4
Em Java
public void push(double valor) {
itens[ topo ] = valor;
topo++;
}

Retirar uma informação na
pilha
pop
Desempilha

POP
Algoritmo 2
Entrada: não há
Saída: não há
inicio
topo  topo – 1
fim
1
2
3
Em Java
public void pop() {
topo--;
}

Adicionar push de Push-down
Remover pop de Pop-up
Exemplos função
push e pop

Retornar o elemento superior
(topo) da pilha, sem remove-lo
TOP
Algoritmo 3
Entrada: não há
Saída: item do topo
inicio
retorne itens[ topo-1 ]
fim
1
2
3
Em Java
public double top() {
return itens[ topo-1 ];
}

Retornar o tamanho da pilha
SIZE
Algoritmo 4
Entrada: não há
Saída: tamanho da pilha (int)
inicio
retorne topo ;
fim
1
2
3
Em Java
public int size() {
return topo;
}

Verificar se a pilha esta vazia
EMPTY
Algoritmo 5
Entrada: não há
Saída: verdadeiro ou falso
inicio
retorne ( topo = 0 );
fim
1
2
3
Em Java
public boolean empty() {
return ( topo == 0 );
}

Verificar se a pilha esta cheia
FULL
Algoritmo 6
Entrada: não há
Saída: verdadeiro ou falso
inicio
retorne ( topo = tam_max );
fim
1
2
3
Em Java
public boolean full() {
return ( topo == tam_max );
}

Aplicação
As pilhas são úteis quando queremos armazenar
temporariamente uma informação que vamos usar logo
depois.
Se tivermos uma pilha p e um elemento x qualquer, a
operação push (x) acrescenta o elemento x no topo da pilha e
aumenta-lhe o tamanho.
A operação pop() remove o elemento que está no topo da
pilha fazendo com que esta diminua.
Já a operação top não altera o tamanho da estrutura, pois
simplesmente visita o topo da pilha retornado uma cópia do
elemento que encontra-se no seu topo.

Editores de texto utilizam estrutura de dados na forma de pilha
operações
Cancela operações recentes e reverte ao estado anterior.
Esse mecanismo é implementado mantendo as alterações do texto em uma
pilha
Aplicação - Exemplos

Navegadores utilizam estrutura de dados na forma de pilha
Para armazenar os endereços mais recentemente visitados.
Cada vez que o navegador visita um novo site, o endereço é armazenado na
pilha de endereços. Usando a operação de retorno (“pop”) o navegador
permite que o usuário retorne ao ultimo site visitado, retirando seu endereço
da pilha.

Jogo paciência utiliza estrutura de dados na forma de pilha
Para empilhar e desempilhar cartas.

class Pilha {
private double[] itens;
private int topo;
private int tam_max;
public Pilha(int n) { // construtor
itens = new double[n];
tam_max = n;
topo = 0;
}
public void push(double valor) { // inserção itens
itens[ topo ] = valor;
topo++;
}
public void pop() { // remoção itens
topo--;
}
public double top() { // retorna item do topo
return itens[ topo-1 ];
}
// Continua ...

public boolean empty() { // verifica se vazia
return ( topo == 0 );
}
public boolean full() { // verifica se cheia
return ( topo == tam_max );
}
public int size() { // retorna tamanho
return topo;
}
} // fim classe Pilha
/////////////////////////////////////////////////////////////
class PilhaApp { // Classe principal
public static void main(String[] args) { //Progr. principal
Pilha p = new Pilha(4); // Criando objeto na memoria
// O usuário deve verificar se a pilha esta cheia antes
// de adicionar
if (!p.full()) p.push(20.5);
else System.out.println("ATENCAO PILHA CHEIA");
// Continua ...

if (!p.full()) p.push(10);
while (!p.empty()) { // Ate esvaziar (se não vazio)
System.out.print(" " + p.top()); // Mostre na tela o
// valor do topo
p.pop(); // Desempilhe um item
}
System.out.println("n"); // Pula uma linha
} // fim programa principal
} // fim classe principal PilhaApp

Atividade 1
 Dado o seguinte trecho de código
abaixo, responda o que esta sendo
impresso na tela.
.public static void main(String[] args) {
int n=0, k=15, x=3;
Pilha p = new Pilha(k+2);
for (n=0; n<x; n++)
p.push(n+1);
System.out.println(p.size());
System.out.println(p.top()); p.pop();
p.push(x+1);
System.out.println(p.top());
Resposta:
3
3
2
4
1

Dica: Classe para Pilha de Strings
private int topo;
private int tam;
private String[] itens;
push: Insere itens na pilha (empilha)
pop: Retira itens da pilha (desempilha)
top: Retorna um item da pilha sem desempilhar
empty: Verifica se a pilha esta vazia
full: Verifica se a pilha esta cheia
size: Retorna o tamanho da pilha
Métodos
Campos Construtor
itens = new String[n];
tam = n;
topo = 0;
}
Atividade 2
Implemente uma pilha de Strings

Classe Agenda
class Agenda {
public String nome;
public long tel;
public Agenda(String nm, long t) {
nome = nm;
tel = t;
}
}
Atividade 3
Implemente uma pilha de Registros Agenda

Dica: Classe para Pilha de Registro
Campos Construtor
itens = new Agenda[n];
tam_max = n;
topo = 0;
}
Método push
public void push(String nm, long t) {
itens[ topo ] = new Agenda(nm, t);
topo++;
}
private int topo;
private int tam;
private Agenda[] itens;
Método top
public String top() {
return itens[ topo-1 ].nome+" "+itens[ topo-1 ].tel;
}

Atividade 4
Escreva um programa que use uma pilha
para inverter a ordem das letras de
uma palavra.
Exemplo de Entrada Exemplo de Saída
FATEC TAUBATE ETABUAT CETAF
DICA:
1. Use a estrutura de dados pilha de caracteres;
2. Ler a entrada na forma de String e usar os métodos
length e charAt.
Exemplo:
String s = lerStr();
s.length(); /* length() retorna o tamanho da string s */
s.charAt(i); /* charAt(i) retorna o caractere da posição
i da string s */

Atividade 5
 Implemente no método de inserção de
itens da pilha a verificação se o usuário
atingiu o tamanho máximo disponível para
o vetor pilha.
 Caso positivo duplique o tamanho do
vetor de itens.
Dica: Crie um novo vetor com o dobro do
tamanho do atual e copie os itens do atual
para o novo. Depois copie o vetor novo para
atual.

Atividades 6, 7, 8 e 9
► Faça o seguinte menu iterativo com o usuário para chamada
dos métodos vistos hoje em aula:
► Dada uma pilha qualquer contendo os valores 3, 9, 5, 1 (3 é
o topo) descreva qual o resultado após as seguintes
operações: Push (2), Pop, Pop, Top, Pop, Push (7), Pop, Pop,
Push (4), Pop, Pop, Push (8), Push (6), Pop.
► Construa um método que troca de lugar o elemento que está
no topo da pilha com o que está na base da pilha.
► Construa um programa que leia 10 valores do tipo int e
empilha-os conforme forem pares ou impares na pilha1 e
pilha2, respectivamente. No final desempilhe os valores de
cada pilha mostrando-os na tela.
Implemente no menu:
Caso 1: Inserir itens: Verificação antes da chamada
da função se o tamanho da pilha é menor que o
tamanho máximo ajustado ao vetor.
Caso 2 e 4: Remover e Imprimir item: Verificação
antes da chamada da função se a pilha esta vazia.

Aula 8

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Aula 8

Semelhante a Aula 8 (20)

Mais de Divani Barbosa

Mais de Divani Barbosa (19)

Aula 8