Pilhas

java.teen · Agosto 29, 2012, 10:15pm

Olá galera =) irei postar meu código sobre pilhas abaixo e queria que analisassem e dissessem o que acharam:

Classe com os método push e pop:

[code]import javax.swing.JOptionPane;

public class MetodosStack {
public String [] elemento=new String [10];
public String resultado="";
public int i;

public void push(int i){
    for(i=0;i<10;i++){
	   this.elemento[i]=JOptionPane.showInputDialog("Digite"+" "+(i+1)+"º"+" elemento");

	    if( ((String)this.elemento[i]).isEmpty()){
    	
		   JOptionPane.showMessageDialog(null,"O elemento não pode ser nulo"); 
		   System.exit(1);

	    }
    
    
     }

     for(i=10-1;i>=0;i--){
	   resultado=resultado+((i+1)+"["+this.elemento[i])+"]"+"\n";
	   JOptionPane.showMessageDialog(null,"Sua pilha está assim: "+"\n"+resultado);	

     }


 }
 public String pop() {
    if(this.elemento[i].isEmpty()){
		JOptionPane.showMessageDialog(null,"Adicione um elemento a pilha!!!");
	}
    for(i=10-1;i>=5;i--){
	     String resultado=" ";
    	 resultado=resultado+"Removendo "+(i+1)+"º "+"elemento: "+"\n"+(i+1)+"["+(this.elemento[i])+"]"+"\n";
	     JOptionPane.showMessageDialog(null,"\n"+resultado);
    }
    for(i=5-1;i>=0;i--){
    	String resultado;
    	resultado=((i+1)+"["+this.elemento[i]+"]")+"\n";
    	JOptionPane.showMessageDialog(null,"Pilha atual: "+"\n"+resultado+"\n");
    	
    }
  return resultado=" ";
	   
   	
 }

}
[/code]

Classe principal:

