Uso de Estrucura Pilas - Caso de Almacen

Introducción

Caso De Almacen

En un almacén se guardan contenedores en grupos de contenedores. Como Maximo, el almacén tiene espacion para M grupos de contenedores. NO es posible colocar mas de N contenedores en cada grupo. Cuando se va a guardar un nuevo contenedor en el Almacen, este se coloca en el primer grupo que tenga espacion. De esta manera, un nuevo grupo de contenedores, se forma, solamente sei es que ya estan llenos los anteriores y si hay espacion para un grupo mas. Cuando se va a retirar un contenedor, deben retirarse primero los que esten encima de el, los cuales se mueven hacia otros grupos, siguendo el mismo criterio cuando se guardan los contenedores. El almacén siempre debe tener espacio disponible para, al menos, N-1 contenedores, para poder mover los contenedores cuando se va a retirar; por tanto la capacidad real del alamacen es (M-1)*N+1.

Ahora vamos al Desarrollo xD!

1.- Creacion del Proyecto

El proyecto se llamará Almacen. Dentro del proyecto Almacén se tendra que colocar el paquete Edtructuras; que contiene la estructura a utilizar; y el paquete almacen que contiene la clase y el programa principal.

Estructura pila

Primero Creamos la Interfaz TPila y Copiamos el siguiente codigo

/**
 *
 * @author JulioCsaR
 */

public interface TPila
{
 void Push(Object dato);
 Object Pop();
 Object Top();
 
 int  Cantidad();
 boolean Vacia();
 Object Obtener(int pos);
 void Modificar(Object dato, int pos);
 int  Buscar(Object dato);
 int  Buscar(Object dato, TComparar cmp);
}

Ahora Creamos la Clase TPilaP y copiamos el siguiente codigo

package Estructuras;

/**
 *
 * @author JulioCsaR
 */

public class TPilaP implements TPila
{
 private TListaP P;

 public TPilaP()
 {
  P = new TListaP();
 }
 
 public void Push(Object dato)
 {
  P.Insertar(dato,0);
 }
 
 public Object Top()
 {
  return P.Obtener(0);
 }
 
 public Object Pop()
 {
  Object aux = Top();
  P.Eliminar(0);
  return aux;
 }
 
 public int Cantidad()
 {
  return P.Cantidad();
 }
 
 public boolean Vacia()
 {
  return P.Vacia();
 }
 
 public Object Obtener(int pos)
 {
  return P.Obtener(pos);
 }
 
 public void Modificar(Object dato, int pos)
 {
  P.Modificar(dato,pos);
 }
 
 public int Buscar(Object dato)
 {
  return P.Buscar(dato);
 }
 
 public int Buscar(Object dato, TComparar cmp)
 {
  return P.Buscar(dato,cmp);
 }
}

Codigificación de la clase Almacén

Paso1 : Ahora se procede a la codificacion de la clase Almacen

package almacen;
//importamos la estructura TPilaP
import Estructuras.TPilaP;

public class AlmacenP {

    int m;
    int n,t;
    TPilaP grupos[];

