Tad en q parte stoy fallando!!!

[XxArCaNgElxX]

Buenas amigos aca un problemita en java obre tad pilas.
Tengo mis metodos apilar,desapilar,pilavacia,pilalena imprimir pila esoos son mis metodos.

apilo 3 datos 1,2,3  y de ahi pongo n=2 entonces deberia imprimirme asi 1,2,3,1,2,3 y asi dependiendo cuanto le asigne a n ahi sta el metodo q intente hacer no se q esta mal mi metodo es
repetirN

Código (java) [Seleccionar] Expandir


public class TadPila implements Pila {

    private static class pilaVacia extends Exception {

        public pilaVacia() {
        }
    }
        private int tope;
    private int max=4;
    private int[] Datos;

    public TadPila() {


        Datos=new int[max];  //crear la pila vacia

    }



    public boolean pilaVacia() {
       // throw new UnsupportedOperationException("Not supported yet.");

        if(tope==0)

            return true;
        else
            return false;


    }

    public boolean pilaLlena() {
        //throw new UnsupportedOperationException("Not supported yet.");

        if(tope==max)
            return true;
        else
            return false;

    }

    public void apilar(int dato) {
        //throw new UnsupportedOperationException("Not supported yet.");
        if(pilaLlena()){
            System.out.println("Desbordamiento pila llena");
        }else{
            tope+=1;
            Datos[tope]=dato;
        }
    }

    public int desapilar() {
      //  throw new UnsupportedOperationException("Not supported yet.");
      int dato=-999;
      if(pilaVacia()){
          System.out.println("Underflow pila vacia...");

      }else{
          dato=Datos[tope];
          tope-=1;
      }
      return dato;
        // <editor-fold defaultstate="collapsed" desc="comment">
    }// </editor-fold>
    public void escribirPila(){
        int dato;
        if(!pilaVacia()){
            dato=desapilar();
            System.out.println(dato);
            escribirPila();
            apilar(dato);

        }
    }
   public void repetirN (Pila p, int n)  {
         int elem, i;
        if (!p.pilaVacia ()) {
         elem = p.desapilar ();
        repetirN (p, n);
        for (i = 0; i < n; i++){
            p.apilar (elem);
        }

}
    }
    public void imprimir(){
        int dato,i;
        for(i=0;i<tope+1;i++){
            dato=Datos[i];
            System.out.println(dato);
        }
    }
     public void Imprime_Datos()
        {
                if(pilaVacia()==true)
                {
                        System.out.println("La pila esta vacia, ingrese datos primero:");
                }
                else
                        for(int Contador=1;Contador<Datos.length;Contador++)
                                System.out.println("Los valores de la pila son:"+Datos[Contador]);
        }



}
/////////////////////esta es mi interfaz/////////////////////////////////////////
public interface Pila {

    boolean pilaVacia();
    boolean pilaLlena();
    void apilar(int dato);
    void repetirN(Pila p, int n);
    int desapilar();

}
////////////////este es mi main/////////////////////////
    public static void main(String[] args) {

        TadPila p1= new TadPila();
        int dato = 0;
       int n=2;
        p1.apilar(1);
       
        p1.apilar(2);
       
        p1.apilar(3);
       
         p1.escribirPila();
       
         
         p1.imprimir();
         
         p1.Imprime_Datos();
                 p1.repetirN(p1, n);
         
       
    }


[ShotgunLogic]

Código [Seleccionar] Expandir

   public void repetirN (Pila p, int n)  {
         int elem, i;
        if (!p.pilaVacia ()) {
         elem = p.desapilar ();
        repetirN (p, n);
        for (i = 0; i < n; i++){
            p.apilar (elem);
        }

}

Vale, lo que haces es desapilar todos los elementos, y luego apilarlos de nuevo, n veces. Así a ojo una depuración:

P = [1, 2, 3]
n = 3

llamas al metodo, entonces quitas 3, salta el repetir y quitas 2, salta otra vez y quitas 1. Ahora se resuelve(si, a lo jugador de MTG xD) el bucle del último(en este caso el 1, pero ojo, según veo haces una llamada un procedimiento de más, en el que no haces nada, osea, que no es muy óptimo), con lo cual metes el 1 tres veces, luego el 2 3 veces y el 3 tres veces, quedando:

P = [111, 222, 333]

Solución:

Creo, y digo creo, no se puede(o si se puede es realmente muchas operaciones) ya que sacando los enteros de uno en uno, o como mucho seguidos pero siendo los mismos, no vas a conseguir el orden que esten salteados. Por ejemplo si lo metiesemos en otra pila, podriamos meterlos como mucho como antes, y estariamos igual, ya que para sacarlos solo podemos empezar por arriba, y vamos a tenerlos seguidos.

En resumen, usa un bucle recursivo o algo de manera que la puedas recorrer y coger cada elemento con un get, que es más fácil, y que no lleva tantas operaciones. De todas formas tienes algunos fallitos de optimización que podrias mejorar, pero eso se coge con la prática