Programando en linux: Pilas y colas en JAVA


Como muchos sabrán, Java es multi-plataforma lo que significa que puede ser ejecutado en distintos computadores, con prestaciones distintas y sistemas operativos variados sin que ello afecte el funcionamiento especifico del programa que hayamos escrito. En pocas palabras lo anterior quiere decir que el programa que hemos escrito en windows correrá perfectamente en linux, sin que tengamos que cambiar absolutamente nada esto nos facilita la vida y por supuesto es un seguro para aquellas personas que aun le tienen miedo a la programación en linux.

Bien hecha esta aclaración, vamos a ver como manipular una pila desde una cola, este ejercicio se me presento en mi curso de algoritmos y creo que será interesante compartirlo con la comunidad, así que empezamos.

¿Qué es una Pila?:
En palabras sencillas, una pila es una estructura dinámica que tiene la particularidad la siguiente particularidad, el último elemento que entra en ella es el primero en salir, por ejemplo supongamos que tenemos una torre de 5 libros, en ella el último libro que colocamos (el de la cima) debe ser el primero que debemos quitar para acceder al cuarto y así sucesivamente hasta llegar al primer libro; de modo que en una pila siempre vamos quitando el elemento que fue insertado al final, cabe destacar que los elementos que salen dejan de formar parte de la estructura.

¿Qué es una cola?:
Una cola es otra estructura dinámica, en la cual el primer elemento en ser insertado es el primer elemento en ser sacado de la estructura, una cola es cotidianamente lo que hacemos cuando vamos a una oficina a realizar un trámite y nos acomodamos en orden de llegada, de modo que el primer sujeto en ser atendido es el primero en haber llegado y el último en realizar el trámite es último en formar parte de la cola.

Descripción del problema:

En un supermercado hay 10 cajas registradoras, en cada una de las cuales se colocan los clientes con sus carros de la compra en orden de llegada. Por cada caja registradora queremos guardar el nombre de la cajera, la recaudación acumulada y los carros en espera.

Por otro lado. En cada carro se amontonan los distintos productos, de modo que tan solo puede añadirse o extraerse el situado en la parte superior. Por cada producto guardamos su nombre y precio.

Analizando el problema:
Parte de darle solución al enunciado consiste primero en desmenuzar los componentes que lo conforman, así por ejemplo vemos que los productos se extraen de arriba hacia abajo, es decir, la extracción de productos sugiere que cada producto en la cima del carro de compras es procesado por la cajera y entonces nos viene a la mente la idea de una pila de productos.

A su vez, los carritos de compras son atendidos en orden de llegada, esto quiere decir que el primer cliente en llegar a la caja, es el primer cliente en ser atendido y en salir del almacén, todo esto nos trae a la mente la noción de cola, por lo tanto debemos pensar en la creación de una cola de carros de compra.

Luego tenemos las 10 cajas registradoras que evidentemente pueden formarse con un arreglo, puesto que de antemano conocemos su cantidad.

Y por último debemos establecer la relación existente entre todas estas estructuras, primero las cajas atienden carros, por tanto deberemos ligar la cola de carros a una caja especifica dentro de las 10, luego cada carro posee una pila de productos de modo que tendremos que considerar crear una pila de productos para cada carrito de compras, pero a todo esto nos surge una interrogante en nuestra mente.

¿Cómo meto una cola dentro de un arreglo y una pila dentro de una cola?
la respuesta es sencilla, resulta  imposible realizar estas operaciones, sin embargo lo que si podemos es crear cada estructura por separado y crear enlaces adecuados que nos permitan manipular referencias especificas a cada una de estas estructuras, de modo que al final tendremos una sola caja con su respectiva referencia a una sola cola de carros, dentro del cual, cada uno de ellos referencia a una sola pila de productos.

Creando la clase Carro con atributos productos:

Bien esta clase Carro implementa dos procedimientos interesantes, el primero llenaProductos, se encarga de pedir el nombre y el precio de un producto al operario y además recibe un objeto de tipo pila que es enviado desde otra clase, luego está parte es importante, ese objeto de tipo pila será el encargado de introducir nuestro producto una vez ingresados los datos dentro de la pila y para ello hace uso de pp.insertaP(nombreProducto,precioProducto);

Clase CajaRegistradora:

