UNIDAD I - PRACTICA 4 - PROGRAMACIÓN ORIENTADA A OBJETOS UPVM

UNIVERSIDAD POLITÉCNICA DEL VALLE DE MÉXICO INGENIERÍA EN INFORMÁTICA

PRACTICA 3: ESTRUCTURAS DE DATOS EN JAVA

ELABORO: REVISO:

M. en D. Bibiana Pérez Castillo Pérez

Página | 1

CLAVE DE LA ASIGNATURA

CUATRIMESTRE NOMBRE DE LA ASIGNATURA

POO-ES 5 PROGRAMACIÓN ORIENTADA

A OBJETOS

NÚMERO DE PRÁCTICA

NOMBRE DURACIÓN (HORAS)

4 PILAS Y COLAS 4

INTRODUCCIÓN:

En programación, una estructura de datos es una forma de organizar un conjunto de

datos elementales (un dato elemental es la mínima información que se tiene en el

sistema) con el objetivo de facilitar la manipulación de estos datos como un todo y/o

individualmente.

Una estructura de datos define la organización e interrelacionamiento de estos, y un

conjunto de operaciones que se pueden realizar sobre él. Las operaciones básicas son:

Alta, adicionar un nuevo valor a la estructura.

Baja, borrar un valor de la estructura.

Búsqueda, encontrar un determinado valor en la estructura para se realizar una

operación con este valor, en forma SECUENCIAL o BINARIO (siempre y cuando

los datos estén ordenados).

Otras operaciones que se pueden realizar son:

Ordenamiento, de los elementos pertenecientes a la estructura.

Apareo, dadas dos estructuras originar una nueva ordenada y que contenga a las

apareadas.

Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y eficiencia

para la realización de cada operación. De esta forma, la elección de la estructura de datos

apropiada para cada problema depende de factores como las frecuencias y el orden en

que se realiza cada operación sobre los datos.



ELABORO: REVISO:


Página | 2

Algunas estructuras de datos utilizadas en programación son:

Arrays (Arreglos)

o Vectores

o Matrices

Listas Enlazadas

o Listas simples

o Listas dobles

o Listas Circulares

Pilas

Colas

Árboles

o Árboles binarios

o Árboles Multicamino

Conjuntos

Grafos

Montículos

OBJETIVO:

Implementar estructuras de datos tipo pila y cola en el diseño de aplicaciones que

resuelvan problemas específicos de almacenamiento y planificación de datos.

TEORÍA:

PILAS



ELABORO: REVISO:


Página | 3

Aunque los objetos son todos diferentes, todos ilustran el concepto de pila (stack). Una

pila, es una particularización de las listas y se puede definir como una estructura en la

cual los elementos son agregados y eliminados en el tope de la lista. Es una estructura

LIFO (Last In First Out – el primero que llega es el último que sale).

Por ejemplo, si nuestra camisa favorita azul se encuentra debajo de la vieja camisa roja

que se encuentra en el tope de las camisas, primero debemos sacar a la camisa roja.

Solamente así podremos sacar a la camisa azul, la cual ahora esta en el tope de la pila de

camisas. Una ves sacada la camisa azul, podemos regresar a la vieja camisa roja al tope

de la pila.

Las pilas cuentan solo con 2 operaciones, conocidas como PUSH, insertar un elemento

en el tope de la pila, y POP, leer el elemento del tope de la pila. Veamos como funcionan

estos métodos:

PUSH



ELABORO: REVISO:


Página | 4

POP

Implementación de pilas Para trabajar con pilas, utilizaremos la misma base con la que trabajamos para las listas. Dispondremos de 2 clases: Pila y NodoDePila. Con la primera crearemos a la pila y las operaciones sobre ella y con la segunda instanciaremos a cada uno de los nodos de la pila.



ELABORO: REVISO:


Página | 5

COLAS Una cola es una estructura de datos similar a una lista con restricciones especiales. Los elementos son agregados en la parte posterior de la cola y son eliminados por el frente. Esta estructura es llamada FIFO (First In, First Out – el primero que llega, es el primero en salir). Considere la siguiente figura:

Si una persona ha elegido sus libros dentro de la librería y desea pasar a pagarlos, debe hacer “cola” para poder efectuar el pago. La cajera atenderá a cada persona en el orden en que llegaron.



ELABORO: REVISO:


Página | 6

A nivel de lógico, podemos representar a una cola de la siguiente manera:

