Listas

Lista (estructura de datos)

En Ciencias de la Computación, 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 eliminación 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 Tamaño(){//saber el tamaño

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 operación que desee" );

op = leer.nextInt(); //coger la opcion

switch(op){

case 1:

System.out.println( "Inserte numero" );

//coger el numero y añadirlo 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" );

//tamaño 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 calificación:" );

nodo.calif1 = leer.nextInt();

System.out.println( "Ingrese la segunda calificación:" );

nodo.calif2 = leer.nextInt();

System.out.println( "Ingrese la tercera calificación:" );

nodo.calif3 = leer.nextInt();

//lo qeu queda guardado

lista.add("Nombre del alumno:\n"+nodo.nom);

lista.add("Calificación 1:\n"+nodo.calif1);

lista.add("Calificación 2:\n"+nodo.calif2);

lista.add("Calificación 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 espectáculo");

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 histórico");

if (Ãndice==4) text.setText("casco histórico");

if (Ãndice==5) text.setText("casco histórico");

if (Ãndice==6) text.setText("casco histórico");

if (Ãndice==7) text.setText("casco histórico");

if (Ãndice==8) text.setText("casco histórico");

if (Ãndice==9) text.setText("Bosque");

if (Ãndice==10) text.setText("casco histórico");

if (Ãndice==11) text.setText("Lago de San Giorgio");

if (Ãndice==12) text.setText("casco histórico");

if (Ãndice==13) text.setText("Piana Romana, casco histórico, casas de Padre Ão");

if (Ãndice==14) text.setText("Encuentro internacional de globos, Palacio Ducal");

if (Ãndice==15) text.setText("casco histórico");

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();

}

}

PUBL ICADO POR  GRUPO1 EN 06:43  

Estructura de Datos(Pilas)...EjemploDefinición: Primero en Entrar, ultimo en Salir aqui les dejo un ejemplo

sencillo de Pilas y espero y les sirva de algo 

//Clase

import  java.*;

import  javax.swing.*;public class Pila {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++)

      {

      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("tamaño"));

          Pila p=new Pila(tam);         

          for(;;)

          {

          byte opc=Byte.parseByte(JOptionPane.showInputDialog("Menu\n1.Insertar dato\n2.Eliminar dato\n3.Llenar 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);}

          }}}

La estructura de datos pila en java. Clase Stack del api java. Ejemplo y ejercicios

resueltos. (CU00920C)Escrito por Manuel Sierra

Resumen: Entrega nº20 del Curso Lenguaje de programación Java Nivel Avanzado I

Codificación aprenderaprogramar.com: CU00920C 

 

 

CLASE STACK

 

A continuación 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. También veremos las características más importantes de esta nueva implementación 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 básicas 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á vacía) y search (que busca un determinado elemento dentro de la pila y devuelve su posición dentro de ella).

 

Esta clase es muy sencilla y al crear un objeto de tipo Stack con el constructor básico evidentemente no contendrá ningún elemento.

 

Un conjunto mucho más 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 más usados en informática de una pila es cuando queremos verificar si una determinada sentencia o instrucción está equilibrada en cuanto a número de paréntesis, corchetes o llaves de apertura y cierre. Cuando se escribe código de programación si no existe equilibrio entre signos de apertura (por ejemplo un paréntesis de apertura) y cierre (por ejemplo un paréntesis de cierre) ni siquiera debería procesarse la sentencia ya que no estaría formalmente bien construida. De esto se encargan los analizadores léxicos de los compiladores.

Así que vamos a utilizar esta vez tan solo una clase Programa con el método main, donde vamos a ir analizando una sentencia para verificar si es equilibrada o no en símbolos de paréntesis, recorriendo todos sus caracteres desde el inicio hasta el final.

 