[code]import javax.swing.JOptionPane;
public class PrincipalStack {

/**
 * by:Robson Barreto
 */
public static void main(String[] args) {
	// TODO Auto-generated method stub
MetodosStack stack= new MetodosStack();

int op=0;
do{
op=Integer.parseInt(JOptionPane.showInputDialog(“Selecione uma opção: “+”\n”+“1- Empilhar”+"\n"+“2-Desempilhar”));

switch(op){

case 1:stack.push(0);
break;

  case 2: 
	  
	  JOptionPane.showMessageDialog(null,"\n"+stack.pop());
  break;

}
}while(op!=0);

}[/code]

Obrigado !!!

darklordkamui · Agosto 30, 2012, 5:23am

bacana… mas… e qual é a sua duvida?

magostta · Agosto 30, 2012, 6:04am

Analisei meio por cima.

Então, não faz muito sentido você ler os elementos/listar dentro da classe da pilha.

Segundo, sua pilha esta limitada a somente 10 elementos(a não ser que tenha sido de proposito)

Terceiro, não é legal ficar concatenando String desta forma

"Removendo "+(i+1)+"º "+"elemento: "+"\n"

Dê uma olhada em StringBuilder

Se quiser aprender mais sobre pilha, dê uma olhada na classe java.util.LinkedList (Não utiliza vetor, e sim uma lista ligada)

java.teen · Agosto 30, 2012, 9:57am

[quote=magostta]Analisei meio por cima.

Então, não faz muito sentido você ler os elementos/listar dentro da classe da pilha.

Segundo, sua pilha esta limitada a somente 10 elementos(a não ser que tenha sido de proposito)

Terceiro, não é legal ficar concatenando String desta forma

"Removendo "+(i+1)+"º "+"elemento: "+"\n"

Dê uma olhada em StringBuilder

Se quiser aprender mais sobre pilha, dê uma olhada na classe java.util.LinkedList (Não utiliza vetor, e sim uma lista ligada)
[/quote]

Cara valeu pelas dicas porém esse código foi feito para ter só 10 elementos mesmo, o propósito dele é mais didático, visto que foi feito como trabalho para explicar o conceito de pilha para a turma onde eu estudo !!!

al.barbosa · Agosto 30, 2012, 11:52am

java.teen,

Eu analisei e achei que não ficou boa a separação de responsabilidades entre as classes.
Explico: em projeto orientado a objetos, é importante que cada classe possua responsabilidades bem definidas. É o conceito de coesão.
Normalmente uma classe pilha fica responsável apenas por guardar os elementos da pilha, empilhar, desempilhar e gerenciar a pilha. Pode usar um vetor para isso.
Uma outra classe ficaria responsável por interagir com o usuário e manipular a pilha.
Também não é necessário empilhar todos os 10 elementos e desempilhar os 10 de uma vez. Pode ficar por conta do usuário empilhar ou desempilhar à vontade.

No tópico abaixo tem um exemplo muito bom de pilha, do Mantu (Luciano Mantuaneli). No construtor da classe SimpleStack você passa o número máximo de elmentos da pilha, que será o tamanho do vetor:

Tomei a liberdade de usar a classe SimpleStack do Mantu e criei um código que o usuário pode usar para empilhar e desempilhar. Rode e veja o que você acha:

[code]import javax.swing.*;

public class Main {
static SimpleStack pilha = new SimpleStack(10);

public static void main(String[] args) {  
    int op;

    while(true){
        String resposta = JOptionPane.showInputDialog(null, "Selecione uma opcao: \n"+
                                                     "1 - Empilhar\n"+
                                                     "2 - Desempilhar\n"+
                                                     "3 - Listar");
        if(resposta == null) return;

        try{
           op = Integer.parseInt(resposta);
        }catch(NumberFormatException e){
           JOptionPane.showMessageDialog(null, "Opcao invalida.");
           continue;
        }

        switch(op){
        case 1:
           empilhar();
           break;
        case 2:
           desempilhar();
           break;
        case 3:
           listar();
           break;
        }
    }
}

private static void empilhar(){
    String valor = JOptionPane.showInputDialog(null, "Digite o elemento a inserir na pilha: ");
    valor = pilha.push(valor);
    if(valor == null){
        JOptionPane.showMessageDialog(null,"A pilha está cheia.");
    }
}

private static void desempilhar(){
    String valor = pilha.pop();
    if(valor == null){
        JOptionPane.showMessageDialog(null,"Não ha mais elementos na pilha.");
    }else{
        JOptionPane.showMessageDialog(null,"Desempilhado o elemento: "+valor);
    }
}

private static void listar(){
    JOptionPane.showMessageDialog(null, pilha.toString());
}

}[/code]

[code]/**

@author luciano.mantuaneli
@date 01/04/2008
*/
//package br.com.mantu.help.guj.zagaia.stack;

/**

@author luciano.mantuaneli
@date 01/04/2008
/
public class SimpleStack {
/*
- Vetor de String que armazenará os elementos.
- Se uma posição estiver nula, esta posição será encarada como uma posição
- vazia na pilha. Sendo assim, nunca poderá existir uma posição vazia
- seguida de uma posição não-vazia(diferente de null), pois isso indicaria
- que, de alguma forma, removemos algum elemento da pilha que não o do topo.
  /
  private String[] elements;
  /*
- inteiro que indicará quantos elementos NÃO NULOS existem dentro de
- elements. Note por exemplo que:
- -Se size for igual a 26, o topo da pilha está na posição 25 de elements
- -Se size for igual a 10, o topo da pilha está na posição 9 de elements
- -Se size for igual a n, o topo da pilha está na posição (n - 1) de elements
- Resumindo, podemos assumir QUASE sempre que o topo da pilha é a posição
- (size - 1) de elements.
- O “quase” se deve ao caso de quando nossa pilha é vazia. Nesse caso,
- size é igual a 0. Se fossemos seguir a regra acima indistintamente,
- acabaríamos assumindo que neste caso o topo da pilha está na posição -1
- de elements, o que é um erro… Trata-se então de uma exceção, a qual
- deveremos estar atentos para fazer bobagem!
- Para fins didáticos, criaremos um método privado que retorna a posição
- exata do topo da pilha, e sempre utilizaremos este método para termos tal
- informação.
  */
  private int size;
/**
- Construtor que recebe um int como parâmetro, indicando qual será a
- capacidade da pilha recém-instanciada
  /
  public SimpleStack(int capacity) {
  /
  - Utilizamos o método abs da classe Math só pra evitar que se tente
  - criar uma pilha “devedora”…
    */
    elements = new String[Math.abs(capacity)];
    size = 0;
    }