Y aquí viene la magia de este ejercicio, esta clase es la encargada de “llenar” cada carro con sus respectivos productos, veamos:

CapturaCR se encarga de insertar los carros en la cola y consecuentemente los productos, mediante una referencia, es decir, llenaproductos crea un objeto de la clase carro c para manipular la inserción de productos, luego le manda un objeto Pila para que coloque en la pila la información insertada, una vez terminado este proceso, manda a llamar al metodo insertarC de la clase cola mediante el objeto cc y le manda el parámetro recien llenado c así: cc.insertarC(c);

De este modo nos aseguramos que dentro del elemento cola, se tenga una referencia hacia el elemento superior de la pila, para de este modo poder manipular la pila de productos como si estuviesen dentro de la cola.

Declaración de la pila:

Ahora sí, vamos a crear la pila con eclipse o netbeans, y sí, los de linux son exactamente iguales al netbeans y el eclipse de windows respectivamente, así que no se preocupen.

public class NodoP {
		String nom;
		double pre;
		NodoP siguiente;

		public NodoP(String nom, double pre)
			{
				this.nom=nom;
				this.pre =pre;
				this.siguiente=null;
			}
}

Los parámetros del constructor se igualan, para posteriormente pasar la información a los atributos de la clase, una vez tengamos llenos los campos.
Con esto podemos proceder a implementar los métodos  básicos de la pila, tales como insertarElemento,sacarElemento; procedemos del mismo modo.

Implementación de la pila (insertando):

Notamos que los parámetros recibidos se igualan a las variables locales nuevo, a la cual le estamos creando un espacio en memoria, estos datos que son pasados, representan el nombre y el precio del producto los cuales son llenados en otra clase.

Bien este método es bastante simple, si cabeza(referencia al primer elemento de la pila) es igual a null, significa que no existen elementos dentro de la pila, por lo cual esta instrucción solo se ejecuta una vez e inserta o mejor dicho establece, que el único elemento pasa a formar parte de la pila.

caso contrario quiere decir que cabeza ya tiene una referencia, por lo tanto pasamos a insertar el segundo elemento de la pila, para esto no existe mayor misterio, solo debemos tener cuidado se insertar adecuadamente al final.

Implementación de la pila (sacando elemento):

Como podemos apreciar este método se encarga de sacar un elemento de la pila, mostrarlo por pantalla, sumar el precio de los productos para obtener un acumulado y posteriormente desliga el elemento de la pila, de modo que no sea accesible en adelante.

Es importante recalcar que cada producto se va sacando de uno en uno, sin embargo en este método se realiza automáticamente, para evitar que el usuario procese manualmente cada producto.

Una vez tengamos la pila debidamente implementada. pasaremos a crear la cola, lo primero que debemos hacer es igual declarar una clase nodo cola.

Declaración de la cola:


Vemos que el constructor recibe como parámetro una variable de tipo Carro, la cual es la clase que contiene atributos de nombre y precio del producto, que serán insertados posteriormente dentro de una pila.

Implementación de la cola (completa):

Lo primero es tener en cuanta que utilizaremos dos punteros uno llamado primero y otro llamado último, la función de cada uno de ellos es garantizar el funcionamiento de la cola como tal, puesto que el primer elemento en ser insertado será el primero en ser procesado, de modo que la primer vez que insertemos un carro el puntero primero será asignado como primer elemento y se quedará ahí hasta que se terminen de insertar elementos, mientras que el puntero último cumple la función de ir actualizándose con cada nueva inserción.

cuando usemos el método sacaC, haremos exactamente lo que dice la teoría, despachar el primer carro que llegó a la caja registradora, para esto obviamente necesitamos sacar cada producto que este dentro del carro y es por ello que procesamos los productos con aux.car.pp.sacaP(); luego vamos sumando el total recaudado por la caja al terminar de atender a todos los carros, y finalmente desligamos cada carro de la cola.

Esto es en términos generales el ejercicio. El código completo puede ser descargado del siguiente enlace, ya está listo para correrlo desde netbeans o eclipse.

https://dl.dropboxusercontent.com/u/68911480/Pilas%20y%20colas.zip

Cualquier duda pueden comentar 🙂

Anuncios

3 thoughts on “Programando en linux: Pilas y colas en JAVA

Tu comentario es importante para mi.

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s