Iremos construyendo nuestra pila apilando un símbolo (cada vez que detectemos un símbolo de apertura o desapilando de ella cuando detectemos un símbolo de cierre. Tendremos que ir analizando todos los caracteres de una expresión y actuar cuando detectemos un paréntesis, operando en función de si el paréntesis leído es de abrir (“(”) o cerrar (“)”). El equilibrio en la escritura vendrá determinado al terminar el análisis en función de si la pila está vacía (hay equilibrio) o contiene algún elemento (no hay equilibrio).

 

Ejemplo: analizamos la expresión “Hay varios países (México, España) que comparten el mismo idioma (español o castellano).”

 

El resultado al finalizar el análisis de la sentencia sería que la pila está vacía, y esto querrá decir que nuestra sentencia es equilibrada en paréntesis y por tanto el resultado es correcto.

 

Si analizáramos la expresión “Hay varios países (México, España) que comparten el mismo idioma (español o castellano.”

 

El resultado al finalizar el análisis será que la pila contiene un paréntesis, lo que quiere decir que la expresión no es equilibrada y no tiene el mismo número de paréntesis abiertos que cerrados.

 

Tendremos que tener en cuenta casos especiales como una expresión cuyo primer elemento sea un paréntesis de cierre. Por ejemplo: “Hay varios países )México, España(“ la consideraríamos una expresión incorrecta ya que si la pila está vacía el primer elemento siempre tendrá que ser un paréntesis de apertura y no uno de cierre. Tendremos en cuenta por tanto que además de equilibrio exista corrección en la forma de construcción (que no puedan existir cierres de paréntesis que no se hayan abierto).

 

Vamos a escribir ahora el siguiente código 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 paréntesis(()()()))))";

            String cadenasi = "(Cadena equilibrada en parentesis())";

            System.out.println("Verificación equilibrado en paréntesis para cadenano:");

            System.out.println(verificaParentesis(cadenano));

            System.out.println("Verificación equilibrado en paréntesis 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 expresión carácter a carácter

                if(cadena.charAt(i)=='(') {pila.push("(");} // Si el paréntesis es de apertura apilamos siempre                               

                else if  (cadena.charAt(i)==')') {  // Si el paréntesis es de cierre actuamos según el caso

                            if (!pila.empty()){ pila.pop(); } // Si la pila no está vacía 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 función verificaParentesis que nos devuelve un boolean indicando si dada una cadena, esta está equilibrada y correcta en paréntesis. Para ello se hace uso internamente en este método de una pila o stack. Así el programa principal main tan solo llama a esta función con una cadena de ejemplo (cadenano o cadenasi) para verificar su equilibrado y corrección en paréntesis.

 

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 implementación es muy fácil de aprender con tan solo los 5 métodos comentados anteriormente (push, pop, peek, empty, search).

 

 

 

 

 

 

 

 

Para acceder a la información 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 JavaUna cola es simplemente un lugar para almacenar cosas, donde esas cosas se insertan una detrás 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 detrás de la ultima persona en la cola.

Con fines educativos una cola se la puede representar gráficamente así:

Una cola puede almacenar lo que nosotros queramos, números, personas, documentos, cualquier cosa. Esta estructura de datos tiene muchas aplicaciones en la informática al igual que la pila, por ejemplo cuando mandan a imprimir varios documentos a una impresora, existe una cola de impresión que sigue la filosofía, se imprimen los primeros documentos y si quiero imprimir un nuevo documento se adiciona al final de todos los documentos que están esperando a imprimirse.

Una vez comprendido en concepto ahora veamos como se implementa esto en un lenguaje de programación, por ahora lo implementaremos en Java. Java en sus librerías ya tiene la forma de implementar Colas (queue), nosotros ahora haremos como si no existiera, es decir crearemos nuestra versión, 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 estática (reservamos un espacio fijo en memoria) o bien dinámica (el tamaño en memoria va creciendo según se requiere), se implementa con arrays o con listas enlazadas respectivamente. Nosotros implementaremos haciendo de un array bidimensional es decir de modo estático y al decir estático 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 estés pensando ¿porque no solo una? (una que me diga en donde termina asumiendo que siempre se empieza desde la posición 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) tendríamos que recorrer todos los siguientes elementos una posición 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 posición antes en la cual se encuentra el primer elemento y la variable fin guarda la posición en donde se encuentra justamente el ultimo elemento.

Entonces los atributos que tendrá nuestra clase Cola de números enteros serán:

private final int MAXIMO = 101;

private int[] V;

private int inicio;

private int fin;

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

esVacia() : boolean retorna verdad si la cola esta vacía es decir no tiene ningún elemento, para esto solo se pregunta si inicio es igual afin.

esLlena() : boolean 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.

adicionar(int a) adiciona un nuevo elemento a la cola, para esto solo se incrementa la variable fin y se coloca el elemento en esa posición.

eliminar() : int extrae el primer elemento de la cola, para esto se retorna la posición inicio + 1 del vector y se incrementa inicioen 1.

tamanio() : int retorna la cantidad de elementos que tiene la cola, para realizar esto se realiza la resta fin - inicio.

copiar(Cola B) copia tal cual la cola B a la cola destino, al finalizar cola B queda totalmente vacía. Este método es muy útil al momento de hacer operaciones con colas.

Con todos estos métodos básicos  se puede realizar cualquier operación que necesitemos, ahora puedes descargarte la clase Cola de números 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 código.

Descargar Clase Cola (.java)

Descargar Clase Cola De Personas (.java)

Las clases son completamente funcionales y también debemos notar que una vez que llegamos al final de nuestro vector regresamos a la posición inicial de nuestro vector, es por eso que veras en el código 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 implementación 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 debería existir una clase Cola.

Una cola (también llamada fila) es una estructura de datos, caracterizada por ser una secuencia

de elementos en la que la operación de inserción push se realiza por un extremo y la operación de

extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out),

debido a que el primer elemento en entrar será también el primero en salir.

Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación(entre

otros), dónde 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 final int MAXIMO = 100; private Persona[] V; private int inicio; private 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 final int MAXIMO = 100; private int[] V; private int inicio; private 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 música.

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 código de una pila en Java: 

import java.util.*; public class Pilas extends LinkedList{ 

public void push (Object elemento){ //creamos el método push donde por parametro nos entra el objeto a insertar 

this.addFirst(elemento); //Insertamos el objeto en la posición 1 de la pila } public Object pop(){ //Creamos el método pop el cual elimina el ultimo objeto agregado a la pila return this.removeFirst(); } 

} 

Ahora vamos a implemetar el código de la pila 

Este código es muy sencillo agregamos 5 números 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á también 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 código 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 código 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 número 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 enlazadasSegún lo que he aprendido, las pilas y colas no son estructura de datos, mas bien son formas de acceder a la información contenida en una estructura de dato como puede ser una lista o vector, entre otras.

Definiciones: Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés 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 añadir más de uso habitual.Crear: se crea la pila vacía (size).Apilar: se añade 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)Vacía: devuelve cierto si la pila está vacía o falso en caso contrario (empty).----------------------------------------------------------------------------------------Una cola (también llamada fila) es una estructura de datos (no estoy deacuerdo), caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.(por wikipedia)

Operaciones Básicas de una ColaCrear: se crea la cola vacía.Encolar (añadir, entrar, insertar): se añade un elemento a la cola. Se añade 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ó.Vacía: devuelve cierto si la pila está vacía 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 Padillaimport java.util.ArrayList;public class Pila extends ArrayList{ //se añade 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 pila está vacía o falso en caso contrario (empty). public boolean vacia(){ return this.isEmpty(); }}

Codigo Cola:

//Autor:Rey Salcedo Padillaimport java.util.ArrayList;public class Cola extends ArrayList{ //se añade un elemento a la cola. Se añade al final de esta. public void encolar(Object dato){ if(dato != null){ this.add(dato); }else{ System.out.println("Introduzca un dato no nulo"); } }

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

Codigo Main:

//Autor:Rey Salcedo Padillapublic 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("Tamaño 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");

cola.encolar("B"); cola.encolar("C"); cola.encolar("D"); System.out.println("Esta vacia la cola?:" + cola.vacia()); System.out.println("Tamaño 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 código.

Estructuras de Datos y Algoritmos en Java Pilas y Colaso Pilas que "Recuerdan"o Priorizar con Colas

Pilas y ColasLos desarrolladores utilizan los arrays y las variantes de listas enlazadas para construir una gran variedad de estructuras de datos complejas. Este página explora dos de esas estructuras: las Pilas, las Colas . Cuando presentemos los algoritmos lo haremos úncamente en código Java por motivos de brevedad.

 Pilas que "Recuerdan"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:

Como muestra la figura anterior, las pilas se construyen en memoria. Por cada dato insertado, el itém 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 programación. Dos de los más comunes son: Pilas que contienen direcciones de retorno: 

Cuando el código llama a un método, la dirección de la primera instrucción que sigue a la llamada se inserta en la parte superior de la pila de llamadas de métodos del thread actual. Cuando el método llamado ejecuta la instrucción return, se saca la dirección de la parte superior de la pila y la ejecución continúa en sa dirección. Si un método llama a otro método, el comportamiento LIFO de la pila asegura que la instrucción return del segundo método transfiere la ejecución al primer método, y la del primer método transfiere la ejecución al código que sigue al código que llamó al primer método. Como resultado una pila "recuerda" las direcciones de retorno de los métodos llamados.

Pilas que contienen todos los parámetros del método llamado y las variables locales: Cuando se llama a un método, la JVM reserva memoria cerca de la dirección de retorno y almacena todos los parámetros del método llamado y las variables locales de ese método.

Si el método es un método de ejemplar, uno de los parámetros que almacena en la pila es la referencia this del objeto actual.

Es muy común implementar una pila utilizando un array uni-dimensional o una lista de enlace simple. En el escenario del array uni-dimensional, una variable entera, típicamente llamada top, contiene el índice de la parte superior de la pila. De forma similar, una variable de referencia, también nombrada noramlmente como top, referencia el nodo superior del escenario de la lista de enlace simple.He modelado mis implementaciones de pilas después de encontrar la arquitectura del API Collections de Java. Mis implementaciones constan de un interface Stack para una máxima flexibilidad, las clases de implementación ArrayStack y LinkedListStack, y una clase de soporte FullStackException. Para facilitar su distribución, 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 métodos determinan si la pila está vacía, 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 específico de la implementación, su programa únicamente necesita llamar a estos métodos.El siguiente listado presenta una implementación 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 combinación 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á vacía. Cuando se crea un objeto ArrayStack llama apublic ArrayStack(int maxElements) con un valor entero que representa el número máximo de elementos. Cualquier intento de sacar un elemento de una pila vacía mediantepop() resulta en el lanzamiento de una java.util.EmptyStackException. De forma similar, cualquier intento de poner más elementos de maxElements dentro de la pila utilizandopush(Object o) lanzará una FullStackException, cuyo código aparece en el siguiente listado:// FullStackException.java

package com.javajeff.cds;

public class FullStackException extends RuntimeException { } Por simetría con EmptyStackException, FullStackException extiendeRuntimeException. Como resultado no se necesita añadir FullStackException a la clausulathrows del método.El siguiente listado presenta una implementación 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 combinación 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 vacía. Al contrario que su contrapartida del array uni-dimensional, LinkedListStack no necesita un constructor ya que se expande dinámicamente 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á vacía, lo que podría 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 ColasLa Cola es una estructura de datos donde la inserción de ítem se hace en un final (el fin de la cola) y la recuperación/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 inserción 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 más datos adicionales porque rear identifica la parte final de la cola. La razón de la posición vacía, que identifica front, implica el comportamiento lineal de la cola. Inicialmente, front y rear identifican la posición más a la izquierda, lo que indica que la cola está vacía. Para almacenar el entero 1, rear avanza una posición hacia la derecha y almacena 1 en esa posición. Para recuperar/borrar el entero 1, front avanza una posición hacia la derecha.

Nota:

Para señalar que la cola lineal está vacía, no necesita gastar una posición, aunque esta aproximación algunas veces es muy conneniente. En su lugar asigne el mismo valor que indique una posición no existente a front y a rear. Por ejemplo, asumiendo una implementación basada en un array uni-dimensional, front y rear podrían contener -1. El índice 0 indica entonces la posición más a la izquierda, y los datos se insertarán empezando en este índice.

Cuando rear identifique la posición más a la derecha, la cola lineal podría no estar llena porquefront podría haber avanzado almenos una posición para recuperar/borrar un dato. En este esceario, considere mover todos los ítems de datos hacia la izquierda y ajuste la posición defront y rear de la forma apropiada para crear más espacio. Sin embargo, demasiado movimiento de datos puede afectar al rendimiento, por eso debe pensar cuidadosamente en los costes de rendimiento si necesita crear más 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 más datos hasta que front avance una posición en sentido horario (para recuperar el entero 1) y rear avance una posición en la misma direción (para identificar la posición que contendrá el nuevo entero). Al igual que con la cola lineal, la razon de la posición vacía, que identifica front, implica el comportamiento circular de la cola. Inicialmente, front y rear identifican la misma posición, lo que indica una cola vacía.

Entoncesrear avanza una posición por cada nueva inserción. De forma similar, front avanza una posición por cada recuperación/borrado.Las colas son muy útiles en varios escenarios de programación, entre los que se encuentran: Temporización de Threads: 

Una JVM o un sistema operativo subyacente podrían establecer varias colas para coincidir con diferentes prioridades de los threads. La información del thread se bloquea porque todos los threads con una prioridad dada se almacenan en una cola asociada.

Trabajos de impresión: Como una impresora normalmente es más lenta que un ordenador, un sistema operativo maneja los trabajos de impresión en un subsistema de impresión, que inserta esos trabajos de impresión 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 múltiple 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 métodos para almacenar un datos, determinar si la cola está vacía, determinar si la cola está llena y recuperar/borrar un dato de la cola. Llame a estos métodos (y a un constructor) para trabajar con cualquier implementación de Queue.El siguiente listado presenta una a implementación de Queue de una cola lineal basada en un array uni-dimensional:// 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 combinación de variables privadas front, rear, y queue. front y rear se inicializan a -1 para indicar una cola vacía. Igual que el constructor deArrayStack llama a public ArrayLinearQueue(int maxElements) con un valor entero que especifique el número máximo de elementos durante la construcción de un objetoArrayLinearQueue.El método insert(Object o) de ArrayLinearQueue lanza una FullQueueExceptioncuando rear identifica el elemento final del array uni-dimensional. El código deFullQueueException aparece en el siguiente listado:// FullQueueException.java

package com.javajeff.cds;

public class FullQueueException extends RuntimeException { } El método remove() de ArrayLinearQueue lanza una EmptyQueueException cuando los objetos front y rear son iguales. El siguiente listado presenta el código de esta clase:// EmptyQueueException.java

package com.javajeff.cds;

public class EmptyQueueException extends RuntimeException { } El siguiente listado presenta una implementación de Queue para una cola circular basada en un array uni-dimensional:// 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 implementación, en terminos de variables privadas y un constructor, muy similar a ArrayLinearQueue. El método insert(Object o) es interesante porque guarda el valor actual de rear antes de hacer que esa variable apunte a la siguiente posición. Si la cola circular está llena, rear restaura su valor original antes de lanzar unaFullQueueException. La restauración 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é vacía).Después de estudiar el código del interface y de varias clases que lo implementan basándose en arrays uni-dimensionales, consideremos en el siguiente listado una aplicación 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 empty = " + 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: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