Construcción de colas Implementar colas involucra el uso clases similares a una lista. Las operaciones sobre esta estructura son idénticas: insertar y eliminar, con las consideraciones pertinentes.

Insertar Insertar un dato en una cola es muy similar a hacerlo en una pila o una lista, la diferencia es que tendremos que hacerlo por el final de la cola. A este proceso se le llama encolar.



ELABORO: REVISO:


Página | 7

Eliminar Para extraer un dato de la cola, es necesario modificar el valor del nodo primero, de manera que deje de apuntar al primer elemento de la cola. De la misma manera que con las pilas, se extrae el valor antes de que se pierda. Se hace que el nodo primero ahora apunte al nuevo elemento (anterior de la cola).



ELABORO: REVISO:


Página | 8

DESARROLLO: // IMPLEMENTACIÓN DE UNA PILA SIMPLE UTILIZANDO LA CLASE // VECTOR

import java.util.Vector; public class Pila <Tipo> { private int size; private Vector<Tipo> elementos; public Pila() { super(); elementos = new Vector<Tipo>(); size = 0; } public boolean pilaVacia () { if (size==0) { return true; } return false; } public void apilar ( Tipo o ) { elementos.add(size, o); size++; } public Tipo desapilar () { try { if(pilaVacia()) throw new ErrorPilaVacia(); else { return elementos.get(--size); } } catch(ErrorPilaVacia error) { System.out.println("ERROR: la pila esta vacía"); return null; } } public int getSize() { return size; } }



ELABORO: REVISO:


Página | 9

@SuppressWarnings("serial") class ErrorPilaVacia extends Exception { public ErrorPilaVacia() { super(); } }

// CLASE DE IMPLEMENTACIÓN DE LA PILA public class Test { @SuppressWarnings("unchecked") public static void main(String[] args) { Pila pila; pila = new Pila<String>(); System.out.println("Elementos en pila: " + pila.getSize()); pila.apilar("Uno"); System.out.println("Elementos en pila: " + pila.getSize()); pila.apilar("Dos"); System.out.println("Elementos en pila: " + pila.getSize()); System.out.println("Extraigo.........: " + pila.desapilar().toString()); System.out.println("Elementos en pila: " + pila.getSize()); System.out.println("Extraigo.........: " + pila.desapilar().toString()); System.out.println("Elementos en pila: " + pila.getSize()); pila = new Pila<Integer>(); System.out.println("Elementos en pila: " + pila.getSize()); pila.apilar(1); System.out.println("Elementos en pila: " + pila.getSize()); pila.apilar(2); System.out.println("Elementos en pila: " + pila.getSize()); System.out.println("Extraigo.........: " + pila.desapilar().toString()); System.out.println("Elementos en pila: " + pila.getSize()); System.out.println("Extraigo.........: " + pila.desapilar().toString()); System.out.println("Elementos en pila: " + pila.getSize()); } }



ELABORO: REVISO:


Página | 10

// IMPLEMENTACIÓN DE UNA COLA UTILIZANDO UN ARREGLO ESTÁTICO class Cola{ static int c[],tf,ti,max; Cola() { c=new int[6]; max=6; } Cola(int max) { c=new int [max]; this.max=max; tf=ti=-1; } public static void insertar(int d) { if(tf==max-1) System.out.print("Cola llena"); else if(ti==-1) ti=tf=0; else {tf++; //el else termina aqui. c[tf]=d;} } public static void eliminar() { if(ti==-1) System.out.println("No se puede eliminar"); else if(tf==ti) { ti=tf=-1; System.out.println("cola vacia");} else ti++; } public static void mostrar(){ for (int i=ti+1; i<=tf; i++) System.out.println(c[i]); } public static boolean estaVacia(){ if(tf==-1) return true; return false; } } public class ColaEspera{ public static void main (String arg[])



ELABORO: REVISO:


Página | 11

{ Cola cola = new Cola(); cola.insertar(8); cola.insertar(6); cola.insertar(7); cola.insertar(8); cola.mostrar(); cola.eliminar(); System.out.println(); cola.mostrar(); cola.eliminar(); System.out.println(); cola.mostrar(); cola.eliminar(); System.out.println(); cola.mostrar(); cola.eliminar(); System.out.println(); cola.mostrar(); cola.eliminar(); System.out.println(); cola.mostrar(); } }

