Estrutura de Dados - PILHAS

Estrutura de Dados(Aula 03)

INSTITUTO FEDERALTRIÂNGULO MINEIRO

Campus Uberlândia Centro

1. Estrutura de Dados

8.1 Pilha

8.2 Fila

8.3 Lista

8.4 Árvores de pesquisa

http://www.inf.ufsc.br/~ronaldo/ine5384/15-OrdenacaoDados.pdf

Tema da aula



Introdução

oAté o momento:

o Vetores estáticos;

o Com tamanho definido;

oAcesso sequêncial;

o De agora em diante:

o Estruturas dinâmicas;

o Com tamanho indefinido;

0 1 2 3 4 5

3 8 7 9 0 3

3 8 7 9 0 3



Pilha(Stack)



Estrutura de dados de pilha

o É a estrutura de dados mais simples;

o É implementada diretamente pelo hardware das máquinas modernas;

o Idéia fundamental da pilha é que todo o acesso a seus elementos é feito através do seu topo;

o O único elemento que pode ser removido é o topo;

o Com esse fundamento faz com que os elementos da pilha sejam retirados de ordem inversa;

o LIFO – Last In First Out



Funcionamento de uma pilha



Exemplo de uma aplicação com uso de pilha

http://www.gameson.com.br/Jogos-Online/ClassicoPuzzle/Torre-de-

Hanoi.html



Elementos de uma pilha

o criar uma pilha vazia;

o inserir um elemento no topo de uma pilha;

o remover o elemento que está no topo de pilha;

o verificar se a pilha esta vazia;

o verificar o elemento que esta no topo da pilha;

o zerar a pilha;



Elementos de uma pilha

oPilha com vetores



TDA de uma pilha

oEmpilha(elemento) – insere um objeto no topo da pilha

•Entrada = objeto saida = nenhum

oDesempilhar() - retira um objeto do topo de pilha e o retorna,

deverá ter uma proteção pois a pilha não pode estar vazia

•Entrada = nenhum saída = objeto

oTamanho() - retorna o número de objetos dentro de uma pilha

•Entrada = nenhuma saída = inteiro

oVazia() - retorna um booleano indicando se a pilha está vazia

•Entrada = nenhuma saída = booleano



TDA de uma pilha

oTopo() - retorna o objeto que está no topo de uma pilha,

deverá ter uma proteção para a pilha vazia;

•Entrada = nenhuma saída = objeto



Pilha pronta em JAVA




o Em Java já temos uma classe para o TDA pilha, portanto

basta importarmos o:

•java.util.Stack

o Os métodos push(obj) e pop() são equivalentes a empilha(o)

e desempilha() respectivamente

o O método peek() é equivalente ao método topo(), tamanho()

e vazia();

o Os métodos pop() e peek() laçam a exceção

StackEmptyException se a pilha estiver vazia




package PilhaJava;

import java.util.EmptyStackException;

import java.util.Stack;




Try{ // usou try pois a pilha pode estar vazia

Stack pilha = new Stack();

//cria uma pilha como se fosse um objeto genérico

. . .

}

catch(EmptyStackException e){

System.out.println("Pilha vazia");

}




try{ // usou try pois a pilha pode estar vazia

. . .

pilha.push(1);

pilha.push(2);

System.out.println(pilha.peek());

pilha.pop();


pilha.pop();


}

catch(EmptyStackException e){


}



Pilha com vetor



Pilha com vetor

package PilhaVetor;

public class PilhaVetor {

public static final int total = 1000;

private int capacidade;

private Object pilha[];

private int topo = -1;

public PilhaVetor(){}



Pilha com vetor

public PilhaVetor(int tam){

capacidade = tam;

pilha = new Object[capacidade];

}

// retorna a quantidade de elementos da // pilha

public int tamanho(){

return topo + 1;

}



Pilha com vetor

// empilha um certo elemento no topo da

// pilha

public void empilhar(Object elemento){

if(tamanho() == capacidade)

System.out.println("Pilha Cheia");

else

pilha[++topo] = elemento;

}

// informa se a pilha estah vazia ou nao

public boolean vazia(){

return(topo < 0);

}



Pilha com vetor

// retira e retorna o elemento que estah

// no topo da pilha

public Object desempilhar(){

Object fora = null;

if(vazia())

System.out.println("Pilha Vazia");

else{

fora = pilha[topo];

pilha[topo] = null;

topo--;

}

return fora;

}



Pilha com vetor

// retorna o elemento que estah no topo

// de uma pilha

public Object verTopo(){

if(!vazia())

return pilha[topo];

else

return null;

}



Pilha com vetor

public static void main(String[] args) {

Dados a = new Dados("Ricardo", "Rua x", 34);

Dados b = new Dados("Maria", "Rua y", 60);

Dados c = new Dados("Joao", "Rua v", 19);

PilhaVetor pilha = new PilhaVetor(3);

pilha.empilhar(a);

pilha.empilhar(b);

pilha.empilhar(c);

Dados res = (Dados) pilha.verTopo();

System.out.println(res.getNome() + " - "

+ res.getEndereco() + " - "

+ res.getIdade());

pilha.desempilhar();



Pilha com vetor

res = (Dados) pilha.verTopo();



+ res.getIdade());

pilha.desempilhar();

res = (Dados) pilha.verTopo();

if (res != null)



+ res.getIdade());

