Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Párraga

Apunte Resumen- sobre Estructuras Dinámicas Bibliografía : java 2 – Javier Ceballos Sierra Apuntes de clases Realizado por : Adriana Párraga 2007 ESTRUCTURAS DINÁMICAS La principal característica de las estructuras dinámicas es la facultad que tienen para variar su tamaño, realizando asignaciones dinámicas para las componentes individuales, al tiempo que son creadas durante la ejecución del programa.Cuando se trabaja con estructuras dinámicas, el compilador asigna una cantidad fija de memoria para mantener la dirección del componente asignado dinámicamente, en vez de hacer una asignación para el componente en sí. Esto implica que debe haber una clara distinción entre datos y referencias a datos, y que consecuentemente se deben emplear tipos de datos cuyos valores sean referencias a otros datos.Cuando se asigna memoria dinámicamente para un objeto de un tipo cualquiera, se devuelve una referencia a la zona de memoria asignada. Para realizar esta operación disponemos en Java del operador new .Dentro de las estructuras dinámicas, podemos encontrar: Listas( listas simplemente enlazadas,, listas circulares, listas doblemente enlazadas, Pilas, Colas), Árboles Binarios y Grafos.-

Listas Lineales
Una Lista lineal es una colección, originalmente vacía, de elementos u objetos de cualquier tipo no necesariamente consecutivos en memoria, que durante la ejecución del programa pueden crecer o decrecer elemento a elemento según las necesidades previstas en el mismo.¿Cómo pasamos desde un elemento al siguiente cuando recorramos la lista? Cada elemento debe almacenar información de dónde está el siguiente elemento o el anterior, o bien ambos. En función de la información que cada elemento de la lista almacene respecto a la localización de sus antecesores y/o predecesores, las listas pueden clasificarse en : a) listas simplemente enlazadas o vinculadas b) listas circulares c) listas doblemente enlazadas d) listas circulares doblemente enlazadas.a) LISTAS LINEALES SIMPLEMENTE ENLAZADAS O VINCULADAS Es una colección de objetos (elementos de la lista), cada uno de los cuales contiene datos o una referencia a los datos, y una referencia al siguiente objeto en la colección (elemento de la lista). Gráficamente puede representarse de la siguiente forma: p Nodo

Nodo prox;

Nodo prox;

Nodo prox;

null;

Página 1 de 32

Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Párraga

Para construir una lista lineal, primero tendremos que definir el tipo de los elementos que van a formar parte de la misma. Por ejemplo, cada elemento de la lista puede definirse como la estructura de datos con dos miembros: una referencia al elemento siguiente y una referencia al área de datos. El área de datos puede ser de un tipo predefinido o de un tipo definido por el usuario. Según esto, el tipo de cada elemento de una lista puede venir definido de la forma siguiente: Class Nodo //o si es definido por el usuario { // atributos … private int x; private Nodo prox; // métodos public Nodo () // contructor por defecto { x = 0; prox = null;} //…………….. class Nodo { private Dato d; private Nodo prox ; // métodos public Nodo() {} ……….