/**
- Método utilizado para adicionar elementos à nossa pilha. Este elemento
- sempre será inserido no topo deta pilha.
- -Se o elemento for null, vamos lançar uma exceção, informando que nossa
- pilha não aceita null como elemento válido.
- -Se a pilha estiver cheia, retornamos null para indicar que não foi
- possível insirir elemento.
- -Se o elemento for inserido com sucesso, retornamos o próprio elemento,
- indicando assim o sucesso da operação
  */
  public String push(String element) {
  if(element == null)
  throw new IllegalArgumentException(“O elemento não pode ser nulo!”);
  
  if(size == elements.length)
  return null;
  
  size++;
  elements[getTopPosition()] = element;
  return element;
  }
/**
- Método utilizado para se obter o elemento que está no topo desta pilha,
- porém, sem removê-lo da mesma.
- -Se a pilha estiver vazia, retornamos null para indicar que a pilha
- está vazia.
- -Se houver ao menos um elemento na pilha, o elemento que está no topo
- será retornado, indicando o sucesso da operação
  */
  public String peek() {
  if(isEmpty())
  return null;
  
  return elements[getTopPosition()];
  }
/**
- Método utilizado para retirar(“destacar”) um elemento desta pilha. Este
- elemento sempre será aquele que se encontra no topo desta pilha.
- -Se a pilha estiver vazia, retornamos null para indicar que a pilha
- está vazia.
- -Se houver ao menos um elemento na pilha, o elemento que está no topo
- será retornado, indicando o sucesso da operação
  */
  public String pop() {
  String result = peek();
  /Se havia um elemento no topo da pilha…/
  if(result != null) {
  elements[getTopPosition()] = null;
  size–;
  }
  return result;
  }
/**
- Método utilizado para limpar todo o conteúdo da pilha.
  */
  public void clear() {
  for(int i = 0; i < size; i++)
  elements[i] = null;
  size = 0;
  }
/**
- Método utilizado para se obter o tamanho (número de elementos) da pilha
  */
  public int getSize() {
  return size;
  }
/**
- Método utilizado para se obter a capacidade da pilha
  */
  public int getCapacity() {
  return elements.length;
  }
/**
- Método utilizado para verificar se a pilha está vazia. Se for o caso,
- será retornado true, caso contrário, será retornado false.
  */
  public boolean isEmpty() {
  return size <= 0;
  }
/**
- Este método tem uma finalidade estritamente didática, visando facilitar o
- entendimento do código desta classe.
- Este método retorna um inteiro que representa a posição de elements onde
- se encontra o último elemento inserido nesta pilha (O topo da pilha)
  */
  private int getTopPosition() {
  if (isEmpty())
  return 0;
  return size - 1;
  }
