Lectura 3 - Listas Enlazadas

Módulo 3 Unidad 3 Lectura 3

Materia: Taller de Algoritmos y Estructuras de Datos I Profesora: Adriana Pérez

3- LISTAS ENLAZADAS Frases introductorias Las listas enlazadas son estructuras de datos complejas complejas dinámicas que permiten almacenar almacenar los elementos elementos de acuerdo a un criterio criterio de orden, esto las diferencia de las pilas y colas por tener orden lógico distinto al orden físico.

3.1 Conceptos básicos Recordemos que hemos visto hasta el momento las estructuras dinámicas lineales, pila y cola. Si bien estas estructuras son listas enlazadas, vimos que su comportamiento responde a almacenar datos por orden de llegada ubicándose siempre después del último elemento y elimina el primero en el caso de la cola y el último en el caso de la pila, respondiendo a la característica FIFO (first input, first output) y LIFO (last inpunt first output) respectivamente. respectivamente. Cuando listamos los elementos los visualizamos en el mismo orden en que los ingresamos, es por ello que su orden físico es igual a su orden lógico. Las estructuras dinámicas llamadas listas enlazadas, tienen el mismo criterio de orden de carga, orden de llegada, pero permiten insertar en cualquier lugar y eliminar cualquier elemento elemento de la lista. En forma general, decimos que: Una lista es una colección de elementos llamados generalmente

nodos, donde el orden entre ellos se establece por medio de referencias; es decir, direcciones o enlaces a otros nodos, con cierto criterio de carga y características que condicionarán las operaciones de inserción y eliminación de los nodos.

Ahora seguiremos seguiremos con las estructuras dinámicas dinámicas lineales listas simplemente simplemente y doblemente enlazadas enlazadas teniendo en en cuenta que pueden ser ordenadas por un criterio determinado con anterioridad. anterioridad. La siguiente figura muestra una lista ligada con cuatro elementos. Llamaremos a cada elemento de la lista, nodo. nodo. Cada nodo debe almacenar el dato y un enlace que señala al nodo siguiente. La lista requiere de la definición de una variable que almacene el apuntador del primer nodo. Cuando decimos primer nodo nos referimos al primero según el orden lógico.

Materia: Taller de Algoritmos y Estructuras de Datos I Profesora: Adriana Pérez | 2

3- LISTAS ENLAZADAS Frases introductorias Las listas enlazadas son estructuras de datos complejas complejas dinámicas que permiten almacenar almacenar los elementos elementos de acuerdo a un criterio criterio de orden, esto las diferencia de las pilas y colas por tener orden lógico distinto al orden físico.

3.1 Conceptos básicos Recordemos que hemos visto hasta el momento las estructuras dinámicas lineales, pila y cola. Si bien estas estructuras son listas enlazadas, vimos que su comportamiento responde a almacenar datos por orden de llegada ubicándose siempre después del último elemento y elimina el primero en el caso de la cola y el último en el caso de la pila, respondiendo a la característica FIFO (first input, first output) y LIFO (last inpunt first output) respectivamente. respectivamente. Cuando listamos los elementos los visualizamos en el mismo orden en que los ingresamos, es por ello que su orden físico es igual a su orden lógico. Las estructuras dinámicas llamadas listas enlazadas, tienen el mismo criterio de orden de carga, orden de llegada, pero permiten insertar en cualquier lugar y eliminar cualquier elemento elemento de la lista. En forma general, decimos que: Una lista es una colección de elementos llamados generalmente

nodos, donde el orden entre ellos se establece por medio de referencias; es decir, direcciones o enlaces a otros nodos, con cierto criterio de carga y características que condicionarán las operaciones de inserción y eliminación de los nodos.

Ahora seguiremos seguiremos con las estructuras dinámicas dinámicas lineales listas simplemente simplemente y doblemente enlazadas enlazadas teniendo en en cuenta que pueden ser ordenadas por un criterio determinado con anterioridad. anterioridad. La siguiente figura muestra una lista ligada con cuatro elementos. Llamaremos a cada elemento de la lista, nodo. nodo. Cada nodo debe almacenar el dato y un enlace que señala al nodo siguiente. La lista requiere de la definición de una variable que almacene el apuntador del primer nodo. Cuando decimos primer nodo nos referimos al primero según el orden lógico.


Los nodos ligados no tienen que estar físicamente adyacentes y el último tiene Null como enlace marcando el final de la lista, como vemos en la figura anterior.

El nodo cabecera no guarda ningún dato, solo la referencia al primer nodo de la lista.

Mark Allen Weiss en su libro “Estructuras de datos en Java”, bibliografía básica de la materia, trata trata las listas enlazadas en varios varios capítulos. En el capítulo 6, hace una introducción, en el capítulo 16 hace la implementación en código Java, usted usted puede codificarlos tal como lo presenta presenta el autor. En este módulo veremos otra alternativa de resolución para que pueda luego tomar su propia codificación, respetando siempre las buenas prácticas y la Cuando la lista está vacía no guarda ninguna referencia en el atributo siguiente: Cabecera.sig = Null Programación Orientada a Objetos. La clase nodo de la Lista enlazada es como el que utilizamos en la estructura Cola, tiene 2 atributos, el objeto a almacenar y el enlace al siguiente.