else




TDA de uma pilha

Representação do nó ou célula

Representação da pilha

topo



TDA de uma pilha

public class No<T> {

private T valor;

private No<T> proximo;

public No(T valor, No<T> proximo) {

this.valor = valor;

this.proximo = proximo;

}

public No(){}

....

// alem disso temos os

// métodos de getters e

// setters

}

Representação do nó ou célula



TDA de uma pilha

ublic class Pilha<T> {

protected No<T> topo;

protected int tamanho;

public Pilha(){

tamanho = 0;

topo = null;

}

....

} Representação da pilha

topo



Criar uma pilha e verificar pilha vazia

public Pilha(){

tamanho = 0;

topo = null;

}



Criar uma pilha e verificar pilha vazia

public boolean vazia(){

return topo == null;

}

public int tamanho(){

return tamanho;

}



Inserção na pilha (i)

1. Pré-requisito: pilha tem que estar criada e o próximo apontando

para NULL;

2. Criar um nó ou célula;

3. Atribuir o elemento ao campo info;

4. O próximo do nó criado será ligado ao para quem o topo esta apontando



Inserção na pilha (ii)

5. Faz o topo apontar para o elemento que foi inserido

Próximo passo:

6. O próximo do nó criado será ligado ao para quem o topo esta apontando



Inserção na pilha (iii)




Inserção na pilha (iii)


void empilhar (T elemento){

No<T> aux = new No(null, null);

aux.setValor(elemento);

aux.setProximo(topo);

topo = aux;

tamanho++;

}



Remoção da pilha (i)

1. Pré-condição é que tenha elementos na pilha.

2. Auxiliar recebe o topo da pilha

3. O topo aponta para o próximo do auxiliar



Remoção da pilha (i)

T desempilhar (){

No<T> aux = null;

T elemento = null;

if (vazia()) {

System.out.println("Pilha vazia\n");

}

else {

aux = topo;

elemento = topo.getValor();

topo = aux.getProximo();

tamanho--;

}

return elemento;

}



Ver topo da pilha (i)

1. Pré-requisito é ter elementos na pilha.

2. Um nó auxiliar recebe o topo e depois apresenta o que tem como info;

void verTopo(){

No<T> aux = null;

if (!vazia()) {

aux = topo;

System.out.println("Topo: " + aux.getValor());

}

else{

System.out.println("Pilha vazia\n");

}

}



Zerar pilha

public static void main(String[] args){

Pilha<Integer> p = new Pilha();

p.empilhar(1);

p.verTopo();

p.empilhar(2);

p.verTopo();

Integer res = p.desempilhar();

System.out.println("Retirado: " + res.toString());

p.verTopo();

res = p.desempilhar();

System.out.println("Retirado: " + res.toString());

p.verTopo();

}



Exercícios

• Dado o TDA abaixo criar uma pilha para armazenar dos dados;

Contatos:

nome;

Endereco:

rua;

bairro;

cep;

numero;

Telefone:

fixo;

celular;

trabalho;

email;



Exercícios

• Método principal

printf(“Menu”);

printf(“\n1.Empilhar”);

printf(“\n2.Desempilhar”);

printf(“\n3.Ver Topo”);

printf(“\n4.Zerar”);

printf(“\n5.Sair”);

printf(“\nDigite a opcao: ”);

scanf(“%d”, &opcao);



Praticar

• Considerando uma Pilha vazia, quais são os comandos necessários para a inserção do 1o nó ?

• Considerando uma Pilha não vazia, quais são os comandos necessários para a exclusão de um nó ?

• Considerando uma Pilha não vazia, quais são os comandos necessários para a inserção de um novo nó ?



Praticar implementação

• Escreve um programa que utilizando uma pilha determina se uma string é um palíndromo ou não, isto é, se pode ser lida da mesma maneira para frente ou para trás.

• Implemente uma APLICAÇÃO que utilize uma pilha para conversão de expressões da notação tradicional (infixa), completamente parentizadas, para a e notação polonesa reversa (pós-fixada).



Praticar implementação

Implemente uma APLICAÇÃO que utilize uma pilha para conversão de expressões da notação tradicional (infixa), completamente parentizadas, para a e notação polonesa reversa (pré-fixada).



Fim da aula.....

[email protected]

mailto:[email protected]

Estrutura de Dados - PILHAS

Technology

Transcript of Estrutura de Dados - PILHAS