    public AlmacenP() {
        
        
    }

Paso2: Contructor (M y N). Tener en cuenta que M representa el numero de GRUPOS de contenedores, N representa la CANTIDAD de contenedores, grupos es la estructura a utilizar, de tipo TPila.

public AlmacenP(int m,int n)
{
    this.m=m;
    this.n=n;
    this.grupos=new TPilaP[m];
    for(int i=0;i<m;i++)
    this.grupos[i]=new TPilaP();
    this.t=0;


}

Paso3: Ahora se procede a la codificacion de los metodos de la clase Almacen. Cantidad de grupos, Cantidad de Contenedores.

public int CantidadGrupos()
{
    return m;
}
public int CantidadContenedores (int grupo)
{
  return grupos[grupo].Cantidad();
}
public int CantidadContenedores()
{
    return t;
}

Paso4: Ahora se procede a la codificacion de los metodos de la clase Almacen. GuardarContenedor. Tener en cuenta que aca primero se ubica en que grupo se tiene la capacidad de recibir a un nuevo contenedor, y recien allo es donde se asigna.

public boolean GuardarContenedor( Object contenedor )
{
    if(t==CapacidadAlmacen())
        return false;
    int g;
    g=BuscarGrupoCapacidad(-1);
    grupos[g].Push(contenedor);
    t++;
    return true;
}

Paso5: Ahora se procede a la codificacion de los metodos de la clase Almacen. RetirarContenedor. El proceso a seguir: primero buscar el contenedor, luego ir retirando cada uno de los contenedores que estan por encima del buscado, cada uno de los que se van retirando debe ir colocandose en alguno de los grupos que tenga capacidad

public boolean RetirarContenedor( String contenedor )
{
    int g;
    Object aux;

    g=BuscarContenedor(contenedor);
    if(g==-1)
        return false;

    do{
        aux=grupos[g].Pop();
        if(!aux.equals(contenedor))
            {
            int gc;
            gc=BuscarGrupoCapacidad(g);
            grupos[gc].Push(aux);
        }
    }while(!aux.equals(contenedor));
    t--;
    return true;




}

Paso6: Ahora se procede a la codificacion de los metodos de la clase Almacen.BuscarContenedor. Se debe buscar dentro de la estructura de contenedores.

public int BuscarContenedor( String contenedor )
{
    for(int i=0;i<m;i++)
        if(grupos[i].Buscar(contenedor)>=0)
            return i;
    return -1;
}

paso7: Ahora se procede a la codificacion de los metodos de la clase Almacen.CapacidadAlmacen y BuscarGrupoConCapacidad.

public int CapacidadAlmacen()
{
    return (m-1)*n+1;
}
private int BuscarGrupoCapacidad(int ge)
{
    for(int i=0;i<m;i++)
        if(i!=ge&& CantidadContenedores(i)<n)
            return i;
    return -1;
}

paso7: Ahora se procede a la codificacion de los metodos de la clase Almacen.ObtenerContenedor.

public Object ObtenerContenedor(int g,int p)
{
    return grupos[g].Obtener(p);
}

Codificacion del programa principal

Bien, Hasta ahora hemos preparado el programa para su correcto desenvolvimiento. Solo queda implementar el programa principal, que contendra un menu con 3 opciones: Retirar Contenedor, Guardar Contenedor, Obtener Contenedor.

package almacen;
import java.io.*;

public class Main {

    static  BufferedReader br;

   public static int ReadInt() throws IOException
   {
       return Integer.valueOf(br.readLine()).intValue();
   }

   public static float ReadFloat() throws IOException
   {
       return Float.valueOf(br.readLine()).floatValue();
   }
   public static double ReadDouble()throws IOException
   {
       return Double.valueOf(br.readLine()).doubleValue();
   }
   public static long ReadLong() throws IOException
   {
       return Long.valueOf(br.readLine()).longValue();

   }

   public static String ReadString()throws IOException
   {
       return br.readLine();
   }

    
    public static void main(String[] args) throws IOException{



        br=new BufferedReader(new InputStreamReader(System.in));
        AlmacenP a;
        a=new AlmacenP();

        String contenedor;
        int opc;
        String o;
        String aux;
        char Resp;
   
         int grupo;
         int posicion;


        do{
            System.out.println("**********Menu***********/n/n");
           System.out.println("1.- Retirar contenedor:");
           System.out.println("2.- Guardar Contenedor:");
           System.out.println("3.- Obtener Contenedor: ");
           System.out.println("\nIngrese Opcion:  ");
           o=br.readLine();
           opc = Integer.valueOf(o).intValue();


           switch(opc)
           {
               case 1: System.out.println("\t/********Retirar Contenedor*******/:");
                       System.out.println("Ingrese contenedor");
                       contenedor=ReadString();
                       a.RetirarContenedor(contenedor);
                       System.out.println("\n"+ contenedor+" Retirado xD");
                       break;

                case 2: System.out.println("\t/********Guardar Contenedor*******/:");
                        System.out.println("Ingrese Contenedor");
                        contenedor=ReadString();
                        a.GuardarContenedor(contenedor);
                        System.out.println("\n"+contenedor+" Guardado");
                        break;


               case 3: System.out.println("\t/********Obtener Contenedor*******/:");
                       System.out.println("Ingrese grupo");
                       grupo=ReadInt();
                       System.out.println("Ingrese Posicion");
                       posicion=ReadInt();
                       System.out.println("Contenedor");
                       a.ObtenerContenedor(grupo, posicion);

                       break;
           }



        System.out.print("\n\n Desea hacer otra operacion ?? S / N ");
                          aux = br.readLine();
                          Resp = aux.charAt(0);
        }while (Resp == 'S' || Resp == 's');
       
    }


}