/**
- Este método serve para representar textualmente esta pilha
- @see java.lang.Object#toString()
  */
  public String toString() {
  StringBuilder sb = new StringBuilder("[");
  for(int i = 0; i < size; i++) {
  sb.append(elements[i]);
  if(i < size - 1)
  sb.append(" | “);
  }
  sb.append(”>");
  
  return sb.toString();
  }
  } [/code]

java.teen · Agosto 30, 2012, 9:37pm

[quote=al.barbosa]java.teen,

Eu analisei e achei que não ficou boa a separação de responsabilidades entre as classes.
Explico: em projeto orientado a objetos, é importante que cada classe possua responsabilidades bem definidas. É o conceito de coesão.
Normalmente uma classe pilha fica responsável apenas por guardar os elementos da pilha, empilhar, desempilhar e gerenciar a pilha. Pode usar um vetor para isso.
Uma outra classe ficaria responsável por interagir com o usuário e manipular a pilha.
Também não é necessário empilhar todos os 10 elementos e desempilhar os 10 de uma vez. Pode ficar por conta do usuário empilhar ou desempilhar à vontade.

No tópico abaixo tem um exemplo muito bom de pilha, do Mantu (Luciano Mantuaneli). No construtor da classe SimpleStack você passa o número máximo de elmentos da pilha, que será o tamanho do vetor:

Tomei a liberdade de usar a classe SimpleStack do Mantu e criei um código que o usuário pode usar para empilhar e desempilhar. Rode e veja o que você acha:

[code]import javax.swing.*;

public class Main {
static SimpleStack pilha = new SimpleStack(10);

public static void main(String[] args) {  
    int op;

    while(true){
        String resposta = JOptionPane.showInputDialog(null, "Selecione uma opcao: \n"+
                                                     "1 - Empilhar\n"+
                                                     "2 - Desempilhar\n"+
                                                     "3 - Listar");
        if(resposta == null) return;

        try{
           op = Integer.parseInt(resposta);
        }catch(NumberFormatException e){
           JOptionPane.showMessageDialog(null, "Opcao invalida.");
           continue;
        }

        switch(op){
        case 1:
           empilhar();
           break;
        case 2:
           desempilhar();
           break;
        case 3:
           listar();
           break;
        }
    }
}

private static void empilhar(){
    String valor = JOptionPane.showInputDialog(null, "Digite o elemento a inserir na pilha: ");
    valor = pilha.push(valor);
    if(valor == null){
        JOptionPane.showMessageDialog(null,"A pilha está cheia.");
    }
}

private static void desempilhar(){
    String valor = pilha.pop();
    if(valor == null){
        JOptionPane.showMessageDialog(null,"Não ha mais elementos na pilha.");
    }else{
        JOptionPane.showMessageDialog(null,"Desempilhado o elemento: "+valor);
    }
}

private static void listar(){
    JOptionPane.showMessageDialog(null, pilha.toString());
}

}[/code]

[code]/**

@author luciano.mantuaneli
@date 01/04/2008
*/
//package br.com.mantu.help.guj.zagaia.stack;

/**

@author luciano.mantuaneli
@date 01/04/2008
/
public class SimpleStack {
/*
- Vetor de String que armazenará os elementos.
- Se uma posição estiver nula, esta posição será encarada como uma posição
- vazia na pilha. Sendo assim, nunca poderá existir uma posição vazia
- seguida de uma posição não-vazia(diferente de null), pois isso indicaria
- que, de alguma forma, removemos algum elemento da pilha que não o do topo.
  /
  private String[] elements;
  /*
- inteiro que indicará quantos elementos NÃO NULOS existem dentro de
- elements. Note por exemplo que:
- -Se size for igual a 26, o topo da pilha está na posição 25 de elements
- -Se size for igual a 10, o topo da pilha está na posição 9 de elements
- -Se size for igual a n, o topo da pilha está na posição (n - 1) de elements
- Resumindo, podemos assumir QUASE sempre que o topo da pilha é a posição
- (size - 1) de elements.
- O “quase” se deve ao caso de quando nossa pilha é vazia. Nesse caso,
- size é igual a 0. Se fossemos seguir a regra acima indistintamente,
- acabaríamos assumindo que neste caso o topo da pilha está na posição -1
- de elements, o que é um erro… Trata-se então de uma exceção, a qual
- deveremos estar atentos para fazer bobagem!
- Para fins didáticos, criaremos um método privado que retorna a posição
- exata do topo da pilha, e sempre utilizaremos este método para termos tal
- informação.
  */
  private int size;
/**
- Construtor que recebe um int como parâmetro, indicando qual será a
- capacidade da pilha recém-instanciada
  /
  public SimpleStack(int capacity) {
  /
  - Utilizamos o método abs da classe Math só pra evitar que se tente
  - criar uma pilha “devedora”…
    */
    elements = new String[Math.abs(capacity)];
    size = 0;
    }
/**
- Método utilizado para adicionar elementos à nossa pilha. Este elemento
- sempre será inserido no topo deta pilha.
- -Se o elemento for null, vamos lançar uma exceção, informando que nossa
- pilha não aceita null como elemento válido.
- -Se a pilha estiver cheia, retornamos null para indicar que não foi
- possível insirir elemento.
- -Se o elemento for inserido com sucesso, retornamos o próprio elemento,
- indicando assim o sucesso da operação
  */
  public String push(String element) {
  if(element == null)
  throw new IllegalArgumentException(“O elemento não pode ser nulo!”);
  
  if(size == elements.length)
  return null;
  
  size++;
  elements[getTopPosition()] = element;
  return element;
  }