Se puede observar que la clase Nodo definirá una serie de atributos correspondientes a los datos que deseamos manipular, además de un atributo especial, denominado prox, para permitir que cada elemento pueda referenciar a su sucesor formando así una lista enlazada (notar que el elemento prox es tipo Nodo) .Una vez creada la clase de objetos Nodo la asignación de memoria para un elemento se haría así: public class Principal { public static void main (String [] args) { Nodo n; // referencia a un elemento de la clase Nodo n = new Nodo(); // asignar memoria para un elemento Nodo, genera una // referencia y asigna la referencia a la variable n

// este elemento no tiene sucesor n.prox = null; // indica de esta manera que después de este elemento no hay otro // operaciones cualesquiera…..

Página 2 de 32

Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Párraga

n = null; // permitir que se libere la memoria ocupada por el elemento n } } // fin Principal El valor null referencia nula, permite crear estructuras de datos finitas. Así mismo suponiendo que n hace referencia al principio de la lista, diremos que dicha lista está vacía si n vale null. Por ejemplo después de ejecutar las sentencias: n = null; // lista vacía n = new Nodo(); // elemento n n.prox =null; //no hay siguiente elemento Tenemos una lista de un elemento: n null

Nodo prox;

para añadir un nuevo elemento a la lista, procedemos así: q = new Nodo(); // creamos un nuevo elemento q.prox = p; // almacena la localización del elemento siguiente n = q; // n hace referencia al principio de la lista Donde q es una referencia a un objeto de tipo Nodo. Ahora tenemos una lista de dos elementos. Observe que los elementos nuevos se añaden al principio de la lista. n q

Nodo prox;

q.prox

Nodo prox;

null

Nota: Cuando en una lista utilizamos una referencia para ir de un elemento al siguiente, podemos decir que llegamos al final de la lista cuando la referencia toma el valor null.Operaciones Básicas Las operaciones que podemos realiza con una lista incluyen fundamentalmente las siguientes: 1- Insertar un elemento en una lista. Página 3 de 32

q. p = q.} public Nodo (int d) // contructor con parametro { dato = d. prox = null. 1.Inserción de un elemento a) Al comienzo de la lista q = new Nodo(). prox = p . en Sistemas de Curso 1k15 Prof.} //……………. Nodo p) // contructor con parametro { dato = d. q. public class Principal { public static void main (String [] args) { Nodo p.Buscar un elemento en una lista.Mostrar todos los elemento de la lista.Recorrer los elementos de una lista.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.} public Nodo (int d.. prox = null.- Partiendo de las definiciones : Class Nodo { // atributos private int dato. private Nodo prox. Y el resultado es q p x x x x Página 4 de 32 .dato = x .r . // metodos …… public Nodo () // contructor por defecto { dato = 0. // referencia a elementos de la clase Nodo Int x = In.q. Párraga 23456- Borrar un elemento de una lista Borrar todos los elementos de una lista. el orden en el que se realizan estas operaciones es esencial. ………… } } // fin class Principal Vamos a exponer como se realizan cada una de las operaciones básicas.prox = p.readInt().

es necesario poder recorrer la misma.getProx() != null) // recorro la lista hasta encontrar el último { aux = aux. en Sistemas de Curso 1k15 Prof. hasta encontrar el último elemento. o a la clase que contiene la lista./** * metodo que permite agregar un nodo al final de la lista */ public void insertarFinal( int y) { Nodo q = new Nodo(y) .getProx(). while ( aux. Párraga null es decir que partiendo de una lista vacía. no tenemos más que repetir la operación de insertar un elemento al comienzo de una lista.Notar que el orden de los elementos en la lista es inverso en el que han llegado. y recién allí realizar la unión.Si realizamos un método podría ser así: /** * metodo que permite agregar un nodo al principio de la lista */ public void insertarAdelante (int y) { Nodo q = new Nodo (y) .b) Inserción al final de la lista Si se desea insertar al final de la lista. else { Nodo aux = p.setProx(p). else { q. } } Siendo este método perteneciente a la clase Principal. Página 5 de 32 .Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. tantas veces como elementos deseemos que tenga dicha lista. if (p == null) p = q. p= q. // constructor con parámetro if (p == null) p = q.

Párraga } aux.setProx(q). Nodo q = new Nodo ( y) . res = true.tamano(). // cuenta que hay un nodo mas q = q. int pos) { boolean res = false. a continuación de otro elemento * * cualquiera por ejemplo en la posición pos * * retorna verdadero si se puede realizar el agregado a la lista */ public boolean insertarGeneral( int y. // se corre al próximo nodo de la lista } return res.insertarAdelante (y). while (q != null) { res++. // referencia el prox del último hacia el nuevo elemento q. en Sistemas de Curso 1k15 Prof. Nodo q = p.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.// crea un elemento a agregar int nroElementos = this. } }// fin método c) inserción general Cuando se necesita insertar un nuevo elemento en un lugar específico avisado por teclado. // elemento auxiliar que permite moverme en la lista Página 6 de 32 .getProx(). // llama al método que calcula el tamaño if (nroElementos == 0) { p = q. se podría utilizar un método similar al siguiente: /** * metodo para calcular cantidad de elementos de la lista */ public int tamano() { int res = 0.setProx(null). else {if (pos < nroElementos && pos> 1) { // añade un elemento en la posición pos Nodo elemAct = p. } else { if( pos == 1) this. } /** * * inserción de un elemento en la lista.

} // se mueve con las dos referencias auxiliares. i < pos. Párraga Nodo elemAnt = p.setProx(q). y lo inserte en forma ordenada. en Sistemas de Curso 1k15 Prof. se realiza la inserción q.// conecto la referencia de q al elemento actual elemAnt. // crea un elemento a agregar y le pasa la dirección de p // para realizar el enganche adelante p = q. Para ello es posible realizar un método que reciba como parámetros al nuevo elemento o sus datos. // sirve para guardar la posición anterior for ( int i= 1. // sirve para guardar la posición anterior // recorro la lista.getDato()< y) Página 7 de 32 . mientras el valor del dato sea menor que el nuevo y while ( elemAct != null && elemAct. hasta encontrar la pos // requerida una vez encontrada la pos.getDato()) { Nodo q = new Nodo(y.getProx(). } else { Nodo q = new Nodo(y) . elemAct = elemAct.setProx(elemAct). Ejemplo /** * inserción ordenada de elementos de una lista * en forma ascendente */ public void insertarOrdenado( int y) { // se fija si la lista está vacía o el dato es menor al del primer elemento if (p == null || y < p. p) . // crea un elemento a agregar Nodo elemAct = p. i ++) { elemAnt = elemAct. } return res. } //fin metodo d) Inserción Ordenada según un dato determinado Hay veces que se desea los elementos de la lista ordenados según algún dato especifico. // elemento auxiliar que permite moverme en la lista Nodo elemAnt = p. //conecto el elemento anterior a q } } res = true.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.