Como anteriormente se ha mencionado las estructuras de datos pueden mezclarse entre sí para optimizar su funcionamiento, los programas que a continuación se ilustran utilizan una lista simple enlazada, su planificación de operación sobre los nodos creados se realiza a través de una Pila o una Cola implementadas en una interfaz /** * Interfaz que representa una pila abstracta */ import java.util.*; public interface Pila<E> { void apila(E e); E desapila() throws NoSuchElementException; void hazNula(); E cima() throws NoSuchElementException; boolean estaVacia(); int tamano(); }



ELABORO: REVISO:


Página | 12

/** * Clase que contiene una operación genérica * y otra no genérica para reemplazar todos * los elementos de una lista por otro */

import java.util.*; public class OpListas { public static void reemplaza (List<String> list, String valor, String nuevoValor) { ListIterator<String> it = list.listIterator(); while (it.hasNext()) { String elem=it.next(); if (valor == null ? elem==null : valor.equals(elem)) { it.set(nuevoValor); } } } public static <E> void reemplazaGenerico (List<E> list, E valor, E nuevoValor) { ListIterator<E> it = list.listIterator(); while (it.hasNext()) { E elem=it.next(); if (valor == null ? elem==null : valor.equals(elem)) { it.set(nuevoValor); } } } public static <E> void muestra(List<E> lista) { System.out.println("--------"); for (E e : lista) { System.out.println(e); } System.out.println(); } public static <E> void invierte(List<E> lista) { PilaEnlazada<E> pila=new PilaEnlazada<E>(); // pasar los elementos de la lista a la pila for (E e:lista) { pila.apila(e); } lista.clear();



ELABORO: REVISO:


Página | 13

// pasar los elementos de la pila a la lista while (!pila.estaVacia()) { lista.add(pila.desapila()); } }

} /** *Clase que implementa una pila mediante una LinkedList */

import java.util.*; public class PilaEnlazada<E> implements Pila<E> { // la pila private LinkedList<E> p; /** * Constructor de la pila; la crea vacía */ public PilaEnlazada() { p=new LinkedList<E>(); } /** * Añade un elemento a la pila */ public void apila(E e) { p.addFirst(e); } /** * Elimina y retorna un elemento de la pila */ public E desapila() throws NoSuchElementException { return p.removeFirst(); } /** * Deja la pila vacÃa */ public void hazNula() { p.clear(); } public E cima() throws NoSuchElementException { return p.getFirst();



ELABORO: REVISO:


Página | 14

} public boolean estaVacia() { return p.isEmpty(); } public int tamano() { return p.size(); }

} /** * Programa de prueba de las operaciones de las listas */

import java.util.*; public class PruebaOpListas { public static void main (String[] args) { ArrayList<String> lista=new ArrayList<String>(20); lista.add("juan"); lista.add("jose"); lista.add("elisa"); lista.add("jose"); lista.add("laura"); lista.add("javi"); lista.add(null); lista.add("elena"); lista.add("pedro"); OpListas.<String>muestra(lista); OpListas.reemplaza(lista,"jose","pepe"); OpListas.muestra(lista); OpListas.reemplaza(lista,null,"nulo"); OpListas.muestra(lista); OpListas.reemplazaGenerico(lista,"pepe","pepito"); OpListas.muestra(lista); OpListas.<String>reemplazaGenerico(lista,"pepe","pepito"); OpListas.muestra(lista); OpListas.invierte(lista); OpListas.muestra(lista); }

}



ELABORO: REVISO:


Página | 15

APLICACIÓN DE LISTA ENCOLADA, EJEMPLIFICA LAS OPERACIONES QUE SE LLEVAN A CABO EN UNA SERIE DE VENTANILLAS BANCARIAS.

/** * Clase que contiene los datos de un cliente de un servicio */ public class Cliente { // atributos private String nombre; private int movil; /** * Constructor for objects of class Cliente */ public Cliente(String nombre, int movil) { this.nombre=nombre; this.movil=movil; } /** * Redefinimos la conversión a string */ @Override public String toString() { return (nombre+" tel. movil: "+movil); }

}

/** * Clase que permite obtener la fecha y hora actual, * en milisegundos desde la época */

import java.util.Calendar; public class Reloj { public static long ahora() { return Calendar.getInstance().getTimeInMillis(); }

}



ELABORO: REVISO:


Página | 16

/** * Abstract class Servicio * Representa un servicio con varias ventanillas * de atención a clientes */