/**
- Método utilizado para se obter o elemento que está no topo desta pilha,
- porém, sem removê-lo da mesma.
- -Se a pilha estiver vazia, retornamos null para indicar que a pilha
- está vazia.
- -Se houver ao menos um elemento na pilha, o elemento que está no topo
- será retornado, indicando o sucesso da operação
  */
  public String peek() {
  if(isEmpty())
  return null;
  
  return elements[getTopPosition()];
  }
/**
- Método utilizado para retirar(“destacar”) um elemento desta pilha. Este
- elemento sempre será aquele que se encontra no topo desta pilha.
- -Se a pilha estiver vazia, retornamos null para indicar que a pilha
- está vazia.
- -Se houver ao menos um elemento na pilha, o elemento que está no topo
- será retornado, indicando o sucesso da operação
  */
  public String pop() {
  String result = peek();
  /Se havia um elemento no topo da pilha…/
  if(result != null) {
  elements[getTopPosition()] = null;
  size–;
  }
  return result;
  }
/**
- Método utilizado para limpar todo o conteúdo da pilha.
  */
  public void clear() {
  for(int i = 0; i < size; i++)
  elements[i] = null;
  size = 0;
  }
/**
- Método utilizado para se obter o tamanho (número de elementos) da pilha
  */
  public int getSize() {
  return size;
  }
/**
- Método utilizado para se obter a capacidade da pilha
  */
  public int getCapacity() {
  return elements.length;
  }
/**
- Método utilizado para verificar se a pilha está vazia. Se for o caso,
- será retornado true, caso contrário, será retornado false.
  */
  public boolean isEmpty() {
  return size <= 0;
  }
/**
- Este método tem uma finalidade estritamente didática, visando facilitar o
- entendimento do código desta classe.
- Este método retorna um inteiro que representa a posição de elements onde
- se encontra o último elemento inserido nesta pilha (O topo da pilha)
  */
  private int getTopPosition() {
  if (isEmpty())
  return 0;
  return size - 1;
  }
/**
- Este método serve para representar textualmente esta pilha
- @see java.lang.Object#toString()
  */
  public String toString() {
  StringBuilder sb = new StringBuilder("[");
  for(int i = 0; i < size; i++) {
  sb.append(elements[i]);
  if(i < size - 1)
  sb.append(" | “);
  }
  sb.append(”>");
  
  return sb.toString();
  }
  } [/code]

[/quote]
Entendi cara valeu pelos toques,essa ideia de deixar o usuário empilhar 1 elemento por exemplo e empilhar um outro depois(anulando o fato dele ter que fazer a pilha toda de uma vez) eu pensei também, porém minha apresentação é amanhã e fica muito em cima para mim fazer as alterações !!! Futuramente vou aprimorar mais o código. Valeu mesmo!

davidbuzatto · Agosto 31, 2012, 8:32am

Uma versão mais simples e genérica.[code]public class Pilha {

private No<T> topo;

public void empilhar( T valor ) {
    No<T> novoNo = new No<T>( valor );
    novoNo.anterior = topo;
    topo = novoNo;
}

// retorna null se a pilha estiver vazia
public T desempilhar() {

    if ( !estaVazia() ) {
        T valor = topo.valor;
        topo = topo.anterior;
        return valor;
    }

    return null;

}

// retorna null se a pilha estiver vazia
public T topo() {

    if ( !estaVazia() ) {
        return topo.valor;
    }

    return null;

}

public boolean estaVazia() {
    return topo == null;
}

public void imprimir() {

    No<T> atual = topo;

    while ( atual != null ) {
        System.out.println( atual.valor );
        atual = atual.anterior;
    }

}

public static void main( String[] args ) {

    Pilha<String> p = new Pilha<String>();
    p.imprimir();

    p.empilhar( "Foo" );
    p.empilhar( "Bar" );
    p.empilhar( "David" );

    p.imprimir();

    System.out.println( "Desempilhou: " + p.desempilhar() );
    p.imprimir();

}

private class No<T> {

    T valor;
    No<T> anterior;

    No( T valor ) {
        this.valor = valor;
    }

}

}[/code]

system · Dezembro 28, 2015, 4:16pm

Pilhas

Cursos de Mobile

Cursos de Programação

Cursos de Front-end

Cursos de DevOps

Cursos de Design & UX

Cursos de Business

Cursos de Data & BI