Estructuras - Dinamicas

Universidad Tecnolgica Nacional Datos 2007 Facultad Regional Crdoba Informacin ESTRUCTURAS DINMICAS Adriana
Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga
Apunte Resumen- sobre Estructuras Dinmicas Bibliografa : java 2 Javier Ceballos Sierra Apuntes de clases Realizado por : Adriana Prraga 2007 ESTRUCTURAS DINMICAS La principal caracterstica de las estructuras dinmicas es la facultad que tienen para variar su tamao, realizando asignaciones dinmicas para las componentes individuales, al tiempo que son creadas durante la ejecucin del programa.Cuando se trabaja con estructuras dinmicas, el compilador asigna una cantidad fija de memoria para mantener la direccin del componente asignado dinmicamente, en vez de hacer una asignacin para el componente en s. Esto implica que debe haber una clara distincin 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 dinmicamente para un objeto de un tipo cualquiera, se devuelve una referencia a la zona de memoria asignada. Para realizar esta operacin disponemos en Java del operador new .Dentro de las estructuras dinmicas, podemos encontrar: Listas( listas simplemente enlazadas,, listas circulares, listas doblemente enlazadas, Pilas, Colas), rboles Binarios y Grafos.-
Listas Lineales
Una Lista lineal es una coleccin, originalmente vaca, de elementos u objetos de cualquier tipo no necesariamente consecutivos en memoria, que durante la ejecucin del programa pueden crecer o decrecer elemento a elemento segn las necesidades previstas en el mismo.Cmo pasamos desde un elemento al siguiente cuando recorramos la lista? Cada elemento debe almacenar informacin de dnde est el siguiente elemento o el anterior, o bien ambos. En funcin de la informacin que cada elemento de la lista almacene respecto a la localizacin 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 coleccin 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 coleccin (elemento de la lista). Grficamente puede representarse de la siguiente forma: p Nodo
Nodo prox;
Nodo prox;
Nodo prox;
null;
Pgina 1 de 32
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. Segn 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; // mtodos public Nodo () // contructor por defecto { x = 0; prox = null;} //.. class Nodo { private Dato d; private Nodo prox ; // mtodos public Nodo() {} .
Se puede observar que la clase Nodo definir una serie de atributos correspondientes a los datos que deseamos manipular, adems 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 asignacin de memoria para un elemento se hara 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 despus de este elemento no hay otro // operaciones cualesquiera..
Pgina 2 de 32
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 vaca si n vale null. Por ejemplo despus de ejecutar las sentencias: n = null; // lista vaca n = new Nodo(); // elemento n n.prox =null; //no hay siguiente elemento Tenemos una lista de un elemento: n null
Nodo prox;
para aadir un nuevo elemento a la lista, procedemos as: q = new Nodo(); // creamos un nuevo elemento q.prox = p; // almacena la localizacin 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 aaden 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 Bsicas Las operaciones que podemos realiza con una lista incluyen fundamentalmente las siguientes: 1- Insertar un elemento en una lista. Pgina 3 de 32
23456-
Borrar un elemento de una lista Borrar todos los elementos de una lista.Recorrer los elementos de una lista.Buscar un elemento en una lista.Mostrar todos los elemento de la lista.-
Partiendo de las definiciones : Class Nodo { // atributos private int dato; private Nodo prox; // metodos public Nodo () // contructor por defecto { dato = 0; prox = null;} public Nodo (int d) // contructor con parametro { dato = d; prox = null;} public Nodo (int d, Nodo p) // contructor con parametro { dato = d; prox = p ;} //.. public class Principal { public static void main (String [] args) { Nodo p,q,r ; // referencia a elementos de la clase Nodo Int x = In.readInt(); } } // fin class Principal Vamos a exponer como se realizan cada una de las operaciones bsicas. 1- Insercin de un elemento a) Al comienzo de la lista q = new Nodo(); q.dato = x ; q.prox = p; p = q; el orden en el que se realizan estas operaciones es esencial. Y el resultado es q p x x x x Pgina 4 de 32
null es decir que partiendo de una lista vaca, no tenemos ms que repetir la operacin de insertar un elemento al comienzo de una lista, tantas veces como elementos deseemos que tenga dicha lista.Si realizamos un mtodo podra ser as: /** * metodo que permite agregar un nodo al principio de la lista */ public void insertarAdelante (int y) { Nodo q = new Nodo (y) ; // constructor con parmetro if (p == null) p = q; else { q.setProx(p); p= q; } } Siendo este mtodo perteneciente a la clase Principal, o a la clase que contiene la lista.Notar que el orden de los elementos en la lista es inverso en el que han llegado.b) Insercin al final de la lista Si se desea insertar al final de la lista, es necesario poder recorrer la misma, hasta encontrar el ltimo elemento, y recin all realizar la unin./** * metodo que permite agregar un nodo al final de la lista */ public void insertarFinal( int y) { Nodo q = new Nodo(y) ; if (p == null) p = q; else { Nodo aux = p; while ( aux.getProx() != null) // recorro la lista hasta encontrar el ltimo { aux = aux.getProx(); Pgina 5 de 32
} aux.setProx(q); // referencia el prox del ltimo hacia el nuevo elemento q.setProx(null); } }// fin mtodo c) insercin general Cuando se necesita insertar un nuevo elemento en un lugar especfico avisado por teclado, se podra utilizar un mtodo similar al siguiente: /** * metodo para calcular cantidad de elementos de la lista */ public int tamano() { int res = 0; Nodo q = p; while (q != null) { res++; // cuenta que hay un nodo mas q = q.getProx(); // se corre al prximo nodo de la lista } return res; } /** * * insercin de un elemento en la lista, a continuacin de otro elemento * * cualquiera por ejemplo en la posicin pos * * retorna verdadero si se puede realizar el agregado a la lista */ public boolean insertarGeneral( int y, int pos) { boolean res = false; Nodo q = new Nodo ( y) ;// crea un elemento a agregar int nroElementos = this.tamano(); // llama al mtodo que calcula el tamao if (nroElementos == 0) { p = q; res = true; } else { if( pos == 1) this.insertarAdelante (y); else {if (pos < nroElementos && pos> 1) { // aade un elemento en la posicin pos Nodo elemAct = p; // elemento auxiliar que permite moverme en la lista Pgina 6 de 32
Nodo elemAnt = p; // sirve para guardar la posicin anterior for ( int i= 1; i < pos; i ++) { elemAnt = elemAct; elemAct = elemAct.getProx(); } // se mueve con las dos referencias auxiliares, hasta encontrar la pos // requerida una vez encontrada la pos, se realiza la insercin q.setProx(elemAct);// conecto la referencia de q al elemento actual elemAnt.setProx(q); //conecto el elemento anterior a q } } res = true; } return res; } //fin metodo d) Insercin Ordenada segn un dato determinado Hay veces que se desea los elementos de la lista ordenados segn algn dato especifico. Para ello es posible realizar un mtodo que reciba como parmetros al nuevo elemento o sus datos, y lo inserte en forma ordenada. Ejemplo /** * insercin ordenada de elementos de una lista * en forma ascendente */ public void insertarOrdenado( int y) { // se fija si la lista est vaca o el dato es menor al del primer elemento if (p == null || y < p.getDato()) { Nodo q = new Nodo(y, p) ; // crea un elemento a agregar y le pasa la direccin de p // para realizar el enganche adelante p = q; } else { Nodo q = new Nodo(y) ; // crea un elemento a agregar Nodo elemAct = p; // elemento auxiliar que permite moverme en la lista Nodo elemAnt = p; // sirve para guardar la posicin anterior // recorro la lista, mientras el valor del dato sea menor que el nuevo y while ( elemAct != null && elemAct.getDato()< y) Pgina 7 de 32
{ elemAnt = elemAct; elemAct = elemAct.getProx(); } // se mueve con las dos referencias auxiliares, hasta encontrar la pos requerida // una vez encontrada la pos, se realiza la insercin if (elemAct == null) elemAnt.setProx(q); // agrega al final de la lista else { q.setProx(elemAct);// conecto la referencia de q al elemento actual elemAnt.setProx(q); //conecto el elemento anterior a q } } }// fin mtodo 2) Borrar un elemento de una lista Para borrar el sucesor de un elemento referenciado por r, las operaciones a realizar son las siguientes: - primero recorrer la lista, hasta ubicar el elemento a borrar, pero sin perder la informacin del elemento anterior.- copiar el elemento a borrar en un aux.- referenciar el prox del elemento anterior al prox. del elemento a borrar.- referencia a null el elemento a borrar, es decir le borra la referencia, de esta forma se borran todas las referencias que existan hacia ese elemento, y puede ser recolectado por el recolector de basura de java.Solo cuando se eliminan todas las referencias que permiten acceder a un elemento, ese objeto es enviado al recolector de basura.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 parmetro /** * mtodo que permite encontrar un elemento y borrarlo de la lista */ public boolean borrarUno( int cod) { boolean r = false; if (p != null) { // primero controlamos que el dato buscado no se encuentre en el primer nodo if(p.getDato() == cod) { Nodo aux = p; Pgina 8 de 32
p = p.getProx(); aux = null; } else { Nodo posAnt = p; Nodo posAct = p; // primero debe evaluarse si el nodo es null, //y luego la otra condicin, porque si no lanzara una excepcin NullPointerExcepcin while ( posAct.getProx() != null && posAct.getDato() !=cod) { posAnt = posAct; posAct = posAct.getProx(); } if (posAct.getDato() == cod) { posAnt.setProx(posAct.getProx()); posAct = null; r = true; } } //fin else }// fin if grande return r; }// fin mtodo b) Siempre borra el primer elemento de la lista /** * Metodo para borrar el primer elemento */ public boolean borrarPri() { boolean r = false; if (p != null) { Nodo aux = p; p = p.getProx(); aux = null; r = true; } return r; } // fin metodo borrarpri c) Siempre borra el ltimo elemento de la lista /** * metodo que permite borrar el ultimo elemento de una lista Pgina 9 de 32
* */ public boolean borrarUltimo() { boolean r = false; if (p != null) { // primero controlamos que la lista tenga datos Nodo posAnt = p; Nodo posAct = p; // primero debe evaluarse si el nodo es null, //y luego la otra condicin, porque si no lanzara una excepcin NullPointerExcepcin while ( posAct != null && posAct.getProx() != null) { posAnt = posAct; posAct = posAct.getProx(); } posAnt.setProx( null); posAct = null; r = true; }// fin if Grande return r; }// fin mtodo 3- Borrar todos los elementos de la lista /** * mtodo que permite borrar todos los elementos de la lista */ public void borrarTodo() { Nodo aux= p; while (aux != null) { p= p.getProx(); aux = null; aux = p; } } // fin metodo 4 - bsqueda de un elemento en particular Pgina 10 de 32
En este tipo de mtodos se deber recibir un dato que permita establecer el elemento a buscar. Siempre que se desea recorrer la lista, se deber crear un elemento auxiliar para poder moverse entre los elementos de la lista hasta encontrar el deseado, sin perder la referencia del primero./** * mtodo que busca un elemento y lo muestra */ public String mostrarDato( int cod) { String res ="\n no existe el dato con codigo : " + cod; Nodo aux = p; if (p != null) { while ( aux != null && aux. getDato() != cod) aux = aux.getProx(); if( aux != null&& aux.getDato() == cod) res = "\t los datos del nmero solicitado son : "+ aux.getDato() ; } return res +"\n\n"; } /** * mtodo que busca un determinado valor en la lista y dice cuantas veces lo encontr */ public int cantidadDato( int cod) { int cant =0; Nodo aux = p; if (p != null) { while ( aux != null) { if( aux. getDato()== cod) cant++; aux = aux.getProx(); } } return cant; } 6- Mostrar todos los elemento de la lista./** *Mtodo para mostrar todos los elementos de la lista Pgina 11 de 32
*/ public String toString() { String r =""; Nodo aux = p; while (aux !=null) { r += aux.getDato()+", "; aux= aux.getProx(); } return r ; }// fin mtodo
Pgina 12 de 32
e)
PILAS
Estas son listas que se destacan por la forma de acceso que se les exige en su uso. Es decir que para la construccin de una pila hay que respetar ciertas reglas de acceso, el ultimo en entrar es el primero en salir.Estructura de tipo LIFO (Last Input - First Output), ltimo en entrar primero en salir . Es decir que solo se puede acceder por un nico lugar o extremo. Los elementos de la pila se aaden siempre al principio.Una pila (stack) es una coleccin ordenada de elementos y se quitan (borran) de la misma slo por su parte superior (cima). Entonces, Insertar y Excluir son las nicas operaciones lcitas (posibles) en una pila. Al operarse nicamente por la parte superior de la pila, al excluir elementos retiramos el que est en la cima, el ltimo que incluimos. Si repetimos esta operacin retiraremos el penltimo, el antepenltimo, o sea en orden inverso al que los incluimos. Supongamos que tenemos las letras 'A', 'B' y 'C', las incluimos y luego excluimos dos de ellas, necesariamente 'C' Y 'B'. Grficamente: C B A
C A B
A La operacin de Insertar sita un elemento dado en la cima de la pila y Excluir lo elimina o quita. Cmo 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, de forma tal de no romper el orden de ingreso de la pila, y acceder al elemento buscado.
Pgina 13 de 32
Se pueden implementar pilas en arrays, en listas dinmicas o en archivos. Grficamente, si tenemos 'A', 'B', '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) Implementacin en vectores En la implementacin con vectores, cabeza es el ndice del ltimo casillero ocupado, (o del primero disponible). Es simple, pero tiene el inconveniente de soportar una estructura tpicamente dinmica (la pila) con una esttica (el vector): El vector puede ser demasiado grande, o pequeo. v[0] = A , v[1] = B , v[2] = C, 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. Por consiguiente la insercin y extraccin de los elementos de la pila (que deben ser por el final de la pila) se realizarn siempre por la primera posicin de la lista.
Raz Primer nodo de la lista Ultimo elemento de la pila NULL Ultimo nodo Primer elemento de la lista de la pila
En este caso, los mtodos para insercin y extraccin, segn los vistos seran:
Pgina 14 de 32
a) Mtodo que permite INSERTAR un nodo al principio de la PILA b) Extraccin del primer elemento de la PILA Un ejemplo de la clase Pila sera public class Pila { private Nodo p;
// la direccin del primer elemento de la pila
/** * Constructor for objects of class Pila */ public Pila() { p = null; } /** mtodo para agregar un elemento en la Pila */ public void insertarEnPila (int y) // es el mtodo de insertar adelante de la lista { Nodo q = new Nodo (y) ; // constructor con parametro if (p == null) p = q; else { q.setProx(p); p= q; } } /** * Metodo para borrar el primer elemento */ public boolean sacarDePila() // metodo borrarpri de la lista { boolean r = false; if (p != null) { Nodo aux = p; p = p.getProx(); aux = null; r = true; } return r; } // fin metodo borrarpri
Pgina 15 de 32
/** * metodo para poder acceder a un elemento cualquiera de la pila * sin tener que desarmar la pila, 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; if(p.getDato()==x) posPila = 1; else { Nodo aux = p; // para poder recorrer la pila sin desarmarla Pila auxPila = new Pila(); // pila auxiliar para conservar el orden de los elementos while(aux != null && aux.getDato()!= x) {auxPila.insertarEnPila(aux.getDato()); // copia en la pila auxiliar el elemento y borra de la lista original this.sacarDePila(); aux= p; posPila ++; } if(aux== null) posPila =0; else posPila++; do{ if(auxPila.p != null) this.insertarEnPila(auxPila.p.getDato()); // copia de la pila auxiliar, del atributo p, el dato //y lo agrega a la primera pila } while( auxPila.sacarDePila()); } return posPila; } /** * metodo para mostrar toda la pila */ public String toString() { String r =" Elementos de la Pila :\n"; Nodo aux = p; while (aux !=null) {r += aux.getDato()+", "; aux= aux.getProx();} return r ; Pgina 16 de 32
} // fin metodo } //fin clase
f) COLAS Una cola es una lista lineal ,(estructura de datos que almacena elementos en una fila uno a continuacin 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 .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), primero en entrar primero en salir. Las aplicaciones utilizan una cola para almacenar y liberar elementos en su orden de aparicin o concurrencia. Insertar y Excluir son las nicas operaciones lcitas (posibles) en una cola. La nica diferencia con la pila es que estas operaciones se realizan en extremos opuestos. Insertar por el fondo, excluir por el frente. Entonces Insertar y Excluir se realizan en el mismo orden. Un buen ejemplo de cola es el de personas esperando utilizar el servicio pblico de transporte. (Si dijramos un mal ejemplo tambin es verdad). La gestin de tareas de impresin en una nica impresora de una red de computadoras es otro ejemplo. Supongamos que tenemos las letras 'A', 'B' y 'C', las incluimos y luego excluimos dos de ellas, necesariamente 'A' Y 'B'. Grficamente:
C frente (cabeza)
A fondo
Cmo se hace para acceder a un elemento que no se encuentre el principio o cima de la pila? Como en el caso anterior, Se puede implementar sobre un vector, sobre una lista enlazada o en archivos. Grficamente, si tenemos 'A', 'B', 'C' "encoladas":
fondo C
C B A
fondo cabeza
C B
C A C
cabeza
C Pgina 17 de 32
A
La cola, 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. Por consiguiente la insercin de los elementos de la cola (que deben ser por el final de la cola) se realizarn por el final de la lista y la extraccin (que debe ser por el principio de la cola) se realizar siempre por la primera posicin de la lista. Se puede utilizar dos punteros, un puntero al principio, raz, para realizar las extracciones y otro al final de la lista para las inserciones, O un solo puntero al principio, raz, para realizar las extracciones y para realizar las inserciones se tiene que recorrer la lista hasta llegar a la ltima posicin.
Raz 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, podemos disear una clase CCola, que soporte los siguientes mtodos : a) // para agregar un nuevo elemento al final de la Cola. b) // para borrar el primer elemento ingresado en la Cola Un ejemplo de implementacin de una Clase Cola sera: public class Cola { private Nodo p; // primer elemento de la cola /** * Constructor for objects of class Cola */ public Cola() { p = null; } /** * metodo que permite agregar un nodo al final de la lista */ Pgina 18 de 32
public void insertarEnCola( int y) // mtodo insertarFinal de listas { Nodo q = new Nodo(y) ; if (p == null) p = q; else { Nodo aux = p; while ( aux.getProx() != null) // recorro la lista hasta encontrar el ltimo { aux = aux.getProx(); } aux.setProx(q); // referencia el prox del ltimo hacia el nuevo elemento q.setProx(null); } }// fin mtodo /** * Metodo para borrar el primer elemento */ public boolean borrarDeCola() // metodo borrarPri de listas { boolean r = false; if (p != null) { Nodo aux = p; p = p.getProx(); aux = null; r = true; } return r; } // fin metodo /** * metodo para poder acceder a un elemento cualquiera de la Cola * sin tener que desarmar la cola, 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; if(p.getDato()==x) posCola = 1; else { Nodo aux = p; // para poder recorrer la pila sin desarmarla Cola auxCola = new Cola(); // pila auxiliar para conservar el orden de los elementos
Pgina 19 de 32
while(aux != null && aux.getDato()!= x) {auxCola.insertarEnCola(aux.getDato()); // copia en la pila auxiliar el elemento y borra de la lista original this.borrarDeCola(); aux= p; posCola ++; } if(aux== null) posCola =0; else posCola++; // sigue cargando la cola en la cola auxiliar hasta terminar while(aux != null) {auxCola.insertarEnCola(aux.getDato()); // copia en la pila auxiliar el elemento y borra de la lista original this.borrarDeCola(); aux= p; } this.p =auxCola.p; // hace que el nodo de la cola original apunte a la Cola auxiliar auxCola = null; // elimina cola auxiliar , aunque no hace falta porque al salir del mtodo deja de existir } return posCola; } /** * metodo para mostrar toda la Cola */ public String toString() { String r =" Elementos de la COLA :\n"; Nodo aux = p; while (aux !=null) {r += aux.getDato()+", "; aux= aux.getProx();} return r ; }// fin metodo
}// fin clase b) LISTAS CIRCULARES
Pgina 20 de 32
La caractersticas de esta estructura dinmica, es que siempre el ltimo elemento tiene almacenado la direccin del primer elemento de la lista, de esta forma se convierte en circular. Podemos encontrar listas circulares simples y listas circulares doblemente enlazadas.Para moverse sobre una lista circular, es necesario almacenar de alguna manera un punto de referencia; por ejemplo, mediante una referencia al ltimo elemento de la lista.SIMPLES (simplemente vinculadas) Sus caractersticas son: *El primer nodo es apuntado por un puntero raiz.. *Cada nodo apunta a la direccin del prximo nodo. *La direccin del prximo nodo en el ltimo nodo es la del primer nodo de la lista.
Raz
Referencia al prximo nodo Informacin
Un ejemplo de clase lista circular simplemente enlazada sera el siguiente: /** * description de class CListaCircularSE * clase que permite generar listas circular simplemente enlazada * @author (Prraga Adriana) * @version (a version 01/2007) */ public class CListaCircularSE { // ultimo : referencia el ultimo elemento // ltimo.prox referencia al primer elemento de la lista private Nodo ultimo = null; /** * Constructor por defecto class CListaCircularSE */ public CListaCircularSE() { ultimo = null; } /** * metodo que devuelve el nmero de elementos de la lista */
Pgina 21 de 32
public int tamanio() { int n= 0; if(ultimo !=null) { Nodo q = ultimo.getProx(); n= 1; while(q != ultimo) { n++; q= q.getProx(); } } return n; } // fin mtodo /** * metodo que aade un elemento al principio de la lista circular * el valor del ultimo se mantiene, y es el valor del primer nodo ingresado, * los dems se van agregando al principio de la lista */ public void agregarAlPrincipio(int x) { Nodo q = new Nodo(x,null); // crea un nuevo elemento if(ultimo == null) { ultimo = q; // insercin del primer elemento a la lista ultimo.setProx(q); } else { q.setProx(ultimo.getProx()); // almacena el valor del prox. ultimo en el prox del nuevo elemento ultimo.setProx(q); } } // fin metodo /** * aade un elemento al final de la lista * por lo tanto, ltimo referenciar al nuevo elemento que se ingrese. */ public void agregarFinal(int x) { // crea el nuevo elemento Nodo q= new Nodo(x,null); // insercin del primer elemento if(ultimo == null) {ultimo = q; ultimo.setProx(q); } else { q.setProx(ultimo.getProx()); // enlaza al nuevo nodo con el prox del ultimo Pgina 22 de 32
ultimo.setProx(q); ultimo= q; } } // fin metodo /** * metodo que permite borrar el primer elemento de la lista y devuelve una referencia * a la informacin (u objeto) que tenia almacenado el elemento borrado */ public int borrar() { int res = -1; // si la lista est vacia devuelve un valor negativo // controla que la lista no est vacia if(ultimo != null) { Nodo q= ultimo.getProx(); // almacena en q, la referencia al primer nodo de la lista que est // apuntada por ultimo.prox res = q.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; // deja la lista vacia else ultimo.setProx(q.getProx()); /** * el elemento desreferenciado por q es enviado a la basura, al quedar desreferenciado * cuando finaliza este mtodo por ser q una variable local.*/ } return res; } // fin metodo /** * metodo que permite obtener el elemento de la posicin i dada por parametro */ public int obtener(int i) { int res; // guarda la cantidad de elementos de la lista en una variable local int numeroElementos = this.tamanio(); if(i >= numeroElementos || i<0) res = -1 ; // indica que no existe esa posicin en la lista o la lista est vaca else { Nodo q = ultimo.getProx(); // crea un nodo que referencia al primer elemento de la lista for(int j=1; j< i; j++) // recorre la lista hasta posesionarse en la posicin i q = q.getProx();
Pgina 23 de 32
res = q.getDato(); } return res; } // fin metodo /** * metodo que permite mostrar los elemento de la lista circular */ public String toString() { String res = "Los elementos de la lista son : \n"; int i =0, tam = this.tamanio(); if (tam > 0) { Nodo aux = ultimo.getProx(); while(i< tam) { res += " "+ aux.getDato(); aux = aux.getProx(); i++; } } else res = "Lista vacia"; return res; } // 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, excepto el primero, posee informacin respecto al nodo posterior y el nodo anterior. Esto permite leer la lista en ambas direcciones. Este tipo de listas es til cuando la insercin, borrado y movimiento de los elementos son operaciones frecuentes. Sus caractersticas son: * El primer nodo es apuntado por un puntero raz.. *Cada nodo apunta a la direccin del prximo nodo y a la direccin de nodo anterior. *La direccin del prximo nodo en el ltimo nodo es 0 (NULL ). *La direccin del anterior nodo en el primer nodo (raz) es 0 (NULL ).
Pgina 24 de 32
Raz NULL
NULL
Referencia al anterior nodo
Segn esto, cada elemento de la lista doblemente enlazada tendr una definicin como la que sigue: // definicin de cada elemento o nodo de la lista public Class Nodo { // atributos private int dato; private Nodo prox; private Nodo ant; // metodos public Nodo () // constructor por defecto { dato = 0; prox = null; ant= null; } public Nodo (int d) // constructor con parmetro { dato = d; prox = null; ant = null; } public Nodo (int d, Nodo p, Nodo a) // { dato = d; prox = p ; ant = a;} //.. Una aplicacin tpica es un procesador de texto, donde el acceso a cada lnea individual se hace a travs de una lista doblemente enlazada.Las operaciones sobre una lista doblemente enlazada normalmente se realizan sin ninguna dificultad. Sin embargo, casi siempre es mucho ms fcil la manipulacin de las mismas, cuando existe un doble enlace entre el ltimo elemento y el primero, estructura que recibe el nombre de Lista Doblemente Enlazada.Pgina 25 de 32 // constructor con parmetros, que indican valores del nodo anterior y posterior
d) LISTAS CIRCULARES DOBLEMENTE VINCULADAS Una lista circular doblemente enlazada (lcde) es una coleccin de objetos, cada uno de los cuales contiene datos (o una referencia a los datos), una referencia al elemento siguiente en la lista, y una referencia al elemento anterior. Sus caractersticas son: *El primer nodo es apuntado por un puntero raz. *Cada nodo apunta a la direccin del prximo nodo y a la direccin de nodo anterior. *La direccin del prximo nodo en el ltimo nodo es la del primer nodo de la lista. *La direccin del anterior nodo en el primer nodo es la del ltimo nodo de la lista.
Raz
Referencia al anterior nodo
Segn esto, 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 informacin del nodo anterior y posterior al actual.* * * @author (Prraga Adriana) * @version (a version 01/2007) */ public class NodoDE { // atributos private int dato; private NodoDE prox; private NodoDE ant; // metodos public NodoDE () { dato = 0; prox = null; // constructor por defecto
Pgina 26 de 32
ant= null; } public NodoDE (int d) { dato = d; prox = null; ant = null; } public NodoDE (int d, NodoDE p, NodoDE a) { dato = d; prox = p ; ant = a;} public int getDato() { return dato; } public NodoDE getProx() { return prox; } public NodoDE getAnt() { return ant; } public void setDato( int d) { dato= d; } public void setProx(NodoDE p) { prox= p; } public void setAnt(NodoDE a) { ant=a; } } //FIN CLASE Un ejemplo de los mtodos que permiten implementar una lista circular doblemente vinculada, son los que se presentan en la siguiente clase : /** * description de class CListaCircularDE . * contiene los mtodos para manipula una lista Circular doblemente enlazada * de datos enteros * * @author (Prraga Adriana) * @version (a version 01/2007) */ public class CListaCircularDE Pgina 27 de 32 // constructor con parmetros, que indican // valores del nodo anterior y posterior // constructor con parmetro
{ // referencia al ultimo elemento de la lista private NodoDE ultimo; // referencia al elemento actual en el que estamos private NodoDE actual; // nmero de elementos que tiene la lista private long numeroElementos; // posicion del elemento actual private long posicion; /** * Constructor for objects of class CListaCircularDE */ public CListaCircularDE() { actual=ultimo= null; numeroElementos= 0; posicion=-1; } public long tamanio() { return numeroElementos; } /** * // aade un nuevo elemento a la lista a continuacin del elemento actual * elnuevo pasa a ser el elemento actual */ public void insertar (int d) { NodoDE q; if(ultimo == null) // lista vacia { ultimo = new NodoDE(); // las dos lineas siguientes inician una lista circular ultimo.setProx(ultimo); ultimo.setAnt(ultimo); ultimo.setDato(d); // asigna datos actual= ultimo; posicion= 0; // LA POSICION DEL PRIMER ELEMENTO SERA LA CERO } else // existe una lista { q = new NodoDE(); // inserta el nuevo elemento despues del actual actual.getProx().setAnt(q); // del nodo actual el atributo nodo prox se carga en el atributo ant el valor de q Pgina 28 de 32
q.setProx(actual.getProx()); actual.setProx(q); // conecta el nodo actual con el nuevo como el proximo q.setAnt(actual); //conecta el nodo nuevo con el actual,que pasa a ser anterior q.setDato(d); // carga los datos al nodo nuevo // actualizar parametros posicion ++; // si el alemento actual es el ultimo, el nuevo elemento pasa a ser el actual y el ltimo. if(actual == ultimo) ultimo = q; actual = q; // el nuevo elemento pasa a ser el actual } numeroElementos++; }// fin metodo // incrementa el nuumero de elementos.-
/** * mtodo 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; int dato; if(ultimo == null) dato = -11 ; // lista vacia else if (actual == ultimo) // controla si se trata del ultimo elemento { if(numeroElementos== 1) // hay un solo elemento { dato = ultimo.getDato(); ultimo = actual= null; numeroElementos= 0; posicion= -1; } else { // hay mas de un elemento actual = ultimo. getAnt(); ultimo.getProx().setAnt(actual); actual.setProx(ultimo.getProx()); dato = ultimo.getDato(); ultimo = actual; posicion--; numeroElementos--; } } // fin del bloque verdadero if(actual== ultimo) Pgina 29 de 32
else { q= actual.getProx(); actual.getAnt().setProx(q); q.setAnt(actual.getAnt()); dato= actual.getDato(); actual = q; numeroElementos--; } return dato; } // fin metodo /** * avanza la posicion actual al siguiente elemento. */ public void irAlSiguiente() { if (posicion < numeroElementos -1) { actual = actual.getProx(); posicion ++; } } // fin metodo /** * retraza la posicion actual al elemento anterior */ public void irAlAnterior() { if(posicion > -1) { actual = actual.getAnt(); posicion--; } } // fin metodo /** * hace que la posicion actual sea el principio de la lista */ public void irAlPrincipio() { actual= ultimo.getProx(); posicion = -1; } // fin metodo /** * el final de la lista es ahora la posicion actual */
Pgina 30 de 32
public void irAlFinal() { actual = ultimo; posicion = numeroElementos-1; } // fin metodo /** * posicionarse en el elemento i */ public boolean irAl(long i) { boolean res = false; long numeroElementos = this.tamanio(); if ( i >0 && i < numeroElementos ) { irAlPrincipio(); // posicionarse en el elemnto i for(int n= 0; n< i; n++) irAlSiguiente(); res = true; } return res; } // fin metodo /** * el metodo obener devuelve la referencia o datos asociados con el elemento actual */ public int obtener() { int res = -1; if(ultimo != null) res = actual.getDato(); 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; return obtener(); }// 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 Pgina 31 de 32
actual.setDato(nuevodat); }// fin metodo /** * metodo para mostrar los elementos de la lista */ public String toString() { String mens = " lista de datos almacenados \n"; long i= 0, tam = this.tamanio(); int dato; while (i < tam) { mens += "\n\t dato " + i + " : "+ this.obtener(i)+ "\t dato " + (i+1) + " : "+ this.obtener(i+1); i=+i+2; } if(tam == 0) mens = "\n\t la lista esta vacia"; return mens; } // fin metodo } // fin clase
Pgina 32 de 32

Estructuras - Dinamicas

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Estructuras - Dinamicas

Загружено:

Авторское право:

Доступные форматы

Universidad Tecnolgica Nacional Datos 2007 Facultad Regional Crdoba Informacin ESTRUCTURAS DINMICAS Adriana

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

C Cabeza B A C B C A C b) Usando Array

c) Usando nodos vinculados

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

// la direccin del primer elemento de la pila

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

} // fin metodo } //fin clase

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Usando nodos vinculados

Ultimo elemento de la cola

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

}// fin clase b) LISTAS CIRCULARES

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Referencia al prximo nodo Informacin

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Referencia al anterior nodo

Referencia al prximo nodo Informacin

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Referencia al anterior nodo

Referencia al prximo nodo Informacin

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Algoritmos y Estructuras de Ing. en Sistemas de Curso 1k15 Prof. Prraga

Вам также может понравиться