P. 1
ESTRUCTURAS- DINAMICAS

ESTRUCTURAS- DINAMICAS

|Views: 25|Likes:
Publicado porJuan Molina

More info:

Published by: Juan Molina on May 07, 2013
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as DOC, PDF, TXT or read online from Scribd
See more
See less

03/29/2014

pdf

text

original

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

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

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

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

getProx(). //conecto el elemento anterior a q } } res = true. en Sistemas de Curso 1k15 Prof.setProx(elemAct). y lo inserte en forma ordenada. // sirve para guardar la posición anterior for ( int i= 1. p) . mientras el valor del dato sea menor que el nuevo y while ( elemAct != null && elemAct. // crea un elemento a agregar Nodo elemAct = p. } else { Nodo q = new Nodo(y) . } //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.getDato()) { Nodo q = new Nodo(y. // crea un elemento a agregar y le pasa la dirección de p // para realizar el enganche adelante p = q. } // se mueve con las dos referencias auxiliares. elemAct = elemAct.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. i < pos. // elemento auxiliar que permite moverme en la lista Nodo elemAnt = p.setProx(q). hasta encontrar la pos // requerida una vez encontrada la pos.// conecto la referencia de q al elemento actual elemAnt. 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. Para ello es posible realizar un método que reciba como parámetros al nuevo elemento o sus datos. se realiza la inserción q. i ++) { elemAnt = elemAct. // sirve para guardar la posición anterior // recorro la lista. Párraga Nodo elemAnt = p.getDato()< y) Página 7 de 32 . } return res.

referenciar el prox del elemento anterior al prox. y puede ser recolectado por el recolector de basura de java. hasta encontrar la pos requerida // una vez encontrada la pos. del elemento a borrar. se realiza la inserción if (elemAct == null) elemAnt. elemAct = elemAct. // agrega al final de la lista else { q. Párraga { elemAnt = elemAct.. hasta ubicar el elemento a borrar. //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.. de esta forma se borran todas las referencias que existían hacia ese elemento.getDato() == cod) { Nodo aux = p. las operaciones a realizar son las siguientes: .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. ese objeto es enviado al recolector de basura.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing.getProx().Solo cuando se eliminan todas las referencias que permiten acceder a un elemento. if (p != null) { // primero controlamos que el dato buscado no se encuentre en el primer nodo if(p.// conecto la referencia de q al elemento actual elemAnt. en Sistemas de Curso 1k15 Prof.. es decir le borra la referencia.setProx(q). Página 8 de 32 .setProx(elemAct). } // se mueve con las dos referencias auxiliares. pero sin perder la información del elemento anterior.referencia a null el elemento a borrar.copiar el elemento a borrar en un aux.primero recorrer la lista.

r = true.getProx(). // primero debe evaluarse si el nodo es null.getDato() !=cod) { posAnt = posAct.getProx()). aux = null. } // 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 .getDato() == cod) { posAnt. posAct = posAct. } if (posAct. p = p.getProx() != null && posAct. aux = null. posAct = 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. Párraga p = p. porque si no lanzaría una excepción NullPointerExcepción while ( posAct. } return r.getProx(). if (p != null) { Nodo aux = p.setProx(posAct. r = true. //y luego la otra condición. 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. } } //fin else }// fin if grande return r.getProx(). Nodo posAct = p.

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

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

aux= aux. }// fin método Página 12 de 32 .getProx(). Párraga */ public String toString() { String r ="".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. Nodo aux = p. ". } return r .getDato()+". en Sistemas de Curso 1k15 Prof.

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

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. v[0] = A . 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. en listas dinámicas o en archivos. Es simple. '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. v[2] = C. si tenemos 'A'. 'B'.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. (o del primero disponible). según los vistos serían: Página 14 de 32 . o pequeño. en Sistemas de Curso 1k15 Prof. 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. Párraga Se pueden implementar pilas en arrays. los métodos para inserción y extracción. Gráficamente. cabeza es el índice del último casillero ocupado.

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. } /** 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) . } } /** * Metodo para borrar el primer elemento */ public boolean sacarDePila() // metodo borrarpri de la lista { boolean r = false. p= q.setProx(p). else { q. p = p. if (p != null) { Nodo aux = p. aux = null. } return r.getProx().Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. } // fin metodo borrarpri Página 15 de 32 . // constructor con parametro if (p == null) p = q. en Sistemas de Curso 1k15 Prof. // la dirección del primer elemento de la pila /** * Constructor for objects of class Pila */ public Pila() { p = null. r = true.

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