en Sistemas de Curso 1k15 Prof. Párraga { elemAnt = elemAct.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.Solo cuando se eliminan todas las referencias que permiten acceder a un elemento.setProx(elemAct). se realiza la inserción if (elemAct == null) elemAnt.referencia a null el elemento a borrar.. elemAct = elemAct.referenciar el prox del elemento anterior al prox. } // se mueve con las dos referencias auxiliares.getDato() == cod) { Nodo aux = p. del elemento a borrar. es decir le borra la referencia.. y puede ser recolectado por el recolector de basura de java. pero sin perder la información del elemento anterior. //conecto el elemento anterior a q } } }// fin método 2) Borrar un elemento de una lista Para borrar el sucesor de un elemento referenciado por r. if (p != null) { // primero controlamos que el dato buscado no se encuentre en el primer nodo if(p. hasta encontrar la pos requerida // una vez encontrada la pos.setProx(q).getProx().setProx(q).Podemos encontrarnos con tres situaciones: a) borrar cualquier elemento b) Borrar el primer elemento de la lista c) Borrar el ultimo elemento de la lista a) Borra el primer elemento que encuentra con el valor dado por parámetro /** * método que permite encontrar un elemento y borrarlo de la lista */ public boolean borrarUno( int cod) { boolean r = false. las operaciones a realizar son las siguientes: .. de esta forma se borran todas las referencias que existían hacia ese elemento. ese objeto es enviado al recolector de basura.// conecto la referencia de q al elemento actual elemAnt.copiar el elemento a borrar en un aux. // agrega al final de la lista else { q.primero recorrer la lista. Página 8 de 32 . hasta ubicar el elemento a borrar.

if (p != null) { Nodo aux = p.getProx(). porque si no lanzaría una excepción NullPointerExcepción while ( posAct.getDato() !=cod) { posAnt = posAct. posAct = null. Nodo posAct = p. } return r.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.getProx()). aux = null. } else { Nodo posAnt = p. }// fin método b) Siempre borra el primer elemento de la lista /** * Metodo para borrar el primer elemento */ public boolean borrarPri() { boolean r = false. } if (posAct. } } //fin else }// fin if grande return r. r = true.setProx(posAct. p = p. Párraga p = p. en Sistemas de Curso 1k15 Prof. // primero debe evaluarse si el nodo es null.getProx(). posAct = posAct. } // fin metodo borrarpri c) Siempre borra el último elemento de la lista /** * metodo que permite borrar el ultimo elemento de una lista Página 9 de 32 .getProx(). //y luego la otra condición.getDato() == cod) { posAnt. r = true. aux = null.getProx() != null && posAct.

Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.getProx() != null) { posAnt = posAct. }// fin método 3. aux = null. porque si no lanzaría una excepción NullPointerExcepción while ( posAct != null && posAct.setProx( null). } } // fin metodo 4 . while (aux != null) { p= p. }// fin if Grande return r. en Sistemas de Curso 1k15 Prof.getProx().Borrar todos los elementos de la lista /** * método que permite borrar todos los elementos de la lista */ public void borrarTodo() { Nodo aux= p. //y luego la otra condición. posAct = posAct. Párraga * */ public boolean borrarUltimo() { boolean r = false. posAct = null. r = true.getProx(). // primero debe evaluarse si el nodo es null. } posAnt. Nodo posAct = p. if (p != null) { // primero controlamos que la lista tenga datos Nodo posAnt = p. aux = p.búsqueda de un elemento en particular Página 10 de 32 .