public abstract class Servicio { // atributos protected int num; // número de ventanillas protected int tmin, tmax; // milisegundos /** * Llegada de un cliente */ public abstract void nuevoCliente(Cliente c); /** * Atender a los clientes que se puedag */ public abstract void atiendeClientes(); /** * Muestra estado */ public abstract void muestraEstado();

} /** * Clase que representa una cola de espera de un servicio */

import java.util.*; public class ColaEspera { /** * Clase interna para almacenar todos los datos * de un cliente */ private static class DatosCliente { Cliente c; long entrada, salida; // milisegundos /** * Constructor de DatosCliente; pone la hora de entrada */ DatosCliente (Cliente c) { this.c=c; entrada=Reloj.ahora(); }



ELABORO: REVISO:


Página | 17

void atiende() { salida=Reloj.ahora(); } } // colas del servicio private Queue<DatosCliente> colaEspera; private Queue<DatosCliente> colaAtendidos; /** * Constructor de ColaEspera */ public ColaEspera() { colaEspera=new LinkedList<DatosCliente>(); colaAtendidos=new LinkedList<DatosCliente>(); } /** * Nuevo cliente; se mete en la cola de espera */ public void nuevoCliente(Cliente c) { DatosCliente datos=new DatosCliente(c); colaEspera.add(datos); } /** * Atender cliente: se saca de la cola de espera * y se mete en la de atendidos; retorna el cliente * atendido */ public Cliente atenderCliente() throws NoSuchElementException { DatosCliente datos=colaEspera.remove(); datos.atiende(); colaAtendidos.add(datos); return datos.c; } /** * Tiempo de espera medio para clientes en espera (en segundos) */ public double tiempoEsperaNoAtendidos() { long tiempo=0; int num=0; long ahora=Reloj.ahora(); for (DatosCliente datos: colaEspera) { tiempo=tiempo + ahora-datos.entrada;



ELABORO: REVISO:


Página | 18

num++; } if (num==0) { return 0.0; } else { return (((double) tiempo)/num)/1000.0; } } /** * Tiempo de espera medio para clientes atendidos (en segundos) */ public double tiempoEsperaAtendidos() { long tiempo=0; int num=0; for (DatosCliente datos: colaAtendidos) { tiempo=tiempo+datos.salida-datos.entrada; num++; } if (num==0) { return 0.0; } else { return (((double) tiempo)/num)/1000.0; } } /** * Tiempo de espera máximo para clientes atendidos (en segundos) */ public double tiempoMaxEsperaAtendidos() { long tiempoMax=0; long tiempo; for (DatosCliente datos: colaAtendidos) { tiempo=datos.salida-datos.entrada; if (tiempo>tiempoMax) { tiempoMax=tiempo; } } return ((double)tiempoMax)/1000.0; } /** * Mostrar el estado de la cola de espera */ public void muestraEstado() { System.out.println(); System.out.println("-------Estado de la cola de espera----"); System.out.println("No atendidos "+colaEspera.size()); if (colaEspera.size()>0) { System.out.println("Tiempo medio espera no atendidos(seg): "+ tiempoEsperaNoAtendidos());



ELABORO: REVISO:


Página | 19

} System.out.println("Atendidos "+colaAtendidos.size()); if (colaAtendidos.size()>0) { System.out.println("Tiempo medio espera atendidos (seg): "+ tiempoEsperaAtendidos()); System.out.println("Tiempo maximo espera atendidos (seg): "+ tiempoMaxEsperaAtendidos()); } System.out.println(); } /** * Num clientes en espera */ public int numClientesEnEspera() { return colaEspera.size(); }

} /** * Descripcion de la clase de ServicioColaUnica */