ackage com.estructuras; public class Nodo { private T dato dato; ; //cualquier tipo de valor, sig; ; private Nodo sig public Nodo() { dato = = null ; this.dato this.sig sig = = null; } public T getDato() { dato; ; return dato } public void setDato(T dato) { setDato(T dato = = dato; this.dato } public Nodo getSig() { return sig sig; ; }

setSig(Nodo sig) { setSig(Nodo public void this.sig sig = = sig; } public Nodo(T dato) { dato = = dato; this.dato } public Nodo(T dato, Nodo sig) { dato = = dato; this.dato this.sig sig = = sig; }

}

La lista enlazada es una estructura de datos compuesta por estos nodos donde las operaciones de insertar y eliminar la diferencian de las pilas y colas. La vista de una lista es la siguiente:


Inserción de un nuevo nodo El comportamiento es el siguiente:

Tmp = new Nodo();

//Crear un nodo nuevo

Tmp.dato = x;

//Colocar x en el campo dato

Tmp.siguiente = actual.siguiente; //El siguiente al nodo x es b Actual.siguiente = tmp;

//El siguiente al nodo a es x

Eliminación de un nuevo nodo Actual.siguiente = actual.siguiente.siguiente; ; //El anterior enlaza al siguiente al nodo a eliminar, en este caso, x.


Como se puede apreciar en las figuras anteriores el algoritmo necesita realizar cambios en los enlaces para que pueda quedar reflejada la operación correctamente y al listarla se muestren los nodos que realmente tiene. Si bien se pueden almacenar valores primitivos, lo ideal es pensar en que se pueden almacenar objetos de cualquier clase, ya sea una Java, como por ejemplo String o Integer, como una definida por usted en el modelo de resolución del proyecto, como por ejemplo, Persona, Automovil, Producto, entre otros. Nodos auxiliares Para las operaciones de listas enlazadas es necesario utilizar nodos auxiliares: 







Cabecera: también llamado primero, almacena la referencia al primer nodo que almacena un dato. Fin: también llamado último, puede utilizarse de dos formas, una de ellas es que el último nodo con valor almacene la referencia a fin y este almacene el null, que indica que no hay más elementos. Otra forma es que el nodo fin/último almacene la referencia al último nodo de la lista, de esta forma al insertar al último no es necesario recorrer la lista desde el primero al último, optimizando así el tiempo de respuesta del algoritmo. Tmp: también llamado nuevo, almacena la referencia al nuevo nodo. Actual: también llamado aux , es el que se utiliza para recorrer la lista.

Para recorrer la lista utilice siempre un nodo auxiliar que no sea cabeza ni fin, de caso contrario perderá las referencias y no podrá encontrar los nodos de la lista. Lista simplemente enlazada ordenada La lista simplemente enlazada ordenada almacena los datos con un criterio de orden, es por ello que debe conocer ese criterio antes de realizar el algoritmo de inserción. Como las Pilas y Colas, las listas enlazadas utilizan una Interfaz para las operaciones, las básicas son: 

Crear()



Insertar()



Eliminar()




Buscar()



Listar()

También podemos agregar otras que consideremos importantes y necesarias, como por ejemplo: 



esVacia() //para saber si no hay elementos en la lista vaciar() //para volver al estado inicial de vacía

3.2 Comparación de atributos, implementación de métodos de Java Teniendo en cuenta que las listas enlazadas tienen orden lógico distinto al orden físico, o sea se muestran de acuerdo al orden del criterio establecido no por el orden de ingreso en memoria, por ejemplo, si se quiere almacenar los datos de los alumnos ordenados por legajo, es posible que la lista a cargar sea: 10, 23, 4, 15. 







El primer legajo en entrar será el 10. Cuando ingrese el 23 lo compara con el 10, como es mayor se ubica después, quedando 10, 23 Cuando ingresa el 4, lo compara con el 10 y corresponde que es < al primero, por lo que lo ubica delante del 10, quedando: 4, 10, 23. Cuando ingresa el 15 lo compara con 4, no es menor, lo compara con el 23, no es mayor, por lo que está en el medio 4 < 15 < 23. El algoritmo debe buscar el lugar dónde debe insertarlo, quedando: 4, 10, 15, 23.

En este caso, lo estamos ordenando por legajo, si hacemos un algoritmo para este caso no servirá para otra situación distinta, por ejemplo para ordenar clientes por apellido y nombre. Como la programación Orientada a Objetos busca reutilizar el código es importante generalizar estos algoritmos y que sirvan para todos los objetos, para ello tenemos que utilizar los métodos equals() y compareTo() de Java. El método equals() El método equals() permite comparar 2 cadenas o 2 objetos, es una función booleana que nos devuelve true cuando son iguales y false cuando son distintos. Recuerde que este método es de la clase String del package java.lang, por lo tanto no es necesario importar el paquete en el programa.


//equals String s1 = “Hola"; String s2 = “hola";

if (s1.equals(s2)){ // s1 y s2 tinen el mismo contenido, devuelve true } if (s1 == s2) { // compara si s1 y s2 tienen la misma referencia }

El método compareTo() Para comparar dos objetos es posible hacerlo con el método compareTo(), de la clase String del paquete java.lang. Este método permite comparar por igual, mayor y menor valor, devolviendo 0, 1 ó -1 respectivamente. Veamos un ejemplo muy simple: //compareTo(Object object) String s1 = “Hola"; String s2 = “hola";

if (s1.compareTo(s2) > 0) { // s1 es más grande que s2 } else if (s1.compareTo(s2) == 0 { // s1 y s2 son iguales } else // s1 es menor a s2


Teniendo en cuenta su funcionamiento deberíamos conocer dónde se tiene que escribir el método para luego poder usarlo.

Si la comparación de dos cadenas u objetos con equals() devolvió true, la misma comparación con compareTo() tiene que devolver 0 (cero).

¿Qué tenemos que tener en cuenta para usar el método compareTo()? Para usar correctamente el método compareTo() se tiene que tener en cuenta: 





El método lo define en la clase del objeto que tiene el atributo a comparar, por ejemplo si queremos comparar la edad de dos alumnos, en la clase Alumno, que tiene el atributo edad es donde coloca el método. La clase donde define el método debe implementar la interfaz Comparable. La interfaz Comparable puede ser usada la que tiene definida en Java o redefinirla.

Supongamos que tenemos que almacenar Médicos ordenados por código en una lista simplemente enlazada, necesitamos las siguientes clases: 

Médico, clase del modelo



Nodo, para almacenar el objeto Médico y el enlace





ListaSimple, con 2 nodos auxiliares primero y último, además tiene las operaciones ILista, interfaz con las operaciones. Veamos el código del ejemplo:


package modelo; import estructuras.*; @SuppressWarnings("unchecked") public class Medico implements Comparable { private private private private

String Nombre; String Apellido; Integer CodigoDeMedico; Integer NumeroDeMatricula;

public Medico() { } public String getNombre() { return Nombre; } public void setNombre(String nombre) { Nombre = nombre; } //se completa con los getxx() y setXX() de los demás atributos public String toString(){ return "Nombre: " + this.getNombre() + "\nApellido: " + this.getApellido() + "\nCodigo Identificatorio: " + this.getCodigoDeMedico() + "\nNumero De Matricula: " + this.getNumeroDeMatricula(); } //método para comparer el objeto active con el recibido por código de médico, devuelve 0, 1 ó -1 public int compareTo(Object m) { Medico medico = (Medico)m; return this.getCodigoDeMedico().compareTo(medico.getCodigoDeMedico()) } }


package com.estructuras;

public class Nodo { private T dato; //cualquier tipo de valor, private Nodo sig; public Nodo() { this.dato = null; this.sig = null; } public Nodo(T dato) { this.dato = dato; } public Nodo(T dato, Nodo sig) { this.dato = dato; this.sig = sig; } public T getDato() { return dato; } public void setDato(T dato) { this.dato = dato; } public Nodo getSig() { return sig; } public void setSig(Nodo sig) { this.sig = sig; } }


package com.estructuras; public interface ILista {

Vaciar(); public void public void Insertar(Comparable dato); public boolean EsVacia(); public boolean Buscar(Comparable dato); public Object Eliminar(Comparable dato); public String ListarAscendente(); public String ListarDescendente(); }

package com.estructuras; public class Lista implements ILista { private Nodo cabecera; private Nodo ultimo; public Lista () { this .cabecera = null; this .ultimo = null; } public Nodo getCabecera() { return cabecera ; } public void setCabecera(Nodo primero) { this .cabecera = primero; } public Nodo getUltimo() { return ultimo; } setUltimo(Nodo ultimo) { public void this .ultimo = ultimo; } ………………………………………………..

Continuamos con el código de cada operación definida en la Interfaz ILista.

Comprobamos si está vacía con: public boolean EsVacia() { if (this .cabecera == null && this.ultimo == null){ return true ; } return false; }


Vaciamos la Lista con:

Vaciar() { public void this.cabecera = null; this.ultimo = null; }

Listamos de forma ascendente, o sea del primero al último con:

public String ListarAscendente() {

String salida = ""; Nodo auxiliar = this.cabecera; while(auxiliar != null ){ salida += auxiliar.getDato().toString()+ "\n"; auxiliar = auxiliar.getSiguiente(); } return salida;

}

Listamos de forma descendente, o sea del último al primero con:

public String ListarDescendente() { String salida = ""; Nodo auxiliar = this.ultimo; while(auxiliar != null){ salida += auxiliar.getDato().toString()+ "\n"; auxiliar = auxiliar.getAnterior(); } return salida

}


Insertamos un nuevo elemento en la Lista, en este caso un objeto Médico ordenado por código public void Insertar(Comparable dato) {

Nodo nuevo = new Nodo (dato); Nodo auxiliar = this.cabecera; Nodo auxAnterior = this.cabecera; //enlazamos con el único nodo que hay en la lista if(this.EsVacia()){ this.cabecera = nuevo; this.ultimo = nuevo; } //si el nuevo código es menor al que estaba primero else if (nuevo.getDato().compareTo( this .getCabecera().getDato())<0){ //enlaza el nuevo nodo con el que estaba primero nuevo.setSiguiente( this.getCabecera()); //enlaza la cabecera con nuevo para indicar que es el primero this.setCabecera(nuevo); } else //si el nuevo código es mayor al último if (nuevo.getDato().compareTo( this.getUltimo().getDato())> 0){ //enlaza el último con el nuevo this.ultimo.setSiguiente(nuevo); //siguiente del nuevo es Null por ser ahora el último dato nuevo.setSiguiente(null); //enlaza con nuevo para indicar que es el último nodo this.setUltimo(nuevo); } else{ //está en el medio while(auxiliar != null && nuevo.getDato().compareTo(auxiliar.getDato()) > 0){ auxAnterior = auxiliar; auxiliar = auxiliar.getSiguiente(); } //sale del while cuando encuentra su lugar, con auxiliar parado en el que le sigue al nuevo nodo y auxAnterior en el anterior nodo //enlaza el anterior con el nuevo auxAnterior.setSiguiente(nuevo); //enlaza el nuevo con el siguiente nuevo.setSiguiente(auxiliar); } }


Buscamos un médico por código en la lista: public boolean Buscar(Comparable dato) { //declaramos un auxiliar para buscar el dato NodoDoble auxiliar = this .cabecera; boolean salida = false; //recorre la lista while(auxiliar != null){ //compara el código del nodo visitado con el ingresado if(auxiliar.getDato().compareTo(dato) == 0){ salida = true; } auxiliar = auxiliar.getSiguiente(); } return salida; }

Eliminamos un Médico de acuerdo a un código ingresado: public Object Eliminar(Comparable dato) { Nodo auxiliar = this .cabecera; Object salida = null ; if (this .EsVacia()){ Mostrar.mostrar("Lista Vacia"); } else //compara con el primero, si es igual if(dato.compareTo( this.getCabecera().getDato()) == 0){

salida = this .cabecera.getDato(); //cambia cabecera enlazando con el segundo this.cabecera = this.cabecera.getSiguiente(); } else //busca si está en la lista while(auxiliar != null && dato.compareTo(auxiliar.getDato()) != 0){ auxAnterior = auxiliar; auxiliar = auxiliar.getSiguiente(); } If(auxiliar ¡= null){ salida = auxiliar.getDato(); //enlaza el anterior con el siguiente, eliminando el nodo auxAnterior.setSiguiente(auxAnterior.getSiguiente()); } return salida; } }


3.3 Clases Iteradoras Como hemos visto hasta ahora, el comportamiento de las listas requiere de algoritmos que pueden tener estructuras repetitivas en su interior, como lo son el buscar() y listar(). Las clases iteradoras simplifica el problema que se puede presentar cuando en la clase Lista se está accediendo a los nodos, puede ser que otro método lo acceda con un auxiliar con lo cual podemos perder la referencia o estar visitando un nodo equivocado. En este caso la posición de la lista en la que se encontraría sería dado por la clase iteradora, manteniendo la noción de la posición actual y el nodo cabecera puede ser inicializado por el constructor. Es necesario que la clase iteradora pertenezca al mismo paquete que la lista, o sea que esté en el package estructuras. Cada instancia de la clase iteradora da el marco que permite solamente las operaciones legales sobre la lista como, por ejemplo avanzar. La clase iteradora requiere de su Interfaz, por lo que estamos agregando una clase y una interfaz a nuestro esquema anterior. Se incorporan nuevos métodos, tales como: 



estaDentro(), que refleja que lo encuentra. Avanzar(), permite que el auxiliar avance secuencialmente



Primero(), coloca el auxiliar en la primera posición.



Recuperar(), elemento en la posición actual.

Veamos los cambios necesarios en la clase Lista y en la interfaz ILista package com.estructuras; public interface ILista{

//public void eliminar(Object x); lo sacamos de la interfaz //public void listarAs();lo sacamos de la interfaz //public void listarDes();lo sacamos de la interfaz //public boolean buscar(T x); lo sacamos de la interfaz public Boolean esVacia(); public void vaciar();

}


package com.estructuras; public class Lista implements ILista { private Nodo cabecera; private Nodo fin; //puede no usarse

public Lista() {

cabecera = new Nodo(null); } Public boolean esVacia() { Return cabecera.siguinete = null } Public void vaciar(){ Cabecera.siguiente = null; } …. }

Necesitamos la Interfaz de la Lista Iteradora, podría tener las siguientes operaciones: package com.estructuras; import java.Exception.*; public interface IListaIter

{

void inserter(Comparable x); void eliminar(Comparable x); boolean buscar(Comparable x); void primero(); void avanzar(); Boolean estaDentro(); Object recuperar();

La clase ListaIteradora implementa la interfaz y define los métodos, en nuestro caso, solo colocamos la cabecera que es:


package com.estructuras; import java.exception.*; public class ListaEnlazadaIter implements IListaIter { ………………………….

}

3.4 Listas doblemente enlazadas y listas circulares Listas doblemente enlazada Las estructuras de datos Listas doblemente enlazadas tienen un comportamiento idéntico a las simplemente enlazadas. Si están ordenadas su orden físico es distinto al orden lógico. Se diferencian en: 



que utilizan un nodo con dos enlaces, ya que guarda las direcciones del anterior y del siguiente nodo. Se pueden listar del primero al último y del último al primero.

Si bien ocupan más memoria por tener un enlace más, es conveniente utilizarla cuando se requiere su listado descendente. En cuanto al algoritmo tenemos que recordar que tenemos un enlace más para actualizar en cada operación. Veamos los primeros casos, cuando está vacía y la creamos con el primer elemento:


Si insertamos tenemos que tener presente los 3 casos vistos anteriormente: 

Menor que el primero:



Mayor que el último:

nuevo.ant = último nuevo.sig = NULL último.sig = nuevo último = nuevo




Inserción al medio:

El mismo criterio se lleva a cabo para eliminar un elemento en la lista, puede ser el primero, el último o uno del medio. Veamos gráficamente estas operaciones: 

Elimina el primero:




Elimina el último:

Los boolean, no aceptan ningún casting, mientras que el casting de char a byte o short, puede dar un negativo, ya que char no contempla el signo.



Elimina uno del medio:

Listas circulares Las listas enlazadas circulares pueden ser simplemente enlazadas o doblemente enlazadas, ambas tienen la característica de no tener nulos en los nodos de los extremos. En las listas simplemente enlazadas, el último nodo enlaza con el primero. En las listas doblemente enlazadas el primero enlaza con el último nodo y el último enlaza con el primero.


Recordemos entonces:





La referencia siguiente del último nodo apunta al primero En general no tienen nodo cabecera 

Se mantiene una referencia al primer nodo



Se pueden usar simultáneamente listas circulares con listas doblemente enlazadas



Son útiles cuando queremos hacer búsquedas que permitan circularidad

Ej Editores de textoUna de las características importantes de las estructuras de datos es la reutilización.

Su gráfica sería:

El código que cambia cuando inserta es el siguiente:

//Inserta primero Nvo.anterior = ultimo; Nvo.siguiente = cabecera; Cabecera.anterior = nuevo; Ultimo.siguiente = nvo //Inserta al último Ultimo.siguiente = nvo; Nvo.anterior = ultimo; Nvo.siguiente = cabecera; Cabecera.anterior = nvo;


El código que cambia cuando elimina es el siguiente:

//Elimina el primero Cabecera.siguiente.anterior = cabecera.anterior ; Cabecera = cabecera.siguiente; Cabecera.anterior = ultimo; //Elimina al último Ultimo.anterior.siguiente = cabecera; Ultimo = ultimo.anterior; Cabecera.anterior = ultimo;

3.5 Implementación Una vez que aprendimos las características de las estructuras de datos Listas enlazadas, simples, dobles y circulares con el uso de las Interfaces necesarias para las operaciones, estamos en condiciones de poder hacer un ejercicio con Listas doblemente enlazadas con clases Iteradoras. Hay situaciones en las que es necesario relacionar más de una estructura para resolverla. Veamos el siguiente caso: Una Clínica almacena los datos de los pacientes que van llegando a los turnos por orden de llegada en una cola por médico. Como son varios los médicos que atienden en un mismo horario, organiza los datos de los médicos en una lista doblemente enlazada, ordenada por código de médico. Datos del nodo de la Cola: Objeto paciente sig de la cola

Datos del nodo de la Lista: Objeto médico Sig de la lista

Objeto Paciente: Nro. De Historia clínica Apellido y nombre Dni


Objeto Médico: Código de médico Nro. De matrícula Apellido y nombre Cola de pacientes Es necesario diseñar las clases del modelo y utilizar las c lases del package modelo como librería, o sea si logró que fuesen generales para cualquier objeto no se deberían modificar, solo reusar. Efectuar las siguientes operaciones para N pacientes y N médicos: Ingresar los datos de los médicos en la lista. Cuando llega un paciente buscar el médico en la lista y cargar los datos en la cola. Ingresando un código de médico, mostrar todos los pacientes que tiene en cola de espera.


Diagrama de las clases para Lista Doble

Diagrama para la estructura Cola


Clases del modelo: Médico y Paciente

package modelo; import estructuras.*; public class Medico implements Comparable { private String Nombre; private String Apellido; private Integer CodigoDeMedico; private Integer NumeroDeMatricula; private Cola c; //estructura Cola como atributo public Medico() { } public Medico(String nombre, String apellido, Integer codigoDeMedico, Integer numeroDeMatricula, Cola c) { Nombre = nombre; Apellido = apellido; CodigoDeMedico = codigoDeMedico; NumeroDeMatricula = numeroDeMatricula; Es importante this .c = c; que repase también las sentencias }repetitivas for , while y do … while utilizándolos en la

programación.

public String getNombre() { return Nombre; } public void setNombre(String nombre) { Nombre = nombre; }

……//demás getxx() y s etxx() public Cola getCola() { return c; } public void setCola(Cola c) { this.c = c; } public String toString(){ return "Nombre: " + this.getNombre() + "\nApellido: " + this.getApellido() + "\nCodigo Identificatorio: " + this .getCodigoDeMedico() + "\nNumero De Matricula: " + this .getNumeroDeMatricula(); } //método para comparer los medicos por código public int compareTo(Object m) { Medico medico = (Medico)m; if(this.getCodigoDeMedico().compareTo(medico.getCodi goDeMedico()) == 0){ } return this.getCodigoDeMedico(); }


Clase Paciente: package modelo; public class Paciente implements Comparable { private String Nombre; private String Apellido; private Integer NumeroDeHistoriaClinica; private Integer Dni; public Paciente() { } public Paciente(String nombre, String apellido, Integer numeroDeHistoriaClinica, Integer dni) { Nombre = nombre; Apellido = apellido; NumeroDeHistoriaClinica = numeroDeHistoriaClinica; Dni = dni; } public String getNombre() { return Nombre; } public void setNombre(String nombre) { Nombre = nombre; } public String toString(){ return "Nombre: " + this .getNombre() + "\nApellido: " + this.getApellido() + "\nNumero De Historia Clinica: " + this .getNumeroDeHistoriaClinica() + "\nDni: " + this.getDni(); } //método para comparer a completer con el atributo necesario public int compareTo(Object o) { return 0; } }


Código del Nodo simple:

package com.estructuras; public class Nodo { private T dato; //cualquier tipo de valor, private Nodo sig; public Nodo() { this .dato = null; this .sig = null; } public T getDato() { return dato; }

setDato(T dato) { public void this .dato = dato; } public Nodo getSig() { return sig; } public void setSig(Nodo sig) { this .sig = sig; } public Nodo(T dato) { this .dato = dato; } public Nodo(T dato, Nodo sig) { this .dato = dato; this .sig = sig; }

}


Interfaz para la estructura Cola:

package com.estructuras; public interface ICola { public int tamanyo(); public boolean isVacia(); public void vaciar(); insertar(Object dato); public void public Object primero(); public void listar(); Object quitarPrimero(); public public void buscar(Object dato); public Object buscarO(Object dato);

}

Estructura Cola: package com.estructuras; public class ColaEnlazada implements ICola { private Nodo primero; private Nodo ultimo; private int tamanyo; public ColaEnlazada() { this.primero = null ; this.ultimo = null ; this.tamanyo = 0; }

….. //getxx() y setxx() necesarios

Operaciones public boolean isVacia() { return (primero== null ); } public void vaciar() { primero= null ; ultimo= null ; }

//inserta un Nuevo elemento insertar(Object dato) { public void if (dato!= null ) { Nodo nuevo = new Nodo(dato, null ); tamanyo++; if (isVacia()) { this .primero=nuevo; } else { ultimo.setSig(nuevo); } ultimo=nuevo; } }


//retorna el primer dato public Object primero() { if(isVacia()) return null ; return (primero.getDato()); } public Object quitarPrimero() { Object dato = null ; if (!isVacia()) { tamanyo--;

dato = primero.getDato(); primero=primero.getSig(); if (primero == null) { ultimo = null; }

} return dato; }

public void listar() { if(isVacia()) return ; Nodo aux = this.primero; while(aux!=null) {

System. out.println(aux.getDato().toString()); aux = aux.getSig(); } } //busca un dato con equals() public void buscar(Object dato) { if(isVacia()) return ; int cont=1; Nodo aux = primero.getSig(); while ((aux!= null ) && !(aux.getDato().equals(dato))) { cont++; aux=aux.getSig(); } if (aux== null ) System.out.println("No se encontro"); else System.out.println("Se encontro " + aux.getDato().toString() + " en el nodo nº: " + cont);

}


//busca un objeto y lo retorna public Object buscarO(Object dato) { Nodo aux = primero.getSig(); while ((aux!= null )&& !(aux.getDato().equals(dato))) { aux=aux.getSig(); } if(aux!= null ) return aux.getDato(); return null;

} }

Nodo doble: package com.estructuras; public class NodoDoble{ private T dato;//cualquier tipo de valor, private NodoDoble sig; private NodoDoble ant; public NodoDoble() { this.dato = null ; this.sig = null; this.ant = null; } public NodoDoble(T dato) { this.dato = dato; } public NodoDoble(T dato, NodoDoble sig) { this.dato = dato; this.sig = sig; } public NodoDoble(T dato, NodoDoble sig, NodoDoble ant)

{ this.dato = dato; this.sig = sig; this.ant = ant;

} //con sus getxx() y setxx()


Interfaz de la lista: package com.estructuras; public interface IListaDoble{ public Boolean esVacia();

vaciar(); public void listarAscendente(); public void listarDescendente(); public void }

Interfaz de la Lista Iteradora:

package com.estructuras; import com.exception.ElementoNoEncontradoException; public interface IListaIter { //declara dos constants para los mensajes static final String MSJ_NO_ENCONTRADO ="Elemento no encontrado"; static final String MSJ_FALLO_ELIMINACION ="Fallo eliminacion elemento no encontrado"; public void imprimir(); void insertarOrdenado(T dato); void insertar (T x,T y) throws ElementoNoEncontradoException;

avanzar(); void boolean estaDentro();

T recuperar(); void primero(); boolean buscar (T x); void eliminar (T x) throws ElementoNoEncontradoException;

}


Código de la Listadoblemente enlazada: package com.estructuras; public class ListaDoble implements IListaDoble { private NodoDoble cab; private NodoDoble fin; public ListaDoble () { cab = null; fin = null; } public NodoDoble getCabecera () { return this.cab; } public NodoDoble getFin () { return this.fin; }

public Boolean esVacia () { return (this .cab == null); }

vaciar () { public void this.cab = null; this.fin = null; } //métodos para insertar ordenado que son llamados desde la ListaIter insertar (T dato) { public void NodoDoble nvo = new NodoDoble (dato); this.cab = nvo; this.fin = nvo; } public void insertarPrimero (T dato) { if ( esVacia() ) this.cab = this .fin = new NodoDoble (dato); else { NodoDoble nvo = new NodoDoble (dato); nvo.setSig(cab); nvo.setAnt( null ); nvo.getSig().setAnt(nvo); this.cab = nvo; } }

insertarUltimo (T dato) { public void if ( esVacia() ) this.cab = this .fin = new NodoDoble (dato); else { NodoDoble nvo = new NodoDoble (dato); nvo.setSig( null ); nvo.setAnt( this .fin); nvo.getAnt().setSig(nvo); this.fin = nvo; } }


//métodos para eliminar llamados desde ListaIter public void eliminarPrimero() { this .cab = this .cab.getSig(); this .cab.setAnt( null); } public void eliminarUltimo() { this .fin = this .fin.getAnt(); this .fin.setSig( null); }

//Elimina el nodo que se encuentra en el medio, entre dos Nodos public void eliminarMedio (NodoDoble auxSig, NodoDoble auxAnt) { auxAnt.setSig(auxSig); auxSig.setAnt(auxAnt);

auxSig.getAnt().setAnt( null); auxAnt.getSig().setSig( null); } // Elimina el nodo que se le pasa por parametro, cuando el mismo se encuentra en el medio, entre dos Nodos public void eliminarMedio (NodoDoble nodoAEliminar) { nodoAEliminar.getAnt().setSig(nodoAEliminar.getSig()); nodoAEliminar.getSig().setAnt(nodoAEliminar.getAnt());

nodoAEliminar.setAnt( null); nodoAEliminar.setSig( null); } //Lista del primero al último listarAscendente() { public void if (this .esVacia()) { System.out.println ("La lista está vacía."); } NodoDoble aux = this.getCabecera(); while (aux != null) { System.out.println (aux.getDato().toString()); aux = aux.getSig(); } } //Lista del ultimo al primero public void listarDescendente() { if (this .esVacia()) { System.out.println ("La lista está vacía."); return ; } NodoDoble aux = this.getFin(); while (aux != null) { System.out.println (aux.getDato().toString()); aux = aux.getAnt(); } System.out.println( "\n" ); } }


Código de la clase Lista Iteradora: package com.estructuras; import com.exception.ElementoNoEncontradoException; //o java.exception public class ListaEnlazadaIter implements IListaIter { protected ListaDoble laLista; NodoDoble actual; protected //constructor de la clase public ListaEnlazadaIter(ListaDoble unaLista) { laLista=unaLista;

actual=laLista.esVacia()?unaLista.getCabecera():unaLista.getCab ecera().getSig(); } public NodoDoble getActual() { return actual; } public void setActual(NodoDoble actual) { this.actual = actual; }

//método para listar los elementos imprimir() { public void if (laLista.esVacia()) { System.out.println("Es Vacia"); return; } //método para listar los elementos imprimir() { public void if (laLista.esVacia()) { System.out.println("Es Vacia"); return; } NodoDoble aux = laLista.getCabecera(); while (aux != null) { System.out.println (aux.getDato()); aux = aux.getSig(); }

System.out.println( "\n" ); } //método para insertar insertar (T x,T y) throws ElementoNoEncontradoException public void { //controla que no esté el elemento en la lista if(!this .buscar(x)) new ElementoNoEncontradoException( MSJ_NO_ENCONTRADO ); this.insertar(x); //llama a insertar() }


//inserta un elemento en la lista enlazada no ordenada insertar (T x) throws ElementoNoEncontradoException public void { NodoDoble nuevoNodo= new NodoDoble(x); if (laLista.esVacia()) { laLista.insertarPrimero(x); } else { laLista.insertarUltimo(x); } actual=nuevoNodo; } public void avanzar() { //método para avanzar en el recorrido if(actual!=null ) { actual=actual.getSig(); } } public boolean estaDentro() { //devuelve verdadero si lo encuentra return actual!= null && actual!=laLista.getCabecera(); } public T recuperar() { //devuelve el elemento encontrado return estaDentro()?actual.getDato(): null; }

primero() { public void actual=laLista.getCabecera(); }

// devuelve el primero

public boolean buscar (T x) { //busca un objeto y devuelve True si lo encuentra NodoDoble itr = laLista.getCabecera(); while (itr!= null && ((Comparable)itr.getDato()).compareTo(x)!=0) itr=itr.getSig(); if (itr!= null) { actual=itr; return true; } return false;

} //busca un objeto y devuelve el objeto si lo encuentra { public Object buscarO (T x) NodoDoble itr = laLista.getCabecera(); while (itr!= null && ((Comparable)itr.getDato()).compareTo(x)!=0) itr=itr.getSig(); if (itr!= null) { actual=itr; return itr.getDato(); } return null; }


//método para inserter ordenado public void insertarOrdenado(T dato) { if (dato!= null ) { if (laLista.esVacia()) { //si no hay datos llama a inserter primero NodoDoble nuevoNodo= new NodoDoble(dato); actual=nuevoNodo; laLista.insertarPrimero(dato); return; } else { NodoDoble nodoAux = laLista.getCabecera(); //busca el lugar que debe ocupar y llama al método que lo hace, insertarPrimero(), insertarMedio() o insertarUltimo()de la clase ListaDoble while (nodoAux!= null) { if((((Comparable) dato).compareTo(nodoAux.getDato())) < 0) { if(nodoAux.getAnt()!=null) { laLista.insertarMedio(nodoAux, nodoAux.getAnt(), dato); return ; } else { laLista.insertarPrimero(dato); return ;

} } else if (((Comparable) dato).compareTo(nodoAux.getDato()) == 0) { if(nodoAux.getAnt()!= null) { laLista.insertarMedio(nodoAux, nodoAux.getAnt(), dato); return ; } else { laLista.insertarPrimero(dato); return ; } } nodoAux = nodoAux.getSig(); } laLista.insertarUltimo(dato); } } }