Un buen ejemplo de cola es el de personas esperando utilizar el servicio público de transporte.(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'. 'C' "encoladas": fondo C C B A fondo cabeza C B C A C cabeza B C Página 17 de 32 A C . en Sistemas de Curso 1k15 Prof.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). Párraga } // fin metodo } //fin clase f) COLAS Una cola es una lista lineal . primero en entrar primero en salir. (Si dijéramos un mal ejemplo también es verdad). La gestión de tareas de impresión en una única impresora de una red de computadoras es otro ejemplo. necesariamente 'A' Y 'B'. Supongamos que tenemos las letras 'A'. las incluimos y luego excluimos dos de ellas. La única diferencia con la pila es que estas operaciones se realizan en extremos opuestos. 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 por el fondo. excluir por el frente. Insertar y Excluir son las únicas operaciones lícitas (posibles) en una cola. 'B'. Gráficamente. sobre una lista enlazada o en archivos. si tenemos 'A'.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. Las aplicaciones utilizan una cola para almacenar y liberar elementos en su orden de aparición o concurrencia. Se puede implementar sobre un vector. Entonces Insertar y Excluir se realizan en el mismo orden.

para realizar las extracciones y para realizar las inserciones se tiene que recorrer la lista hasta llegar a la última posición. 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. 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. // primer elemento de la cola /** * Constructor for objects of class Cola */ public Cola() { p = null. que soporte los siguientes métodos : a) // para agregar un nuevo elemento al final de la Cola. Párraga La cola.Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. podemos diseñar una clase CCola. O un solo puntero al principio. en Sistemas de Curso 1k15 Prof. Se puede utilizar dos punteros. para realizar las extracciones y otro al final de la lista para las inserciones. raíz. } /** * metodo que permite agregar un nodo al final de la lista */ Página 18 de 32 . un puntero al principio. 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. 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.

} // fin metodo /** * metodo para poder acceder a un elemento cualquiera de la Cola * sin tener que desarmar la cola. r = true. aux = null.getProx().Universidad Tecnológica Nacional Datos 2007 Facultad Regional Córdoba Información ESTRUCTURAS DINÁMICAS Adriana Algoritmos y Estructuras de Ing. } return r. // referencia el prox del último hacia el nuevo elemento q. p = p.setProx(q). if(p. // para poder recorrer la pila sin desarmarla Cola auxCola = new Cola(). else { Nodo aux = p.getProx() != null) // recorro la lista hasta encontrar el último { aux = aux. // pila auxiliar para conservar el orden de los elementos Página 19 de 32 . while ( aux. } }// 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. else { Nodo aux = p. if (p == null) p = q.getProx().getDato()==x) posCola = 1. if (p != null) { Nodo aux = p. } aux. Párraga public void insertarEnCola( int y) // método insertarFinal de listas { Nodo q = new Nodo(y) .setProx(null). en Sistemas de Curso 1k15 Prof.

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

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

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

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

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

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

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

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

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

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

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

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

setDato(nuevodat). } if(tam == 0) mens = "\n\t la lista esta vacia". while (i < tam) { mens += "\n\t dato " + i + " : "+ this.tamanio(). 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. } // fin metodo } // fin clase Página 32 de 32 .obtener(i+1). return mens. i=+i+2. long i= 0.obtener(i)+ "\t dato " + (i+1) + " : "+ this. tam = this. }// fin metodo /** * metodo para mostrar los elementos de la lista */ public String toString() { String mens = " lista de datos almacenados \n". Párraga actual. int dato.

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->