if (p != null) { while ( aux != null) { if( aux. Siempre que se desea recorrer la lista.getDato() == cod) res = "\t los datos del número solicitado son : "+ aux. } 6.getProx(). Nodo aux = p. if( aux != null&& aux./** * método que busca un elemento y lo muestra */ public String mostrarDato( int cod) { String res ="\n no existe el dato con codigo : " + cod. sin perder la referencia del primero./** *Método para mostrar todos los elementos de la lista Página 11 de 32 . } /** * método que busca un determinado valor en la lista y dice cuantas veces lo encontró */ public int cantidadDato( int cod) { int cant =0. getDato()== cod) cant++. se deberá crear un elemento auxiliar para poder moverse entre los elementos de la lista hasta encontrar el deseado. Nodo aux = p. en Sistemas de Curso 1k15 Prof.Mostrar todos los elemento de la lista. Párraga En este tipo de métodos se deberá recibir un dato que permita establecer el elemento a buscar.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. if (p != null) { while ( aux != null && aux. } } return cant. aux = aux. } return res +"\n\n". getDato() != cod) aux = aux.getDato() .getProx().

} return r .Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. ". }// fin método Página 12 de 32 . aux= aux.getProx(). Nodo aux = p.getDato()+". while (aux !=null) { r += aux. Párraga */ public String toString() { String r ="". en Sistemas de Curso 1k15 Prof.

último en entrar primero en salir .Estructura de tipo LIFO (Last Input . Es decir que solo se puede acceder por un único lugar o extremo. el último que incluimos. en Sistemas de Curso 1k15 Prof. Es decir que para la construcción de una pila hay que respetar ciertas reglas de acceso. ¿Cómo se hace para acceder a un elemento que no se encuentre el principio o cima de la pila? Se puede implementar sobre un vector o sobre una lista. “el ultimo en entrar es el primero en salir”.First Output). las incluimos y luego excluimos dos de ellas. y acceder al elemento buscado. Los elementos de la pila se añaden siempre al principio.Una pila (stack) es una colección ordenada de elementos y se quitan (borran) de la misma sólo por su parte superior (cima). Supongamos que tenemos las letras 'A'. Párraga e) PILAS Estas son listas que se destacan por la forma de acceso que se les exige en su uso. o sea en orden inverso al que los incluimos. Página 13 de 32 . necesariamente 'C' Y 'B'. Al operarse únicamente por la parte superior de la pila. 'B' y 'C'. al excluir elementos retiramos el que está en la cima. de forma tal de no romper el orden de ingreso de la pila. Si repetimos esta operación retiraremos el penúltimo. Insertar y Excluir son las únicas operaciones lícitas (posibles) en una pila.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. Gráficamente: C B A C A B C B A La operación de Insertar sitúa un elemento dado en la cima de la pila y Excluir lo elimina o quita. el antepenúltimo. Entonces.

Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. cabeza es el índice del último casillero ocupado. en listas dinámicas o en archivos. si tenemos 'A'. 'C' "apiladas": C Cabeza B A C B C A C b) Usando Array cabeza C B C A a) La pila Conceptualmente c) Usando nodos vinculados b) Implementación en vectores En la implementación con vectores. Es simple. (o del primero disponible). 'B'. Por consiguiente la inserción y extracción de los elementos de la pila (que deben ser por el final de la pila) se realizarán siempre por la primera posición de la lista. v[1] = B . IMPLEMENTACION EN LISTAS ENLAZADAS Analizaremos una de las formas de Implementar una pila sobre una lista: Se considera el último elemento de la pila como el primero de la lista. o pequeño. en Sistemas de Curso 1k15 Prof. los métodos para inserción y extracción. v[0] = A . Párraga Se pueden implementar pilas en arrays. Gráficamente. v[2] = C. Raíz Primer nodo de la lista Ultimo elemento de la pila NULL Ultimo nodo Primer elemento de la lista de la pila En este caso. pero tiene el inconveniente de soportar una estructura típicamente dinámica (la pila) con una estática (el vector): El vector puede ser demasiado grande. según los vistos serían: Página 14 de 32 .

p = p.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.getProx(). } } /** * Metodo para borrar el primer elemento */ public boolean sacarDePila() // metodo borrarpri de la lista { boolean r = false. if (p != null) { Nodo aux = p. // constructor con parametro if (p == null) p = q.setProx(p). // la dirección del primer elemento de la pila /** * Constructor for objects of class Pila */ public Pila() { p = null. r = true. } // fin metodo borrarpri Página 15 de 32 . aux = null. } return r. Párraga a) Método que permite INSERTAR un nodo al principio de la PILA b) Extracción del primer elemento de la PILA Un ejemplo de la clase Pila sería public class Pila { private Nodo p. en Sistemas de Curso 1k15 Prof. else { q. p= q. } /** método para agregar un elemento en la Pila */ public void insertarEnPila (int y) // es el método de insertar adelante de la lista { Nodo q = new Nodo (y) .

} if(aux== null) posPila =0.getDato()!= x) {auxPila. else posPila++. aux= aux.} return r .getProx(). while (aux !=null) {r += aux.getDato()). Nodo aux = p.p. // copia de la pila auxiliar.getDato()+". Página 16 de 32 .insertarEnPila(auxPila.sacarDePila()). } return posPila.getDato()==x) posPila = 1. else { Nodo aux = p. el dato //y lo agrega a la primera pila } while( auxPila. ". do{ if(auxPila. Párraga /** * metodo para poder acceder a un elemento cualquiera de la pila * sin tener que desarmar la pila.p != null) this. usando una pila auxiliar * devuelve el lugar en que se encuentra dentro de la pila */ public int mostrarUnEle(int x) // el parametro dice cual es el elemento a buscar { int posPila = 0. } /** * metodo para mostrar toda la pila */ public String toString() { String r =" Elementos de la Pila :\n". // para poder recorrer la pila sin desarmarla Pila auxPila = new Pila(). // pila auxiliar para conservar el orden de los elementos while(aux != null && aux. // copia en la pila auxiliar el elemento y borra de la lista original this. if(p. aux= p.sacarDePila(). del atributo p. en Sistemas de Curso 1k15 Prof.insertarEnPila(aux. posPila ++.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.getDato()).