import java.util.*; public class ServicioColaUnica extends Servicio { // atributos private ColaEspera fila; private long[] horaDisponible; //milisegundos /** * Constructor al que se le pasa el número de ventanillas * el tiempo máximo de atención, y el tiempo máximo de atención */ public ServicioColaUnica(int numVentanillas, int tmin, int tmax) { this.num=numVentanillas; this.tmin=tmin; this.tmax=tmax; fila =new ColaEspera(); horaDisponible=new long[num]; long ahora=Reloj.ahora(); for (int i=0; i<numVentanillas; i++) { horaDisponible[i]=ahora; } } /** * Llegada de un cliente */ public void nuevoCliente(Cliente c) {



ELABORO: REVISO:


Página | 20

// meter el cliente en esa cola fila.nuevoCliente(c); } /** * Cliente atendido */ public void atiendeClientes() { long ahora=Reloj.ahora(); for (int i=0; i<num; i++) { if (horaDisponible[i]<=ahora) { try { Cliente c=fila.atenderCliente(); System.out.println("Atendido: "+c); // Calculamos el tiempo de atenciÃ³n double tiempoAtencion=Math.random()*(tmax-tmin)+tmin; horaDisponible[i]=ahora+(long) tiempoAtencion; } catch (NoSuchElementException e) { // no hacemos nada si no hay nadie esperando } } } } /** * Muestra estado */ public void muestraEstado() { System.out.println(); System.out.println("----------Estado Servicio---------"); System.out.println("Fila NumClientes T. Espera T. Atendidos Max Tiempo"); System.out.printf(" %3d %3d %7.2f %7.2f %7.2f%n", 1,fila.numClientesEnEspera(),fila.tiempoEsperaNoAtendidos(), fila.tiempoEsperaAtendidos(), fila.tiempoMaxEsperaAtendidos()); System.out.println(); }

}



ELABORO: REVISO:


Página | 21

/** * Programa de simulación de un servicio de atención * a clientes */

import java.util.*; public class Simulador { /** * Espera el tiempo indicado */ public static void espera(int milisegundos) { try { Thread.sleep(milisegundos); } catch (InterruptedException e) { } } /** * programa de prueba */ public static void main(String[] args) { final int numVentanillas=5; //Servicio serv=new ServicioColaUnica(numVentanillas,200,8000); Servicio serv=new ServicioColaUnica(numVentanillas,100,8000); int tiempoMax= 60000; // milisegundos int periodo=100; // milisegundos int contadorClientes=0; int tiempoMaxLlegada=1700; // milisegundos long horaProximaLlegada=Reloj.ahora(); // milisegundos for (int tiempo=0; tiempo<=tiempoMax; tiempo+=periodo) { long ahora=Reloj.ahora(); // Simulamos la llegada de clientes if (horaProximaLlegada<=ahora) { contadorClientes++; // creamos un cliente simulado y lo metemos en el servicio Cliente c=new Cliente("C"+contadorClientes, contadorClientes+600000000); serv.nuevoCliente(c); // Calculamos la hora de la proxima llegada horaProximaLlegada=horaProximaLlegada+ (long) (Math.random()*tiempoMaxLlegada); } // Simulamos la atención a los clientes serv.atiendeClientes();



ELABORO: REVISO:


Página | 22

// esperar espera(periodo); // cada cierto tiempo mostrar el estado if (tiempo % (periodo*50) ==0) { serv.muestraEstado(); } } }

}

ACTIVIDADES COMPLEMENTARIAS

Genere un programa en Java que resuelva la siguiente situación: Un grupo de soldados está rodeado por el enemigo y no hay posibilidad de victoria sin refuerzos, pero hay sólo un caballo para escapar y pedir dichos refuerzos. Los soldados llegan a un acuerdo para determinar quién va a escapar y pedir ayuda. Forman un círculo y sacan un número N de un sombrero y uno de sus nombres de otro. Empezando por el soldado cuyo nombre se ha sacado cuentan, en el sentido de las agujas del reloj, N soldados y sacan fuera del círculo al soldado encontrado en el lugar n-ésimo. La cuenta empieza de nuevo con el siguiente soldado (el que sigue al eliminado según el sentido de las agujas del reloj). El proceso continúa de forma que cada vez que la cuenta llega a N se saca a un soldado del círculo. Una vez que un soldado se saca del círculo ya no se vuelve a contar. El soldado que queda al final es el que toma al caballo y escapa.



ELABORO: REVISO:


Página | 23

CONCLUSIONES

BIBLIOGRAFÍA:

1. JAVA2 LENGUAJE Y APLICACIONES, FCO. JAVIER CEBALLOS, 2007, ALFAOMEGA,

MÉXICO, ISBN-978-970-15-1249-4.

2. JAVA2: INTERFACES GRÁFICAS Y APLICACIONES, FCO. JAVIER CEBALLOS, 2006,

ALFAOMEGA, MÉXICO, ISBN-9701511808.

3. INT. A LA PROG. CON JAVA: UN ENFOQUE OO, ARNOW – WEISS, 2008, ADDISON –

WESLEY, ESPAÑA, 8478290338.

Documents

UNIDAD I - PRACTICA 4 - PROGRAMACIÓN ORIENTADA A OBJETOS UPVM