Invertir pila en java

[ivankiros]

Hola dispongo de los siguientes metodos para crear una pila, desapilarla , saber cuala es la que esta arriba , baciarla ...
Me podeis ayudar a crear un metodo que invierta una pila ?
Un ejemplo es que si yo inserto la palabra HOLA que me muestre como resultado ALOH .

import java.util.*;

public class Apilar {

LinkedList pilar = new LinkedList();

public void apila(Object element)
{
pilar.addFirst(element);
}

public Object desapila()
{
return pilar.removeFirst();
}

public Object cim()
{
if(esbuida())
{
return null;
}
else
{
return pilar.getFirst();
}
}

public void inicia()
{
pilar.clear();
}


public boolean esbuida()
{
return (pilar.size()==0);
}

[napartar]

Lo más sencillo, utilizar una pila nueva para almacenar los elementos, aunque no sé si te permiten hacerlo.

Código:

pila2 = new Pila();
while (!pila1.esbuida()){
pila2.apila(pila1.desapila());
}
return pila2;

[Xerelo]

Si no te exigen crear tu propio algoritmo

http://download.oracle.com/javase/1....a.util.List%29

[ivankiros]

Muchas gracias napar . Es exactamente lo que necesitaba . Siceramente no se me da bien java. Ara e implementado tu parte del codigo pero no me acaba de funcionar . Te pego el codigo aber si me podrias decir donde fallo porque no me da errores Jcreator xo el resultado es null xD
El fallo imagino que tiene que estar en el metodo invierte ...

import java.util.*;

public class Apilar {

LinkedList pilar = new LinkedList();

public void apila(Object element)
{
pilar.addFirst(element);
}

public Object desapila()
{
return pilar.removeFirst();
}

public Object cim()
{
if(esbuida())
{
return null;
}
else
{
return pilar.getFirst();
}
}

public void inicia()
{
pilar.clear();
}


public boolean esbuida()
{
return (pilar.size()==0);
}

//METODO INVERTIR PILA
public Object invierte() {
Apilar pila2 = new Apilar();
while (!esbuida()){
pila2.apila(desapila());
}
return pila2;
}



public static void main(String[] args)
{
//CREAMOS PILA
Apilar Pila = new Apilar();
String elemento1="H";
String elemento2="O";
String elemento3="L";
String elemento4="A";

//METEMOS EN LA PILA
Pila.apila(elemento1);
Pila.apila(elemento2);
Pila.apila(elemento3);
Pila.apila(elemento4);

//MOSTRAMOS PILA ORIGINAL
System.out.println(" Pila 1 : "+ Pila.cim());
Pila.desapila();
System.out.println(" Pila 1 : "+ Pila.cim());
Pila.desapila();
System.out.println(" Pila 1 : "+ Pila.cim());
Pila.desapila();
System.out.println(" Pila 1 : "+ Pila.cim());

//CREAMOS PILA INVERTIDA
Apilar Pila2 = new Apilar();

//METEMOS EN LA PILA
Pila2.apila(elemento1);
Pila2.apila(elemento2);
Pila2.apila(elemento3);
Pila2.apila(elemento4);

//INVERTIMOS LA PILA
Pila2.invierte();

//MOSTRAMOS PILA INVERTIDA
System.out.println(" Pila 2 : "+ Pila2.cim());
Pila.desapila();
System.out.println(" Pila 2 : "+ Pila2.cim());
Pila.desapila();
System.out.println(" Pila 2 : "+ Pila2.cim());
Pila.desapila();
System.out.println(" Pila 2 : "+ Pila2.cim());



} //FIN MAIN
}//FIN CLASE



RESULTADO :

Pila 1 : A
Pila 1 : L
Pila 1 : O
Pila 1 : H
Pila 2 : null
Pila 2 : null
Pila 2 : null
Pila 2 : null

[Heimish2000]

Es que en el metodo invierte lo unico que estás haciendo es desapilar, nada más.

Tu problema es que el método desapila no devuelve la cima, y es lo que tienes que coger antes de desapilar. Vamos, el metodo sería algo así. Por cierto, mejor que devuelva una pila que no un Object (eso para todos los métodos que tengas, cuando sepas el tipo de dato que devuelve, mejor indicarlo y no poner el genérico)

Por otra parte, en tu main, estas llamando al método invierte, que devuelve la pila invertida, pero no la estás recogiendo. En el método que te pongo, el resultado de la inversión se guarda en la propia pila, no devolvería nada el método, pero tienes que tener estas cosas en cuenta.

Código Java:

public void invierte() {
Apilar pila2 = new Apilar();
while (!pilar.esbuida()){
pila2.apila(pilar.cim());
pilar.desapila();
}
pilar = pila2;
}
 

[napartar]

Como dice Heimish, en la progamación orientada a objetos es conveniente implementar los métodos que repercuten al objeto sobre él mismo. De esta forma, podremos actuar sobre el objeto modificándolo a nuestro gusto. Tal y como habías hecho en tu código, bastaría recoger los resultados en una pila nueva:

Código:

Apilar p = Pila2.invierte();
//Imprimir p

Sin embargo esta no es la idea de la POO. Lo ideal es ejecutar el invertir() sobre la misma pila y que este método modifique la misma. Con el código que ha puesto Heimish, se podría hacer:

Código:

Pila2.invierte();
//Imprimir Pila2

No necesitas una nueva instancia

[ivankiros]

Muchas graciiiasss!!!!! Ya esta hecho !!!!

[napartar]

Aquí lo tienes en recursivo:

Código Java:

public invierte(){
Apilar p2 = new Apilar();
invierte1(this, p2);
pilar = p2;
}
 
private void invierte1(Apilar p, Apilar p2){
if(p.size() == 0)
return;
else{
p2.apila(p.desapila());
invierte1(p,p2);
}
}
 

[ivankiros]

SolucionadO!