//método para eliminar eliminar (T x) throws ElementoNoEncontradoException { public void NodoDoble itr = laLista.getCabecera(); while (itr!= null && ((Comparable)itr.getDato()).compareTo(x)!=0) itr=itr.getSig(); // Si encontro el dato procedo a eliminarlo if(itr!= null ) { // En caso que la lista este compuesto por un solo nodo Elimino la lista if (itr.getAnt() == null && itr.getSig() == null) { laLista.vaciar(); } else { //Esta al Principio de la Lista if (itr.getAnt() == null) { laLista.eliminarPrimero(); return ; //Esta al Final de la Lista } else if (itr.getSig() == null ) { laLista.eliminarUltimo(); return ; // Esta en Medio de la Lista } else { laLista.eliminarMedio(itr.getSig(), itr.getAnt()); //laLista.eliminarMedio(itr); } } } } }


Conclusión Con lo visto en esta unidad usted está en condiciones de plantear el diseño de clases y la codificación organizada en paquetes de dichas clases. En el planteo de solución de un caso deberá ver en qué estructuras de datos almacenará los objetos, para ello tiene las estructuras estáticas como las colecciones de arreglos o las estructuras dinámicas lineales como Pila, Cola, Listas enlazadas. Dependiendo de cómo deba tratar los datos almacenados está en condiciones de poder elegir la estructura que más le convenga utilizar. Recuerde siempre tratar de diseñar código reutilizable y tener sus propias librerías, las cuales podrá utilizar en distintos proyectos. Espero que le haya sido de utilidad lo aprendido en este módulo.


Lectura 3 - Listas Enlazadas

Recommend Documents