Gráficamente. las incluimos y luego excluimos dos de ellas. Gráficamente: A B C frente (cabeza) A fondo B C ¿Cómo se hace para acceder a un elemento que no se encuentre el principio o cima de la pila? Como en el caso anterior. Insertar y Excluir son las únicas operaciones lícitas (posibles) en una cola. 'B'. Un buen ejemplo de cola es el de personas esperando utilizar el servicio público de transporte. en Sistemas de Curso 1k15 Prof. (Si dijéramos un mal ejemplo también es verdad). necesariamente 'A' Y 'B'.(estructura de datos que almacena elementos en una fila uno a continuación de otro) en donde cada elemento se inserta en parte final de la lista y se suprime o elimina por el frente (Cabeza) de la lista . 'B' y 'C'. excluir por el frente. 'C' "encoladas": fondo C C B A fondo cabeza C B C A C cabeza B C Página 17 de 32 A C . Párraga } // fin metodo } //fin clase f) COLAS Una cola es una lista lineal . Insertar por el fondo. La única diferencia con la pila es que estas operaciones se realizan en extremos opuestos. sobre una lista enlazada o en archivos. Entonces Insertar y Excluir se realizan en el mismo orden.Este es otro tipo de lista que se destaca por las limitaciones que se plantean en la forma de acceso a sus elementos Estructura FIFO (First Input-First Output). Se puede implementar sobre un vector. primero en entrar primero en salir. si tenemos 'A'. Las aplicaciones utilizan una cola para almacenar y liberar elementos en su orden de aparición o concurrencia. La gestión de tareas de impresión en una única impresora de una red de computadoras es otro ejemplo. Supongamos que tenemos las letras 'A'.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.

b) // para borrar el primer elemento ingresado en la Cola Un ejemplo de implementación de una Clase Cola sería: public class Cola { private Nodo p. Se puede utilizar dos punteros. Párraga La cola. // primer elemento de la cola /** * Constructor for objects of class Cola */ public Cola() { p = null. podemos diseñar una clase CCola. en Sistemas de Curso 1k15 Prof.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. Por consiguiente la inserción de los elementos de la cola (que deben ser por el final de la cola) se realizarán por el final de la lista y la extracción (que debe ser por el principio de la cola) se realizará siempre por la primera posición de la lista. O un solo puntero al principio. raíz. Conceptualmente Usando array Usando nodos vinculados Analizaremos una de las formas de Implementar una cola sobre una lista: Se considera el primer elemento de la cola como el primero de la lista. que soporte los siguientes métodos : a) // para agregar un nuevo elemento al final de la Cola. un puntero al principio. } /** * metodo que permite agregar un nodo al final de la lista */ Página 18 de 32 . para realizar las extracciones y para realizar las inserciones se tiene que recorrer la lista hasta llegar a la última posición. raíz. para realizar las extracciones y otro al final de la lista para las inserciones. Raíz Primer nodo de la lista Primer elemento de la cola NULL Ultimo nodo de la lista Ultimo elemento de la cola Para trabajar con Colas.

getProx() != null) // recorro la lista hasta encontrar el último { aux = aux.getProx(). if (p == null) p = q. // pila auxiliar para conservar el orden de los elementos Página 19 de 32 . p = p. r = true. else { Nodo aux = p.setProx(q). else { Nodo aux = p.getDato()==x) posCola = 1.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. } return r. if (p != null) { Nodo aux = p. while ( aux. } aux. if(p. } // fin metodo /** * metodo para poder acceder a un elemento cualquiera de la Cola * sin tener que desarmar la cola. Párraga public void insertarEnCola( int y) // método insertarFinal de listas { Nodo q = new Nodo(y) . // referencia el prox del último hacia el nuevo elemento q.setProx(null). en Sistemas de Curso 1k15 Prof. // para poder recorrer la pila sin desarmarla Cola auxCola = new Cola(). aux = null.getProx(). } }// fin método /** * Metodo para borrar el primer elemento */ public boolean borrarDeCola() // metodo borrarPri de listas { boolean r = false. usando una cola auxiliar * devuelve el lugar en que se encuentra dentro de la cola */ public int mostrarUnEle(int x) // el parametro dice cual es el elemento a buscar { int posCola = 0.

