Foro de elhacker.net

Programación => Java => Mensaje iniciado por: XxArCaNgElxX en 4 Junio 2011, 05:04 am


Título: Tad en q parte stoy fallando!!!
Publicado por: XxArCaNgElxX en 4 Junio 2011, 05:04 am
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
  1. public class TadPila implements Pila {
  2.  
  3.     private static class pilaVacia extends Exception {
  4.  
  5.         public pilaVacia() {
  6.         }
  7.     }
  8.         private int tope;
  9.     private int max=4;
  10.     private int[] Datos;
  11.  
  12.     public TadPila() {
  13.  
  14.  
  15.         Datos=new int[max];  //crear la pila vacia
  16.  
  17.     }
  18.  
  19.  
  20.  
  21.     public boolean pilaVacia() {
  22.        // throw new UnsupportedOperationException("Not supported yet.");
  23.  
  24.         if(tope==0)
  25.  
  26.             return true;
  27.         else
  28.             return false;
  29.  
  30.  
  31.     }
  32.  
  33.     public boolean pilaLlena() {
  34.         //throw new UnsupportedOperationException("Not supported yet.");
  35.  
  36.         if(tope==max)
  37.             return true;
  38.         else
  39.             return false;
  40.  
  41.     }
  42.  
  43.     public void apilar(int dato) {
  44.         //throw new UnsupportedOperationException("Not supported yet.");
  45.         if(pilaLlena()){
  46.             System.out.println("Desbordamiento pila llena");
  47.         }else{
  48.             tope+=1;
  49.             Datos[tope]=dato;
  50.         }
  51.     }
  52.  
  53.     public int desapilar() {
  54.       //  throw new UnsupportedOperationException("Not supported yet.");
  55.       int dato=-999;
  56.       if(pilaVacia()){
  57.           System.out.println("Underflow pila vacia...");
  58.  
  59.       }else{
  60.           dato=Datos[tope];
  61.           tope-=1;
  62.       }
  63.       return dato;
  64.         // <editor-fold defaultstate="collapsed" desc="comment">
  65.     }// </editor-fold>
  66.     public void escribirPila(){
  67.         int dato;
  68.         if(!pilaVacia()){
  69.             dato=desapilar();
  70.             System.out.println(dato);
  71.             escribirPila();
  72.             apilar(dato);
  73.  
  74.         }
  75.     }
  76.    public void repetirN (Pila p, int n)  {
  77.          int elem, i;
  78.         if (!p.pilaVacia ()) {
  79.          elem = p.desapilar ();
  80.         repetirN (p, n);
  81.         for (i = 0; i < n; i++){
  82.             p.apilar (elem);
  83.         }
  84.  
  85. }
  86.     }
  87.     public void imprimir(){
  88.         int dato,i;
  89.         for(i=0;i<tope+1;i++){
  90.             dato=Datos[i];
  91.             System.out.println(dato);
  92.         }
  93.     }
  94.      public void Imprime_Datos()
  95.         {
  96.                 if(pilaVacia()==true)
  97.                 {
  98.                         System.out.println("La pila esta vacia, ingrese datos primero:");
  99.                 }
  100.                 else
  101.                         for(int Contador=1;Contador<Datos.length;Contador++)
  102.                                 System.out.println("Los valores de la pila son:"+Datos[Contador]);
  103.         }
  104.  
  105.  
  106.  
  107. }
  108. /////////////////////esta es mi interfaz/////////////////////////////////////////
  109. public interface Pila {
  110.  
  111.     boolean pilaVacia();
  112.     boolean pilaLlena();
  113.     void apilar(int dato);
  114.     void repetirN(Pila p, int n);
  115.     int desapilar();
  116.  
  117. }
  118. ////////////////este es mi main/////////////////////////
  119.     public static void main(String[] args) {
  120.  
  121.         TadPila p1= new TadPila();
  122.         int dato = 0;
  123.        int n=2;
  124.         p1.apilar(1);
  125.  
  126.         p1.apilar(2);
  127.  
  128.         p1.apilar(3);
  129.  
  130.          p1.escribirPila();
  131.  
  132.  
  133.          p1.imprimir();
  134.  
  135.          p1.Imprime_Datos();
  136.                  p1.repetirN(p1, n);
  137.  
  138.  
  139.     }
  140.  

Título: Re: Tad en q parte stoy fallando!!!
Publicado por: ShotgunLogic en 4 Junio 2011, 15:42 pm
Código:
   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 :laugh:



Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines