Listas

Lista (estructura de datos)

En Ciencias de la Computacin, una lista enlazada es una de lasestructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias (punteros) al nodo anterior y/o posterior. El principal beneficio de las listas enlazadas respecto a los array convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento. Una lista enlazada es un tipo de dato auto-referenciado porque contienen un puntero o link a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminacin de nodos en cualquier punto de la lista en tiempo constante (suponiendo que dicho punto est previamente identificado o localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listas enlazadas: Lista Enlazadas Simples, Listas Doblemente Enlazadas, Listas Enlazadas Circulares y Listas Enlazadas Doblemente Circulares. Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes tales como Lisp y Scheme tiene estructuras de datos ya construidas, junto con operaciones para acceder a las listas enlazadas. Lenguajes imperativos u orientados a objetos tales como C o C++ y Java, respectivamente, disponen de referencias para crear listas enlazadas. Operaciones con listas simples en java

package listas; //operaciones para listas simples public class ListaImplements { class Nodo{ //variables public String dato; public Nodo enlace; Nodo (String n){ dato=n;//inicializacion enlace=null; } } Nodo inicio; public void Lista(){ inicio=null; } public boolean vacia(){//cuando esta vacia return(inicio==null); } public int Tamao(){//saber el tamao int n=0; Nodo temporal=inicio; while(temporal!=null){ n++; temporal=temporal.enlace; } return n; } public boolean Buscar(String elemento){//para buscar un elemento en la lista Nodo temporal=inicio; while(temporal!=null){ if(elemento.equals(temporal.dato))

return true; else temporal=temporal.enlace; } return false; } public void Insertar(String elemento){//insert un elemento en la lista Nodo n=new Nodo(elemento); } public String Eliminar(){//eliminar un elemento en la lista String temporal=inicio.dato; inicio=inicio.enlace; return temporal; } public static void main (String args[]) { ListaImplements x= new ListaImplements(); } } EJEMPLO DE LISTAS ENLAZADAS

package listasenlazadas; class Nodo { //variables a itilizar int dato; Nodo enlace; public Nodo(int a){ //inicializar variables dato=a; enlace=null; }

} class Lista{ private Nodo inicio; public Lista(){ inicio=null; } public Lista Insertarcabeza(int a){//insertar arriba Nodo nuevo=new Nodo(a); nuevo.enlace=inicio; inicio=nuevo; return this; } public void Visualizar(){//ver que hay en cada uno de los nodos Nodo actual; actual=inicio; while(actual!=null){ System.out.print(actual.dato+""); actual=actual.enlace; } } public Nodo Buscar(int dat){//buscar un dato Nodo i; try{ for(i=inicio;i!=null;i=i.enlace){ if(dat==i.dato) return i; } catch(Exception e)() return null; } } }

package listasenlazadas; public class Principal { public static void main(String [] args){ Lista x=new Lista(); //datos de ejemplo for(int i=0; i< n="i.Buscar(3);"> EJERCICIO

package listaligada; import java.util.*; public class ListaLigada { public static void main (String args[]) { Scanner leer = new Scanner(System.in); ListaLigada x=new ListaLigada(); //variables a usar int num; int op; LinkedList lista = new LinkedList(); //menu do{ System.out.println( "\t Men \t" ); System.out.println( "Operaciones con listas" ); System.out.println( "1.- Insertar al principio" ); System.out.println( "2.- Insertar al final" ); System.out.println( "3.- Borrar al principio" ); System.out.println( "4.- Borrar al final" ); System.out.println( "5.- Mostrar la lista" ); System.out.println( "6.- Borrar toda la lista" ); System.out.println( "7.- Salir" ); System.out.println( "\n" ); System.out.println( "Elija la operacin que desee" ); op = leer.nextInt(); //coger la opcion switch(op){

case 1: System.out.println( "Inserte numero" ); //coger el numero y aadirlo a la lista de primeras num = leer.nextInt(); lista.addFirst(num); break; case 2: System.out.println( "Inserte numero" ); //anadir el numero a la lista num = leer.nextInt(); lista.addLast(num); break; case 3: System.out.println( "Se borrara el primer nodo" ); //remover de la lista lista.removeFirst(); break; case 4: System.out.println( "Se borrara el nodo final" ); //remover nodo de el final de la lista lista.removeLast(); break; case 5: System.out.println( "La lista es la siguiente" ); //tamao de la lista List lista2 = new ArrayList(lista); Iterator it = lista2.iterator(); while (it.hasNext()){ System.out.println(it.next()+""); } break; case 6: System.out.println( "Se borraran todos los elementos de la lista" );

lista.clear(); break; case 7: System.out.println( "Al rato" ); break; } } while( op != 7 ); } } EJERCICIO 2

package ejemplolista; import java.util.*; public class ListaAlumnos{ //variables qeu necesitamos private String nom; int calif1; int calif2; int calif3; static double prom; public static void main( String args[] ){ Scanner leer = new Scanner(System.in); ListaAlumnos nodo = new ListaAlumnos(); int op; ArrayList lista = new ArrayList(); //secuencia de lista do{ System.out.println( "Ingrese el nombre del alumno:" ); nodo.nom = leer.next(); System.out.println( "Ingrese la primera calificacin:" ); nodo.calif1 = leer.nextInt(); System.out.println( "Ingrese la segunda calificacin:" );

nodo.calif2 = leer.nextInt(); System.out.println( "Ingrese la tercera calificacin:" ); nodo.calif3 = leer.nextInt(); //lo qeu queda guardado lista.add("Nombre del alumno:\n"+nodo.nom); lista.add("Calificacin 1:\n"+nodo.calif1); lista.add("Calificacin 2:\n"+nodo.calif2); lista.add("Calificacin 3\n"+nodo.calif3); promedio(nodo.calif1, nodo.calif2, nodo.calif3); lista.add("Su promedio es:\n"+prom); System.out.println( "Desea ingresar otro alumno?" ); System.out.println( "1.-Si\t 2.-No" ); op = leer.nextInt(); } while(op != 2); List lista2 = new ArrayList(lista); Iterator it = lista2.iterator(); while (it.hasNext()){ System.out.println(it.next()+""); } } private static double promedio(int calif1, int calif2, int calif3){ //como resolver el promedio int suma = calif1 + calif2 + calif3; prom = suma/3; return prom; } } EJERCICIO 3

package ejerciciodelistas;//Paquete import java.awt.BorderLayout;//importacion de librerias import java.awt.Frame;

import java.awt.Label; import java.awt.List; import java.awt.event.ItemEvent; import java.awt.event.ItemListener; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; public class Listas extends Frame{ List lista = new List(0,true); Label text= new Label ("Maravillas que se pueden visitar en la localidad elegida"); public Listas(){ super("elegir intinerario"); lista.add("Bienvenido"); lista.add("foiano de val fortore"); lista.add("baselice"); lista.add("San bartolomeo en Galdo"); lista.add("San marco de los Cavoti"); lista.add("Montefalcone en val fortore"); lista.add("Pesco Sannita"); lista.add("Colle Sannita"); lista.add("Castelvetere en val fortore"); lista.add("castelfranco en miscano"); lista.add("ginestra de los schiavoni"); lista.add("San giorgio la molara"); lista.add("molinara"); lista.add("Pietrelcina"); lista.add("Fragneto Monforte"); lista.add("Circello"); lista.add("Campolattaro"); add(lista,BorderLayout.CENTER); add(text,BorderLayout.SOUTH); addWindowListener(new listeWindowListener()); //lista.addItemListener(new escuchaLista());

setSize(350,100); setResizable(false); show(); } class listeWindowListener implements WindowListener{ public void windowActivated(WindowEvent e){//la ventana se ve en primer plano } public void windowClosed(WindowEvent e){//salir de el explor5ador } public void windowClosing(WindowEvent e){//seleccionaren la lista aql cerrar String[]s=lista.getSelectedItems(); int i=0; System.out.println("itinerario seleccionado"); try{ while(true){ System.out.println(s[i++]); } } catch (ArrayIndexOutOfBoundsException er){ System.out.println("que lo pases bien "); } System.exit(0); } public void windowDeactivated(WindowEvent e){//eventos de windows } public void windowDeiconified(WindowEvent e){ } public void windowIconified(WindowEvent e){ } public void windowOpened(WindowEvent e){ } class escuchaLista implements ItemListener{ public void itemStateChanged(ItemEvent e){

int ndice=((Integer) e.getItem()).intValue(); if (ndice==0) text.setText("Rocca de los Rettori, arco de Trajano, anfiteatro Romano, ciudad espectculo"); if (ndice==1) text.setText("localidad San Giovanni, Campanario, via Roma, lago, fiesta S.Giovanni, fiesta del emigrante"); if (ndice==2) text.setText("asis ds San Leonardo"); if (ndice==3) text.setText("casco histrico"); if (ndice==4) text.setText("casco histrico"); if (ndice==5) text.setText("casco histrico"); if (ndice==6) text.setText("casco histrico"); if (ndice==7) text.setText("casco histrico"); if (ndice==8) text.setText("casco histrico"); if (ndice==9) text.setText("Bosque"); if (ndice==10) text.setText("casco histrico"); if (ndice==11) text.setText("Lago de San Giorgio"); if (ndice==12) text.setText("casco histrico"); if (ndice==13) text.setText("Piana Romana, casco histrico, casas de Padre o"); if (ndice==14) text.setText("Encuentro internacional de globos, Palacio Ducal"); if (ndice==15) text.setText("casco histrico"); if (ndice==16) text.setText("Dique de Campolattaro"); } } } public static void main(String [] args){ Listas x= new Listas(); } } OPERACIONES RECURSIVAS

package listas2; import javax.swing.JOptionPane;

public class IntSLLNode { private IntSLLNode next; public int info; public IntSLLNode(){ } public IntSLLNode(int i){ this(i,null); } public IntSLLNode(int i, IntSLLNode n){ int info= i; next=n; } public void addToHead(int i,Object head){ head=newIntSLLNode(i,head); if(tail==null) tail=head; } public void addToTail(int i){ if(isEmpaty()){ Tail.next=newIntsLLNode(i); tail=tail.next; } head=tail=newIntSLLNode(i); } public int deleteFromTail(){ int i=Head.info; if(Head==tail){ Head=tail=null; } else{ IntSLLNodetmp for(tmp=head;tmp.next!=tail;tmp=tmp.next){ tail.tmp;

tail.next=null; } } } public void PrintAll(){ for(IntSLLNode.tmp=head;tmp!=null;tmp=tmp.next){ System.out.print(tmp.info+""); } } public boolean isInList(int i){ IntSLLNode tmp; for(tmp=head;tmp!=null && tmp.info1=i;tmp=tmp.next){ returntmp!=null; } } public static void main (String args[]) { IntSLLNode x= new IntSLLNode(); }

PUBLICADO POR GRUPO1 EN 06:43

Estructura de Datos(Pilas)...Ejemplo
Definicin: Primero en Entrar, ultimo en Salir aqui les dejo un ejemplo sencillo
//Clase

de

Pilas

espero

les

sirva

de

algo

import java.*; import javax.swing.*; public int p[]; int tam; int tope; public Pila() { } public Pila(int t) { this.tam=t; p=new int [tam]; } public boolean Pila_Llena() { boolean ban=false; if(tope==p.length-1) { ban=true; } return ban; } public boolean Pila_Vacia() { boolean ban=false; if(tope==-1) { ban=true; } return ban; } public void llenar() { if(Pila_Vacia()) { for(int i=0;i<p.length;i++) { p[i]=Integer.parseInt(JOptionPane.showInputDialog("Introduce dato")); tope++; } } else { for(int i=tope+1;i<p.length;i++) { class Pila {

p[i]=Integer.parseInt(JOptionPane.showInputDialog("Introduce dato")); tope++; } } } public void Insertar() { int dato; if(!Pila_Llena()) { dato=Integer.parseInt(JOptionPane.showInputDialog("Introduce dato")); p[tope]=dato; } else { JOptionPane.showMessageDialog(null,"Pila llena"); } } public void Eliminar() { int dato; if(!Pila_Vacia()) { JOptionPane.showMessageDialog(null,"El elemento a eliminar es: "+p[tope]); tope--; } else { JOptionPane.showMessageDialog(null,"Pila Vacia"); } } public String toString() { String cad="Contenido\n"; for(int i=0;i<=tope;i++) { cad+=p[i]+", "; } return cad; } } //Aplicacion import javax.swing.*; import java.*;

public class AppPila { public static void main (String[] args) { int tam=Integer.parseInt(JOptionPane.showInputDialog("tamao")); Pila p=new Pila(tam);

for(;;) { byte opc=Byte.parseByte(JOptionPane.showInputDialog("Menu\n1.Insertar Pila\n4.Ver Pila\n5.Salir")); switch(opc) { case 1: p.Insertar(); break; case 2: p.Eliminar(); break; case 3: p.llenar(); break; case 4: JOptionPane.showMessageDialog(null,""+p.toString()); break; case 5: System.exit(5); } } } } dato\n2.Eliminar dato\n3.Llenar

La estructura de datos pila en java. Clase Stack del api java. Ejemplo y ejercicios resueltos. (CU00920C)
Escrito por Manuel Sierra

Resumen: Entrega n20 del Curso Lenguaje de programacin Java Nivel Avanzado I Codificacin aprenderaprogramar.com: CU00920C

CLASE STACK

A continuacin vamos a explicar la clase Stack de Java, que implementa la interface List. Stack se traduce por pila y para recordar su signifcado podemos pensar en una pila de libros. Tambin veremos las caractersticas ms importantes de esta nueva implementacin y haremos un ejemplo a modo de ejercicio.

STACK

La clase Stack es una clase de las llamadas de tipo LIFO (Last In - First Out, o ltimo en entrar - primero en salir). Esta clase hereda de la clase que ya hemos estudiado anteriormente en el curso Vector y con 5 operaciones permite tratar un vector a modo de pila o stack.

Las operaciones bsicas son push (que introduce un elemento en la pila), pop (que saca un elemento de la pila), peek (consulta el primer elemento de la cima de la pila), empty (que comprueba si la pila est vaca) y search (que busca un determinado elemento dentro de la pila y devuelve su posicin dentro de ella).

Esta clase es muy sencilla y al crear un objeto de tipo Stack con el constructor bsico evidentemente no contendr ningn elemento.

Un conjunto mucho ms completo y consistente para operaciones de stack LIFO son proporcionados en la interface Deque y sus implementaciones, pero nosotros de momento vamos a limitarnos al estudio de la clase Stack.

EJEMPLO USO CLASE STACK

Realizaremos un ejemplo a modo de uso de pila. Uno de los casos ms usados en informtica de una pila es cuando queremos verificar si una determinada sentencia o instruccin est equilibrada en cuanto a nmero de parntesis, corchetes o llaves de apertura y cierre. Cuando se escribe cdigo de programacin si no existe equilibrio entre signos de apertura (por ejemplo un parntesis de apertura) y cierre (por ejemplo un parntesis de cierre) ni siquiera debera procesarse la sentencia ya que no estara formalmente bien construida. De esto se encargan los analizadores lxicos de los compiladores. As que vamos a utilizar esta vez tan solo una clase Programa con el mtodo main, donde vamos a ir analizando una sentencia para verificar si es equilibrada o no en smbolos de parntesis, recorriendo todos sus caracteres desde el inicio hasta el final.

Iremos construyendo nuestra pila apilando un smbolo (cada vez que detectemos un smbolo de apertura o desapilando de ella cuando detectemos un smbolo de cierre. Tendremos que ir analizando todos los caracteres de una expresin y actuar cuando detectemos un parntesis, operando en funcin de si el parntesis ledo es de abrir (() o cerrar ()). El equilibrio en la escritura vendr determinado al terminar el anlisis en funcin de si la pila est vaca (hay equilibrio) o contiene algn elemento (no hay equilibrio).

Ejemplo: analizamos la expresin Hay varios pases (Mxico, Espaa) que comparten el mismo idioma (espaol o castellano).

El resultado al finalizar el anlisis de la sentencia sera que la pila est vaca, y esto querr decir que nuestra sentencia es equilibrada en parntesis y por tanto el resultado es correcto.

Si analizramos la expresin Hay varios pases (Mxico, Espaa) que comparten el mismo idioma (espaol o castellano.

El resultado al finalizar el anlisis ser que la pila contiene un parntesis, lo que quiere decir que la expresin no es equilibrada y no tiene el mismo nmero de parntesis abiertos que cerrados.

Tendremos que tener en cuenta casos especiales como una expresin cuyo primer elemento sea un parntesis de cierre. Por ejemplo: Hay varios pases )Mxico, Espaa( la consideraramos una expresin incorrecta ya que si la pila est vaca el primer elemento siempre tendr que ser un parntesis de apertura y no uno de cierre. Tendremos en cuenta por tanto que adems de equilibrio exista correccin en la forma de construccin (que no puedan existir cierres de parntesis que no se hayan abierto).

Vamos a escribir ahora el siguiente cdigo con el que vamos a trabajar:

/* Ejemplo Interface List, clase Stack aprenderaprogramar.com */ import java.util.Stack; public class Programa { public static void main(String arg[]) { String cadenano = "(Cadena no equilibrada en parntesis(()()()))))"; String cadenasi = "(Cadena equilibrada en parentesis())"; System.out.println("Verificacin equilibrado en parntesis para cadenano:"); System.out.println(verificaParentesis(cadenano)); System.out.println("Verificacin equilibrado en parntesis para cadenasi:"); System.out.println(verificaParentesis(cadenasi)); }

public static boolean verificaParentesis(String cadena) { Stack<String> pila = new Stack<String>(); int i = 0;

while (i<cadena.length()) { // Recorremos la expresin carcter a carcter if(cadena.charAt(i)=='(') {pila.push("(");} // Si el parntesis es de apertura apilamos siempre else if (cadena.charAt(i)==')') { // Si el parntesis es de cierre actuamos segn el caso if (!pila.empty()){ pila.pop(); } // Si la pila no est vaca desapilamos else { pila.push(")"); break; } // La pila no puede empezar con un cierre, apilamos y salimos } i++; } if(pila.empty()){ return true; } else { return false; } } }

En este ejemplo hemos creado la funcin verificaParentesis que nos devuelve un boolean indicando si dada una cadena, esta est equilibrada y correcta en parntesis. Para ello se hace uso internamente en este mtodo de una pila o stack. As el programa principal main tan solo llama a esta funcin con una cadena de ejemplo (cadenano o cadenasi) para verificar su equilibrado y correccin en parntesis.

El diagrama de clases por tanto para BlueJ es muy sencillo y tiene tan solo la clase Programa:

La salida que obtendremos por consola ser similar a esta:

CONCLUSIONES

Hemos visto un claro ejemplo del uso de la clase Stack que aunque muy sencilla, es muy til ya que su implementacin es muy fcil de aprender con tan solo los 5 mtodos comentados anteriormente (push, pop, peek, empty, search).

Para acceder a la informacin general sobre este curso y al listado completo de entregas pulsa en este link: Ver curso completo.

Para hacer un comentario o consulta utiliza los foros aprenderaprogramar.com, abiertos a cualquier persona independientemente de su nivel de conocimiento.

Bajar archivo...

Colas En Java
Una cola es simplemente un lugar para almacenar cosas, donde esas cosas se insertan una detrs de otra y para extraer siempre se lo hace por adelante de la cola donde se encuentra el primer elemento. Una cola funciona como una fila o cola de personas, que esperan su turno para ser atendidas, la primera persona atendida es siempre la primera de la fila y cuando llega una persona y queremos incorporarla a cola o adicionarla debemos hacerlo por detrs de la ultima persona en la cola.

Con fines educativos una cola se la puede representar grficamente as:

Una cola puede almacenar lo que nosotros queramos, nmeros, personas, documentos, cualquier cosa. Esta estructura de datos tiene muchas aplicaciones en la informtica al igual que la pila, por ejemplo cuando mandan a imprimir varios documentos a una impresora, existe una cola de impresin que sigue la filosofa, se imprimen los primeros documentos y si quiero imprimir un nuevo documento se adiciona al final de todos los documentos que estn esperando a imprimirse. Una vez comprendido en concepto ahora veamos como se implementa esto en un lenguaje de programacin, por ahora lo implementaremos en Java. Java en sus libreras ya tiene la forma de implementar Colas (queue), nosotros ahora haremos como si no existiera, es decir crearemos nuestra versin, que es lo que generalmente se hace cuando se aprende colas en la universidad. Pues bien existen dos formas de implementar para que la cola sea o bien esttica (reservamos un espacio fijo en memoria) o bien dinmica (el tamao en memoria va creciendo segn se requiere), se implementa con arrays o con listas enlazadas respectivamente. Nosotros implementaremos haciendo de un array bidimensional es decir de modo esttico y al decir esttico estamos diciendo que tendr un limite para almacenar datos en la cola. Para manipular elementos en el vector de la cola son necesarias variables que me digan en donde empiezan los elementos y otra en donde terminan, como tal vez ests pensando porque no solo una? (una que me diga en donde termina asumiendo que siempre se empieza desde la posicin 0 del array), pues se puede implementar con solo una de estas variables pero presenta muchas desventajas pues si eliminamos un elemento de nuestra cola, (el primero justamente) tendramos que recorrer todos los siguientes elementos una posicin adelante y esta manera seria muy lenta de implementar pues que pasa si son 1000 elementos, eso es mucho tiempo perdido, entonces es por eso que usamos dos variables que me digan donde empieza y donde terminan los elementos de la cola, dos variables enteras que llamaremos inicio y fin, estas variables funcionan de la siguiente manera:

Consideremos que nuestro array bidimensional o vector lo creamos con 10 posiciones enumeradas del 0 al 9, la variable inicio guarda una posicin antes en la cual se encuentra el primer elemento y la variable fin guarda la posicin en donde se encuentra justamente el ultimo elemento. Entonces los atributos que tendr nuestra clase Cola de nmeros enteros sern:
private private private private final int MAXIMO = 101; int[] V; int inicio; int fin;

Ahora una vez teniendo esta estructura hay que definir los mtodos principales para manejar una cola, estos mtodos son:

esVacia() : boolean

retorna verdad si la cola esta vaca es decir no tiene ningn elemento, para esto solo se pregunta si inicio es igual afin. retorna verdad si es que la cola esta llena, pasa cuando se ha llenado todo el vector, la cantidad de elemento que permite la cola lo determina la variable MAXIMO. adiciona un nuevo elemento a la cola, para esto solo se incrementa la variable fin y se coloca el elemento en esa posicin. extrae el primer elemento de la cola, para esto se retorna la posicin inicio + 1 del vector y se incrementa inicioen 1.

esLlena() : boolean

adicionar(int a)

eliminar() : int

tamanio() : int

retorna la cantidad de elementos que tiene la cola, para realizar esto se realiza la resta fin - inicio. copia tal cual la cola B a la cola destino, al finalizar cola B queda totalmente vaca. Este mtodo es muy til al momento de hacer operaciones con colas.

copiar(Cola B)

Con todos estos mtodos bsicos se puede realizar cualquier operacin que necesitemos, ahora puedes descargarte la clase Cola de nmeros enteros y otra clase cola para objetos Persona, tu puedes crear tu propia clase Cola que almacene lo que quieras ya solo hay que cambiar cierta parte del cdigo.

Descargar Clase Cola (.java) Descargar Clase Cola De Personas (.java)

Las clases son completamente funcionales y tambin debemos notar que una vez que llegamos al final de nuestro vector regresamos a la posicin inicial de nuestro vector, es por eso que veras en el cdigo varios operadores modulo. Nota: Se suele implementar a veces una cola llamada cola circular, en realidad no existe una cola circular pues es la misma que se implementa en todas partes suelen llamarla as porque su implementacin simula que los elementos van rotando en nuestro vector o array, sin embargo da lo mismo que cualquier cola, es por eso que solo existe o debera existir una clase Cola.
Una cola (tambin llamada fila) es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operacin de insercin push se realiza por un extremo y la operacin de extraccin pop por el otro. Tambin se le llama estructura FIFO (del ingls First In First Out), debido a que el primer elemento en entrar ser tambin el primero en salir. Las colas se utilizan en sistemas informticos, transportes y operaciones de investigacin(entre otros), dnde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas enlazadas.

import java.util.Scanner; /** * Clase Cola De Personas * @author Daniel Alvarez (a3dany) */ public class Cola { private private private private final int MAXIMO = 100; Persona[] V; int inicio; int fin;

public Cola() { this.V = new Persona[MAXIMO + 1]; this.inicio = 0; this.fin = 0; } public boolean esVacia() { return inicio == fin; } public boolean esLlena() { return tamanio() == MAXIMO - 1; } public void adicionar(Persona a) { if (esLlena()) { System.out.println("Cola Llena! No se pudo adicionar."); } else { fin = (fin + 1) % MAXIMO; V[fin] = a; } } public Persona eliminar() { Persona a = null; if (esVacia()) { System.out.println("Cola Vacia! No se pudo eliminar."); } else { inicio = (inicio + 1) % MAXIMO; a = V[inicio]; } return a; } public int tamanio() { return (fin - inicio + MAXIMO) % MAXIMO; } private void copiar(ColaCircular B) { while (!B.esVacia()) { adicionar(B.eliminar()); } }

public void leer() { Scanner in = new Scanner(System.in); System.out.print("Nro.Elementos: "); int n = in.nextInt(); System.out.println("Ingrese elementos:"); for (int i = 0; i < n; i++) { Persona a = new Persona(); a.leer(); adicionar(a); } } public void mostrar() { if (esVacia()) { System.out.println("Cola Vacia! No se puede mostrar nada."); } else { ColaCircular X = new ColaCircular(); while (!esVacia()) { Persona a = eliminar(); a.mostrar(); X.adicionar(a); } this.copiar(X); System.out.println(""); } } }

import java.util.Scanner; /** * Clase Cola * @author Daniel Alvarez (a3dany) */ public class Cola { private private private private final int MAXIMO = 100; int[] V; int inicio; int fin;

public Cola() { this.V = new int[MAXIMO + 1]; this.inicio = 0; this.fin = 0; } public boolean esVacia() { return inicio == fin; } public boolean esLlena() { return tamanio() == MAXIMO - 1; } public void adicionar(int a) { if (esLlena()) { System.out.println("Cola Llena! No se pudo adicionar."); } else { fin = (fin + 1) % MAXIMO; V[fin] = a; } } public int eliminar() { int a = Integer.MIN_VALUE; if (esVacia()) { System.out.println("Cola Vacia! No se pudo eliminar."); } else { inicio = (inicio + 1) % MAXIMO; a = V[inicio]; } return a; } public int tamanio() { return (fin - inicio + MAXIMO) % MAXIMO; } private void copiar(ColaCircular B) { while (!B.esVacia()) { adicionar(B.eliminar()); } }

public void leer() { Scanner in = new Scanner(System.in); System.out.print("Nro.Elementos: "); int n = in.nextInt(); System.out.println("Ingrese elementos:"); for (int i = 0; i < n; i++) { int a = in.nextInt(); adicionar(a); } } public void mostrar() { if (esVacia()) { System.out.println("Cola Vacia! No se puede mostrar nada."); } else { ColaCircular X = new ColaCircular(); while (!esVacia()) { int a = eliminar(); System.out.print(" " + a); X.adicionar(a); } this.copiar(X); System.out.println(""); } } }

Pilas, Colas. En Java

Queres escuchar Jazz?

www.Taringa.net/musica Descubr nuevas bandas, nueva msica.
Vamos a mostrar unos ejemplos de colas y pilas en Java Pilas: Primero definimos la pila como ultimo en entrar, primero en salir, cuando agregamos a la pilas usamospuhs y cuando queremos sacar de la pila usamos pop un ejemplo de pila es: imagina una torre de CD`S, el ultimo CD en entrar es el primero en salir; y el primer Cd en entrar es el ultimo en salir. Ahora vamos con el cdigo de una pila en Java: import java.util.*; public class Pilas extends LinkedList{ public void push (Object elemento){ //creamos el mtodo push donde por parametro nos entra el objeto a insertar this.addFirst(elemento); //Insertamos el objeto en la posicin 1 de la pila } public Object pop(){ //Creamos el mtodo pop el cual elimina el ultimo objeto agregado a la pila return this.removeFirst(); } } Ahora vamos a implemetar el cdigo de la pila Este cdigo es muy sencillo agregamos 5 nmeros y eliminamos el ultimo.

public class EjemploPilas { public static void main (String args[]){ Pila pila = new Pila (); pila.push(1); pila.push(2); pila.push(3); pila.push(4); pila.push(5); System.out.println(pila); pila.pop(); System.out.println(pila);

} }

Colas:el primer elemento en entrar ser tambin el primero en salir. Un ejemplo bastante comun en nuestra vida cotidiana es cuando haces un fila en el Banco, el primer cliente en entrar es el primer en ser atendido y por consiguiente ser el primer en salir nuestro cdigo de la cola: import java.util.*; public class Cola extends LinkedList { public void push (Object elemento){ this.addFirst(elemento); } public Object pop(){ return this.removeLast(); } }

Ahora vamos a implementar este cdigo en un ejemplo identico al anterior, al de la pila. Vamos a agregar cinco numeros

public class EjemploColas { public static void main (String args []){ Cola cola = new Cola (); cola.push(1); cola.push(2); cola.push(3); cola.push(4); cola.push(5); System.out.println(cola); cola.pop(); System.out.println(cola); }

Como podes ver En la PILA el numero que salia era el ultimo que entraba en ese caso era el numero 5; Mientras que en la COLA el primer numero en entrar es el primero en salir y en este caso el nmero que salia era el 1.

Espero poder solucionar algunas dudas. Suerte.

Saludos espero les sirva de mucho

Implementacion de pila y cola.

Tal vez le interese leer sobre listas enlazadas Segn lo que he aprendido, las pilas y colas no son estructura de datos, mas bien son formas de acceder a la informacin contenida en una estructura de dato como puede ser una lista o vector, entre otras. Definiciones: Una pila (stack en ingls) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del ingls Last In First Out, ltimo en entrar, primero en salir) que permite almacenar y recuperar datos. (por wikipedia).

Operaciones de la pila: Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen aadir ms de uso habitual. Crear: se crea la pila vaca (size). Apilar: se aade un elemento a la pila.(push) Desapilar: se elimina el elemento frontal de la pila.(pop) Cima: devuelve el elemento que esta en la cima de la pila. (top o peek) Vaca: devuelve cierto si la pila est vaca o falso en caso contrario (empty). ---------------------------------------------------------------------------------------Una cola (tambin llamada fila) es una estructura de datos (no estoy deacuerdo), caracterizada por ser una secuencia de elementos en la que la operacin de insercin push se realiza por un extremo y la operacin de extraccin pop por el otro. Tambin se le llama estructura FIFO (del ingls First In First Out), debido a que el primer elemento en entrar ser tambin el primero en salir.(por wikipedia)

Operaciones Bsicas de una Cola Crear: se crea la cola vaca. Encolar (aadir, entrar, insertar): se aade un elemento a la cola. Se aade al final de esta. Desencolar (sacar, salir, eliminar): se elimina el elemento frontal de la cola, es decir, el primer elemento que entr. Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primer elemento que entr. Vaca: devuelve cierto si la pila est vaca o falso en caso contrario (empty). Tal vez tambien te interese esto: Implementacion de una lista simple enlazada.

Mas

informacion: Pila, cola.

Codigo

Pila:

//Autor: Rey Salcedo Padilla import java.util.ArrayList; public class Pila extends ArrayList{ //se aade un elemento a la pila.(push) public void apilar(Object dato){ if(dato != null){ this.add(dato); }else{ System.out.println("Introduzca un dato no nulo"); } } //se elimina el elemento frontal de la pila.(pop) public void desapilar(){ if(size() > 0){ this.remove(this.size()-1); } } //devuelve el elemento que esta en la cima de la pila. (top o peek) public Object cima(){ Object datoAuxiliar = null; if(this.size() > 0){ datoAuxiliar = this.get(this.size()-1); } return datoAuxiliar; } //devuelve cierto si la (empty). public boolean vacia(){ return this.isEmpty(); } } pila est vaca o falso en caso contrario

Codigo
//Autor:Rey Salcedo Padilla import java.util.ArrayList; public class Cola extends ArrayList{ //se aade un elemento a la cola. Se aade al final de esta. public void encolar(Object dato){ if(dato != null){ this.add(dato); }else{ System.out.println("Introduzca un dato no nulo"); } } //se elimina el elemento elemento que entr. frontal de la cola, es decir, el

Cola:

primer

public void desencolar(){ if(this.size() > 0){ this.remove(0); } } //se devuelve el elemento frontal elemento que entr. public Object frente(){ Object datoAuxiliar = null; if(this.size() > 0){ datoAuxiliar = this.get(0); } return datoAuxiliar; } //devuelve cierto si la (empty). public boolean vacia(){ return this.isEmpty(); } } pila est de la cola, es decir, el primer

vaca

falso

en

caso

contrario

Codigo
//Autor:Rey Salcedo Padilla public class Main{ public static void main(String []args){ System.out.println("------Pila------"); Pila pila = new Pila(); pila.apilar("A"); pila.apilar("B"); pila.apilar("C"); pila.apilar("D"); System.out.println("Esta vacia la pila?:" + pila.vacia()); System.out.println("Tamao de la pila:" + pila.size()); System.out.println(pila.cima()); pila.desapilar(); System.out.println(pila.cima()); pila.desapilar(); System.out.println(pila.cima()); pila.desapilar(); System.out.println(pila.cima()); pila.desapilar(); System.out.println("Esta vacia la pila?:" + pila.vacia()); System.out.println("------Cola------"); Cola cola = new Cola(); cola.encolar("A");

Main:

cola.encolar("B"); cola.encolar("C"); cola.encolar("D"); System.out.println("Esta vacia la cola?:" + cola.vacia()); System.out.println("Tamao de la cola:" + cola.size()); System.out.println(cola.frente()); cola.desencolar(); System.out.println(cola.frente()); cola.desencolar(); System.out.println(cola.frente()); cola.desencolar(); System.out.println(cola.frente()); cola.desencolar(); System.out.println("Esta vacia la cola?:" + cola.vacia()); } }

Comenta acerca del cdigo.

Estructuras de Datos y Algoritmos en Java

o o
Pilas y Colas Pilas que "Recuerdan" Priorizar con Colas

Pilas y Colas
Los desarrolladores utilizan los arrays y las variantes de listas enlazadas para construir una gran variedad de estructuras de datos complejas. Este pgina explora dos de esas estructuras: las Pilas, las Colas . Cuando presentemos los algoritmos lo haremos ncamente en cdigo Java por motivos de brevedad.

La Pila es una estrucutra de datos donde las inserciones y recuperaciones/borrados de datos se hacen en uno de los finales, que es conocido como el top de la pila. Como el ltimo elemento insertado es el primero en recuperarse/borrarse, los desarrolladores se refieren a estas pilas como pilas LIFO ( last-in, first-out). Los datos se push (insertan) dentro y se pop (recuperan/borran) de la parte superior de la pila. La siguiente figura ilustra una pila con tres String cada uno insertado en la parte superior de la pila:

Pilas que "Recuerdan"

Como muestra la figura anterior, las pilas se construyen en memoria. Por cada dato insertado, el itm superior anterior y todos los datos inferiores se mueven hacia abajo. Cuando llega el momento de sacar un tem de la pila, se recpupera y se borra de la pila el tem superior (que en la figura anterior se revela como "third"). Las pilas son muy tiles en varios escenarios de programacin. Dos de los ms comunes son: Pilas que contienen direcciones de retorno: Cuando el cdigo llama a un mtodo, la direccin de la primera instruccin que sigue a la llamada se inserta en la parte superior de la pila de llamadas de mtodos del thread actual. Cuando el mtodo llamado ejecuta la instruccin return, se saca la direccin de la parte superior de la pila y la ejecucin contina en sa direccin. Si un mtodo llama a otro mtodo, el comportamiento LIFO de la pila asegura que la instruccin return del segundo mtodo transfiere la ejecucin al primer mtodo, y la del primer mtodo transfiere la ejecucin al cdigo que sigue al cdigo que llam al primer mtodo. Como resultado una pila "recuerda" las direcciones de retorno de los mtodos llamados. Pilas que contienen todos los parmetros del mtodo llamado y las variables locales: Cuando se llama a un mtodo, la JVM reserva memoria cerca de la direccin de retorno y almacena todos los parmetros del mtodo llamado y las variables locales de ese mtodo. Si el mtodo es un mtodo de ejemplar, uno de los parmetros que almacena en la pila es la referencia this del objeto actual. Es muy comn implementar una pila utilizando un array uni-dimensional o una lista de enlace simple. En el escenario del array uni-dimensional, una variable entera, tpicamente llamada top, contiene el ndice de la parte superior de la pila. De forma similar, una variable de referencia, tambin nombrada noramlmente como top, referencia el nodo superior del escenario de la lista de enlace simple.

He modelado mis implementaciones de pilas despus de encontrar la arquitectura del API Collections de Java. Mis implementaciones constan de un interface Stack para una mxima flexibilidad, las clases de implementacin ArrayStack y LinkedListStack, y una clase de soporte FullStackException. Para facilitar su distribucin, he empaquetado estas clases en un paquete llamado com.javajeff.cds, donde cds viene de estructura de datos complejas. El siguiente listado presenta el interface Stack:

// Stack.java package com.javajeff.cds; public interface Stack { boolean isEmpty (); Object peek (); void push (Object o); Object pop (); }
Sus cuatro mtodos determinan si la pila est vaca, recuperan el elemento superior sin borrarlo de la pia, situan un elemento en la parte superior de la pila y el ltimo recuera/borra el elemento superior. Aparte de un constructor especfico de la implementacin, su programa nicamente necesita llamar a estos mtodos. El siguiente listado presenta una implementacin de un Stack basado en un array uni-dimensional:

// ArrayStack.java package com.javajeff.cds; public class ArrayStack implements Stack private int top = -1; private Object [] stack; {

public ArrayStack (int maxElements) { stack = new Object [maxElements]; } public boolean isEmpty () { return top == -1; } public Object peek () { if (top < 0) throw new java.util.EmptyStackException (); return stack [top]; } public void push (Object o) { if (top == stack.length - 1) throw new FullStackException (); stack [++top] = o; } public Object pop () { if (top < 0) throw new java.util.EmptyStackException (); return stack [top--]; } } ArrayStack revela una pila como una combinacin de un ndice entero privado top y variables de referencia de un array uni-dimensional stack. top identifica el elemento superior de la pila y lo inicializa a 1 para indica que la pila est vaca. Cuando se crea un objeto ArrayStack llama apublic ArrayStack(int maxElements) con un valor entero que representa el nmero mximo de elementos.

Cualquier intento de sacar un elemento de una pila vaca mediantepop() resulta en el lanzamiento de una java.util.EmptyStackException. De forma similar, cualquier intento de poner ms elementos de maxElements dentro de la pila utilizandopush(Object o) lanzar una FullStackException, cuyo cdigo aparece en el siguiente listado:

// FullStackException.java package com.javajeff.cds; public class FullStackException extends RuntimeException { } Por simetra con EmptyStackException, FullStackException extiendeRuntimeException. Como resultado no se necesita aadir FullStackException a la clausulathrows del mtodo. El siguiente listado presenta una implementacin de Stack utilizando una lista de enlace simple: // LinkedListStack.java package com.javajeff.cds; public class LinkedListStack implements Stack private static class Node { Object o; Node next; } private Node top = null; public boolean isEmpty () { return top == null; } public Object peek () { if (top == null) throw new java.util.EmptyStackException (); return top.o; } public void push (Object o) { Node temp = new Node (); temp.o = o; temp.next = top; top = temp; } public Object pop () { if (top == null) throw new java.util.EmptyStackException (); Object o = top.o; top = top.next; return o; } } LinkedListStack revela una pila como una combinacin de una clase anidada privada de alto nivel llamada Node y una variable de referencia privada top que se inicialia a null para indicar una pila vaca. Al contrario que su contrapartida del array uni-dimensional, LinkedListStack no necesita un constructor ya que se expande dinmicamente cuando se ponen los tems en la pila. As, void push(Object o) no necesita lanzar una FullStackException. Sin embargo,Object pop() si debe chequear si la pila est vaca, lo que podra resultar en el lanzamiento de una EmptyStackException. {

Ahora que ya hemos visto el interface y las tres clases que generan mis implementaciones de las pilas, juguemos un poco. El siguiente listado muestra casi todo el soporte de pilas de mi paquete com.javajeff.cds:

// StackDemo.java import com.javajeff.cds.*; class StackDemo { public static void main (String [] args) { System.out.println ("ArrayStack Demo"); System.out.println ("---------------"); stackDemo (new ArrayStack (5)); System.out.println ("LinkedListStack Demo"); System.out.println ("--------------------"); stackDemo (new LinkedListStack ()); } static void stackDemo (Stack s) { System.out.println ("Pushing \"Hello\""); s.push ("Hello"); System.out.println ("Pushing \"World\""); s.push ("World"); System.out.println ("Pushing StackDemo object"); s.push (new StackDemo ()); System.out.println ("Pushing Character object"); s.push (new Character ('C')); System.out.println ("Pushing Thread object"); s.push (new Thread ("A")); try { System.out.println ("Pushing \"One last item\""); s.push ("One last item"); } catch (FullStackException e) { System.out.println ("One push too many"); } System.out.println (); while (!s.isEmpty ()) System.out.println (s.pop ()); try { s.pop (); } catch (java.util.EmptyStackException e) { System.out.println ("One pop too many"); } System.out.println (); } }
Cuando se ejecuta StackDemo, produce la siguiente salida:

ArrayStack Demo ---------------

Pushing "Hello" Pushing "World" Pushing StackDemo object Pushing Character object Pushing Thread object Pushing "One last item" One push too many Thread[A,5,main] C StackDemo@7182c1 World Hello One pop too many LinkedListStack Demo -------------------Pushing "Hello" Pushing "World" Pushing StackDemo object Pushing Character object Pushing Thread object Pushing "One last item" One last item Thread[A,5,main] C StackDemo@cac268 World Hello One pop too many

Priorizar con Colas

La Cola es una estructura de datos donde la insercin de tem se hace en un final (el fin de la cola) y la recuperacin/borrado de elementos se hace en el otro final (el inicio de la cola). Como el primer elemento insertado es el primero en ser recuperado, los desarrolladores se refieren a estas colas como estructuras FIFO (first-in, first-out). Normalmente los desarrolladores tabajan con dos tipos de colas: lineal y circular. En ambas colas, la insercin de datos se realiza en el fin de la cola, se mueven hacia adelante y se recuperan/borran del incio de la cola. La siguiente figura ilustra las colas lineal y circular:

La cola lineal de la figura anterior almacena cuatro enteros, con el entero 1 en primer lugar. Esa cola est llena y no puede almacenar ms datos adicionales porque rear identifica la parte final de la cola. La razn de la posicin vaca, que identifica front, implica el comportamiento lineal de la cola. Inicialmente, front y rear identifican la posicin ms a la izquierda, lo que indica que la cola est vaca. Para almacenar el entero 1, rear avanza una posicin hacia la derecha y almacena 1 en esa posicin. Para recuperar/borrar el entero 1, front avanza una posicin hacia la derecha.

Nota: Para sealar que la cola lineal est vaca, no necesita gastar una posicin, aunque esta aproximacin algunas veces es muy conneniente. En su lugar asigne el mismo valor que indique una posicin no existente a front y a rear. Por ejemplo, asumiendo una implementacin basada en un array uni-dimensional, front y rear podran contener -1. El ndice 0 indica entonces la posicin ms a la izquierda, y los datos se insertarn empezando en este ndice.

Cuando rear identifique la posicin ms a la derecha, la cola lineal podra no estar llena porquefront podra haber avanzado almenos una posicin para recuperar/borrar un dato. En este esceario, considere mover todos los tems de datos hacia la izquierda y ajuste la posicin defront y rear de la forma apropiada para crear ms espacio. Sin embargo, demasiado movimiento de datos puede afectar al rendimiento, por eso debe pensar cuidadosamente en los costes de rendimiento si necesita crear ms espacio.
La cola circular de la figura anterior tiene siete datos enteros, con el entero 1 primero. Esta cola est llena y no puede almacenar ms datos hasta que front avance una posicin en sentido horario (para recuperar el entero 1) y rear avance una posicin en la misma direcin (para identificar la posicin que contendr el nuevo entero). Al igual que con la cola lineal, la razon de la posicin vaca, que identifica front, implica el comportamiento circular de la cola. Inicialmente, front y rear identifican la misma posicin, lo que indica

una cola vaca. Entoncesrear avanza una posicin por cada nueva insercin. De forma similar, front avanza una posicin por cada recuperacin/borrado. Las colas son muy tiles en varios escenarios de programacin, entre los que se encuentran: Temporizacin de Threads: Una JVM o un sistema operativo subyacente podran establecer varias colas para coincidir con diferentes prioridades de los threads. La informacin del thread se bloquea porque todos los threads con una prioridad dada se almacenan en una cola asociada. Trabajos de impresin: Como una impresora normalmente es ms lenta que un ordenador, un sistema operativo maneja los trabajos de impresin en un subsistema de impresin, que inserta esos trabajos de impresin en una cola. El primer trabajo en esa cola se imprime primero, y as sucesivamente. Los desarrolladores normalmente utilizan una array uni-dimensional para implementar una cola. Sin embargo, si tienen que co-existir mltiple colas o las inserciones en las colas deben ocurrir en posiciones distintas a la ltima por motivos de prioridades, los desarrolladores suelen cambiar a la lista doblemente enlazada. Con un array uni-dimensional dos variables enteras (normalmente llamadas front y rear) contienen los ndices del primer y ltimo elemento de la cola, respectivamente. Mis implementaciones de colas lineales y circulares usan un array uni-dimensional y empiezan con el interface Queue que puede ver en el siguiente listado:

// Queue.java package com.javajeff.cds; public interface Queue { void insert (Object o); boolean isEmpty (); boolean isFull (); Object remove (); } Queue declara cuatro mtodos para almacenar un datos, determinar si la cola est vaca, determinar si la cola
est llena y recuperar/borrar un dato de la cola. Llame a estos mtodos (y a un constructor) para trabajar con cualquier implementacin de Queue. El siguiente listado presenta una a implementacin de Queue de una cola lineal basada en un array unidimensional:

// ArrayLinearQueue.java package com.javajeff.cds; public class ArrayLinearQueue implements Queue { private int front = -1, rear = -1; private Object [] queue; public ArrayLinearQueue (int maxElements) { queue = new Object [maxElements]; } public void insert (Object o) { if (rear == queue.length - 1) throw new FullQueueException (); queue [++rear] = o; } public boolean isEmpty () { return front == rear; } public boolean isFull () { return rear == queue.length - 1; }

public Object remove () { if (front == rear) throw new EmptyQueueException (); return queue [++front]; } } ArrayLinearQueue revela que una cola es una combinacin de variables privadas front, rear, y queue. front y rear se inicializan a -1 para indicar una cola vaca. Igual que el constructor deArrayStack llama a public ArrayLinearQueue(int maxElements) con un valor entero
que especifique el nmero mximo de elementos durante la construccin de un objetoArrayLinearQueue. El mtodo insert(Object o) de ArrayLinearQueue lanza una FullQueueExceptioncuando rear identifica el elemento final del array uni-dimensional. El cdigo deFullQueueException aparece en el siguiente listado:

// FullQueueException.java package com.javajeff.cds; public class FullQueueException extends RuntimeException { } El mtodo remove() de ArrayLinearQueue lanza una EmptyQueueException cuando objetos front y rear son iguales. El siguiente listado presenta el cdigo de esta clase: // EmptyQueueException.java package com.javajeff.cds; public class EmptyQueueException extends RuntimeException { } El siguiente listado presenta una implementacin de Queue para una cola circular basada en un array unidimensional:

los

// ArrayCircularQueue.java package com.javajeff.cds; public class ArrayCircularQueue implements Queue { private int front = 0, rear = 0; private Object [] queue; public ArrayCircularQueue (int maxElements) { queue = new Object [maxElements]; } public void insert (Object o) { int temp = rear; rear = (rear + 1) % queue.length; if (front == rear) { rear = temp; throw new FullQueueException (); } queue [rear] = o; } public boolean isEmpty () { return front == rear; }

public boolean isFull () { return ((rear + 1) % queue.length) == front; } public Object remove () { if (front == rear) throw new EmptyQueueException (); front = (front + 1) % queue.length; return queue [front]; } } ArrayCircularQueue revela una implementacin, en terminos de variables privadas y un constructor, muy similar a ArrayLinearQueue. El mtodo insert(Object o) es interesante porque guarda el valor actual de rear antes de hacer que esa variable apunte a la siguiente posicin. Si la cola circular est llena, rear restaura su valor original antes de lanzar unaFullQueueException. La restauracin de rear es necesaria porque front es igual a rear(en ese punto), y una subsecuente llamada a remove() resulta en la lanzamiento de unaEmptyQueueException (incluso aunque la cola circular no
est vaca). Despus de estudiar el cdigo del interface y de varias clases que lo implementan basndose en arrays unidimensionales, consideremos en el siguiente listado una aplicacin que demuestra las colas lineales y circulares:

// QueueDemo.java import com.javajeff.cds.*; class QueueDemo { public static void main (String [] args) { System.out.println ("ArrayLinearQueue Demo"); System.out.println ("---------------------"); queueDemo (new ArrayLinearQueue (5)); System.out.println ("ArrayCircularQueue Demo"); System.out.println ("---------------------"); queueDemo (new ArrayCircularQueue (6)); // Need one more slot because // of empty slot in circular // implementation } static void queueDemo (Queue q) { System.out.println ("Is empty = " + q.isEmpty ()); System.out.println ("Is full = " + q.isFull ()); System.out.println ("Inserting \"This\""); q.insert ("This"); System.out.println ("Inserting \"is\""); q.insert ("is"); System.out.println ("Inserting \"a\""); q.insert ("a"); System.out.println ("Inserting \"sentence\""); q.insert ("sentence"); System.out.println ("Inserting \".\"");

q.insert ("."); try { System.out.println ("Inserting \"One last item\""); q.insert ("One last item"); } catch (FullQueueException e) { System.out.println ("One insert too many"); System.out.println ("Is empty = " + q.isEmpty ()); System.out.println ("Is full = " + q.isFull ()); } System.out.println (); while (!q.isEmpty ()) System.out.println (q.remove () + " [Is q.isEmpty () + ", Is full = " + q.isFull () + "]"); try { q.remove (); } catch (EmptyQueueException e) { System.out.println ("One remove too many"); } System.out.println (); } }
Cuando se ejecuta QueueDemo, se produce la siguiente salida:

empty

"

ArrayLinearQueue Demo --------------------Is empty = true Is full = false Inserting "This" Inserting "is" Inserting "a" Inserting "sentence" Inserting "." Inserting "One last item" One insert too many Is empty = false Is full = true This [Is empty = false, Is full = true] is [Is empty = false, Is full = true] a [Is empty = false, Is full = true] sentence [Is empty = false, Is full = true] . [Is empty = true, Is full = true] One remove too many ArrayCircularQueue Demo --------------------Is empty = true Is full = false Inserting "This" Inserting "is" Inserting "a"

Inserting "sentence" Inserting "." Inserting "One last item" One insert too many Is empty = false Is full = true This [Is empty = false, Is full = false] is [Is empty = false, Is full = false] a [Is empty = false, Is full = false] sentence [Is empty = false, Is full = false] . [Is empty = true, Is full = false] One remove too many