aux= p.insertarEnCola(aux. } if(aux== null) posCola =0. Párraga while(aux != null && aux. Nodo aux = p.borrarDeCola().getDato()). } /** * metodo para mostrar toda la Cola */ public String toString() { String r =" Elementos de la COLA :\n".borrarDeCola(). else posCola++.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. while (aux !=null) {r += aux.insertarEnCola(aux. // sigue cargando la cola en la cola auxiliar hasta terminar while(aux != null) {auxCola. // copia en la pila auxiliar el elemento y borra de la lista original this.p. aux= aux. aunque no hace falta porque al salir del método deja de existir } return posCola.getDato()!= x) {auxCola. // hace que el nodo de la cola original apunte a la Cola auxiliar auxCola = null. aux= p.getDato()+".getDato()). // elimina cola auxiliar . posCola ++.} return r . ".getProx(). }// fin metodo }// fin clase b) LISTAS CIRCULARES Página 20 de 32 . // copia en la pila auxiliar el elemento y borra de la lista original this.p =auxCola. } this. en Sistemas de Curso 1k15 Prof.

es que siempre el último elemento tiene almacenado la dirección del primer elemento de la lista..prox referencia al primer elemento de la lista private Nodo ultimo = null. *La dirección del próximo nodo en el último nodo es la del primer nodo de la lista.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. /** * Constructor por defecto class CListaCircularSE */ public CListaCircularSE() { ultimo = null. Párraga La características de esta estructura dinámica. de esta forma se convierte en circular. mediante una referencia al último elemento de la lista. Podemos encontrar listas circulares simples y listas circulares doblemente enlazadas. en Sistemas de Curso 1k15 Prof.SIMPLES (simplemente vinculadas) Sus características son: *El primer nodo es apuntado por un puntero raiz.Para moverse sobre una lista circular. por ejemplo. Raíz Referencia al próximo nodo Información Un ejemplo de clase lista circular simplemente enlazada sería el siguiente: /** * description de class CListaCircularSE * clase que permite generar listas circular simplemente enlazada * @author (Párraga Adriana) * @version (a version 01/2007) */ public class CListaCircularSE { // ultimo : referencia el ultimo elemento // último. } /** * metodo que devuelve el número de elementos de la lista */ Página 21 de 32 . es necesario almacenar de alguna manera un punto de referencia. *Cada nodo apunta a la dirección del próximo nodo.

* los demás se van agregando al principio de la lista */ public void agregarAlPrincipio(int x) { Nodo q = new Nodo(x. Párraga public int tamanio() { int n= 0. while(q != ultimo) { n++.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.setProx(ultimo.setProx(ultimo. } else { q.getProx(). } } return n. */ public void agregarFinal(int x) { // crea el nuevo elemento Nodo q= new Nodo(x. } else { q. ultimo en el prox del nuevo elemento ultimo.getProx(). if(ultimo !=null) { Nodo q = ultimo. ultimo.setProx(q). // almacena el valor del prox. // inserción del primer elemento a la lista ultimo. // enlaza al nuevo nodo con el prox del ultimo Página 22 de 32 . y es el valor del primer nodo ingresado. en Sistemas de Curso 1k15 Prof. q= q.null).getProx()).setProx(q).getProx()). n= 1. último referenciará al nuevo elemento que se ingrese. } } // fin metodo /** * añade un elemento al final de la lista * por lo tanto. // inserción del primer elemento if(ultimo == null) {ultimo = q.setProx(q).null). } // fin método /** * metodo que añade un elemento al principio de la lista circular * el valor del ultimo se mantiene. // crea un nuevo elemento if(ultimo == null) { ultimo = q.

en Sistemas de Curso 1k15 Prof.prox res = q.*/ } return res.setProx(q.setProx(q). // guarda la cantidad de elementos de la lista en una variable local int numeroElementos = this. Párraga ultimo. Página 23 de 32 . } // fin metodo /** * metodo que permite obtener el elemento de la posición i dada por parametro */ public int obtener(int i) { int res. if(i >= numeroElementos || i<0) res = -1 .getProx().getProx(). } } // fin metodo /** * metodo que permite borrar el primer elemento de la lista y devuelve una referencia * a la información (u objeto) que tenia almacenado el elemento borrado */ public int borrar() { int res = -1. j< i.tamanio(). // deja la lista vacia else ultimo. ultimo= q. // almacena en q. // crea un nodo que referencia al primer elemento de la lista for(int j=1. /** * el elemento desreferenciado por q es enviado a la basura.getDato(). // guarda el valor del primer elemento if( q== ultimo) // controla que si el elemnento a borrar es el unico de la lista ultimo = null.getProx()). // indica que no existe esa posición en la lista o la lista está vacía else { Nodo q = ultimo. // si la lista está vacia devuelve un valor negativo // controla que la lista no esté vacia if(ultimo != null) { Nodo q= ultimo.getProx(). al quedar desreferenciado * cuando finaliza este método por ser q una variable local.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. la referencia al primer nodo de la lista que está // apuntada por ultimo. j++) // recorre la lista hasta posesionarse en la posición i q = q.

int i =0. *La dirección del próximo nodo en el último nodo es 0 (NULL ).Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. } // fin metodo /** * metodo que permite mostrar los elemento de la lista circular */ public String toString() { String res = "Los elementos de la lista son : \n". } // fin metodo } // fin clase Antes de describir las listas circulares doblemente vinculadas. } return res. Sus características son: * El primer nodo es apuntado por un puntero raíz. if (tam > 0) { Nodo aux = ultimo..tamanio().getDato(). } } else res = "Lista vacia". Página 24 de 32 . *La dirección del anterior nodo en el primer nodo (raíz) es 0 (NULL ). excepto el primero. Esto permite leer la lista en ambas direcciones.getProx(). tam = this. borrado y movimiento de los elementos son operaciones frecuentes.getProx(). *Cada nodo apunta a la dirección del próximo nodo y a la dirección de nodo anterior. Este tipo de listas es útil cuando la inserción. vamos a definir cuando una lista es doblemente enlazada o vinculadas b) LISTAS DOBLEMENTE VINCULADAS Estas listas se caracterizan porque cada nodo. en Sistemas de Curso 1k15 Prof. aux = aux. return res. i++.getDato(). while(i< tam) { res += " "+ aux. Párraga res = q. posee información respecto al nodo posterior y el nodo anterior.

Una aplicación típica es un procesador de texto. que indican valores del nodo anterior y posterior . ant= null. en Sistemas de Curso 1k15 Prof.} //…………….Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. private Nodo prox. cuando existe un doble enlace entre el último elemento y el primero. Nodo a) // { dato = d. Nodo p. prox = p . casi siempre es mucho más fácil la manipulación de las mismas.Las operaciones sobre una lista doblemente enlazada normalmente se realizan sin ninguna dificultad.Página 25 de 32 // constructor con parámetros. ant = a. private Nodo ant. } public Nodo (int d) // constructor con parámetro { dato = d.. ant = null. } public Nodo (int d. cada elemento de la lista doblemente enlazada tendrá una definición como la que sigue: // definición de cada elemento o nodo de la lista public Class Nodo { // atributos private int dato. Párraga Raíz NULL NULL Referencia al anterior nodo Referencia al próximo nodo Información Según esto. donde el acceso a cada línea individual se hace a través de una lista doblemente enlazada. prox = null. prox = null. estructura que recibe el nombre de Lista Doblemente Enlazada. // metodos …… public Nodo () // constructor por defecto { dato = 0. Sin embargo.

en Sistemas de Curso 1k15 Prof. // constructor por defecto Página 26 de 32 . *La dirección del anterior nodo en el primer nodo es la del último nodo de la lista. prox = null. private NodoDE prox. // metodos …… public NodoDE () { dato = 0. Sus características son: *El primer nodo es apuntado por un puntero raíz. el tipo de cada elemento de la lista puede venir definido de la forma siguiente: /** * description de class NodoDE * esta clase permite crear objetos donde cada elemento tiene dos atributos tipo nodoDE * que permiten acceder a la información del nodo anterior y posterior al actual. private NodoDE ant.* * * @author (Párraga Adriana) * @version (a version 01/2007) */ public class NodoDE { // atributos private int dato. *Cada nodo apunta a la dirección del próximo nodo y a la dirección de nodo anterior.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. cada uno de los cuales contiene datos (o una referencia a los datos). Raíz Referencia al anterior nodo Referencia al próximo nodo Información Según esto. una referencia al elemento siguiente en la lista. Párraga d) LISTAS CIRCULARES DOBLEMENTE VINCULADAS Una lista circular doblemente enlazada (lcde) es una colección de objetos. *La dirección del próximo nodo en el último nodo es la del primer nodo de la lista. y una referencia al elemento anterior.

} public void setDato( int d) { dato= d. que indican // valores del nodo anterior y posterior // constructor con parámetro . } public NodoDE (int d.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. } public void setProx(NodoDE p) { prox= p. } public NodoDE getProx() { return prox. } } //FIN CLASE Un ejemplo de los métodos que permiten implementar una lista circular doblemente vinculada. } public NodoDE getAnt() { return ant. prox = null. prox = p . ant = null. Párraga ant= null. } public NodoDE (int d) { dato = d. ant = a.} public int getDato() { return dato. NodoDE p. NodoDE a) { dato = d. en Sistemas de Curso 1k15 Prof. * contiene los métodos para manipula una lista Circular doblemente enlazada * de datos enteros * * @author (Párraga Adriana) * @version (a version 01/2007) */ public class CListaCircularDE Página 27 de 32 // constructor con parámetros. son los que se presentan en la siguiente clase : /** * description de class CListaCircularDE . } public void setAnt(NodoDE a) { ant=a.

// referencia al elemento actual en el que estamos private NodoDE actual. Párraga { // referencia al ultimo elemento de la lista private NodoDE ultimo. en Sistemas de Curso 1k15 Prof.setProx(ultimo). } /** * // añade un nuevo elemento a la lista a continuación del elemento actual * elnuevo pasa a ser el elemento actual */ public void insertar (int d) { NodoDE q. /** * Constructor for objects of class CListaCircularDE */ public CListaCircularDE() { actual=ultimo= null.setDato(d). } public long tamanio() { return numeroElementos. // inserta el nuevo elemento despues del actual actual. ultimo.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. // LA POSICION DEL PRIMER ELEMENTO SERA LA CERO } else // existe una lista { q = new NodoDE(). // del nodo actual el atributo nodo prox se carga en el atributo ant el valor de q Página 28 de 32 . posicion=-1. numeroElementos= 0. // número de elementos que tiene la lista private long numeroElementos.getProx(). // posicion del elemento actual private long posicion.setAnt(q). if(ultimo == null) // lista vacia { ultimo = new NodoDE(). // las dos lineas siguientes inician una lista circular ultimo. posicion= 0. // asigna datos actual= ultimo. ultimo.setAnt(ultimo).

setAnt(actual). int dato.getProx()). }// fin metodo // incrementa el nuumero de elementos. //conecta el nodo nuevo con el actual.que pasa a ser anterior q. posicion= -1. actual. if(actual == ultimo) ultimo = q.setProx(q). el nuevo elemento pasa a ser el actual y el último.setDato(d).getDato(). dato = ultimo. // carga los datos al nodo nuevo // actualizar parametros posicion ++. Párraga q.getProx()). numeroElementos= 0. // conecta el nodo actual con el nuevo como el proximo q.getDato(). posicion--.setProx(actual. ultimo = actual= null. // lista vacia else if (actual == ultimo) // controla si se trata del ultimo elemento { if(numeroElementos== 1) // hay un solo elemento { dato = ultimo.setAnt(actual). getAnt(). numeroElementos--.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.- /** * método que borra un nodo y devuelve los datos del elemento referenciado como actual * y lo elimina de la lista (al quedar dereferenciado es enviado a la basura) * si la lista está vacia devuelve un valor negativo */ public int borrar() { NodoDE q. // si el alemento actual es el ultimo.getProx(). } } // fin del bloque verdadero if(actual== ultimo) Página 29 de 32 .setProx(ultimo. if(ultimo == null) dato = -11 . actual = q. ultimo = actual. // el nuevo elemento pasa a ser el actual } numeroElementos++. en Sistemas de Curso 1k15 Prof. } else { // hay mas de un elemento actual = ultimo. ultimo. actual.

actual = q. Párraga else { q= actual. */ public void irAlSiguiente() { if (posicion < numeroElementos -1) { actual = actual.getProx().Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. actual.getAnt()). numeroElementos--. } // fin metodo /** * avanza la posicion actual al siguiente elemento.getProx().setProx(q).getDato(). en Sistemas de Curso 1k15 Prof. posicion = -1.getProx(). } // fin metodo /** * el final de la lista es ahora la posicion actual */ Página 30 de 32 . posicion ++. posicion--. dato= actual.getAnt().setAnt(actual. } return dato. } } // fin metodo /** * hace que la posicion actual sea el principio de la lista */ public void irAlPrincipio() { actual= ultimo.getAnt(). q. } } // fin metodo /** * retraza la posicion actual al elemento anterior */ public void irAlAnterior() { if(posicion > -1) { actual = actual.

posicion = numeroElementos-1. if ( i >0 && i < numeroElementos ) { irAlPrincipio(). n< i. n++) irAlSiguiente(). en Sistemas de Curso 1k15 Prof. Párraga public void irAlFinal() { actual = ultimo.tamanio().getDato(). } // fin metodo /** * el metodo obener devuelve la referencia o datos asociados con el elemento actual */ public int obtener() { int res = -1.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. long numeroElementos = this. } return res. }// fin metodo /** * el metodo devuelve los datos asociados con el elemento de indice i */ public int obtener (long i) { if(!irAl(i)) return -1. } // fin metodo /** * posicionarse en el elemento i */ public boolean irAl(long i) { boolean res = false. res = true. return obtener(). if(ultimo != null) res = actual. return res. }// fin metodo /** * metodo modificar establece nuevos datos para el elemento actual */ public void modificar(int nuevodat) { if(ultimo != null) // controla que la lista no este vacia Página 31 de 32 . // posicionarse en el elemnto i for(int n= 0.

i=+i+2. } if(tam == 0) mens = "\n\t la lista esta vacia". en Sistemas de Curso 1k15 Prof. } // fin metodo } // fin clase Página 32 de 32 .setDato(nuevodat).obtener(i+1). long i= 0.tamanio().obtener(i)+ "\t dato " + (i+1) + " : "+ this. return mens. tam = this. while (i < tam) { mens += "\n\t dato " + i + " : "+ this. Párraga actual.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. int dato. }// fin metodo /** * metodo para mostrar los elementos de la lista */ public String toString() { String mens = " lista de datos almacenados \n".

Sign up to vote on this title
UsefulNot useful