1

Curso de Estructuras de Datos Orientada a Objetos

Ing. Daysi M. Erreyes P.

5.

ESTRUCTURA LISTA

5.1.Descripcin Lgica de la Estructura Lista Una lista es una coleccin de elementos homogneos, entre los elementos existe una relacin lineal, en donde cada elemento indica la direccin donde se encuentra el siguiente elemento de la lista.

Representacin: Una lista se puede representar de dos formas: Esttica: su tamao se limita en tiempo de compilacin Ej.: arreglos Dinmica: su tamao puede crecer indefinidamente en tiempo de ejecucin Ej.: listas enlazadas simples, listas enlazadas dobles, listas circulares, pilas y colas. Caractersticas En cada elemento o nodo de la lista a excepcin del primero, tiene un nico predecesor se debe indicar donde se encuentra el siguiente elemento. Cada elemento de la lista, a excepcin del ltimo tiene un nico sucesor. Las listas son flexibles y permiten cambios en la implementacin. Partes de un nodo Campo dato o info Campo de enlace

Campo dato o info: contiene uno o varios datos y/o objetos Campo de enlace: es la referencia hacia el otro nodo de la lista. Representacin de la estructura en memoria:

Por lo general un nodo de una lista se abstrae en una clase. Ejemplo: Class Nodo{ int dato; Nodo siguiente;

public Nodo (Nodo sig){ Siguiente = sig; } // mtodos de la clase } // fin de la clase Nodo 5.2.Operaciones En una lista se pueden efectuar las siguientes operaciones: Insertar: Agregar un nuevo nodo a la lista Eliminar: Quitar un nodo de la lista Buscar: Permite encontrar un nodo dentro de la lista Modificar: Actualiza la informacin de un determinado nodo dentro de la lista 5.3.Tipos de listas 5.3.1. Listas Simplemente Enlazadas Analiza: Piensa en varias aplicaciones informticas de la vida real, en donde se utilice la estructura: Lista Simplemente Enlazada, comenta con tus compaeros y con tu profesora..!!! Es una coleccin de elementos homogneos cuya relacin lineal es determinada por la posicin del elemento en la lista. Una lista simplemente enlazada se caracteriza por lo siguiente: En cada nodo existe un solo enlace o referencia hacia el siguiente nodo. Solo el ltimo nodo de la lista contendr una referencia nula o apuntara a null. Esta dada en un solo sentido.

Java inicializa los campos de referencias de un objeto a null durante la construccin del objeto, no es necesario asignar explcitamente null a un campo de enlace. Pero sin embargo no olvide estas asignaciones de null en su cdigo fuente, su ausencia reduce la claridad del cdigo.

TDA:LISTA ENLAZADA SIMPLE Elementos: los elementos de una lista simplemente enlazada, son conocidos como nodos, que almacenan datos simples o estructurados. Estructura: Lineal entre los nodos que forman la lista enlazada simple, cada nodo tiene un nico sucesor y predecesor Dominio: si la lista no est vaca el rango sern los elementos que tendrn las posiciones 0,1,2,3N donde N es la cantidad de elementos de la lista. OPERACIONES: INSERTAR-INICIO Utilidad: aadir un elemento al inicio de la lista L Datos de entrada: la lista L y el nuevo elemento. Datos de salida: la lista L con el nuevo elemento al inicio. Precondicin: Ninguna Postcondicion: La lista L contiene un elemento nuevo al inicio. INSERTAR-FIN

Utilidad: aadir un elemento al final de la lista L Datos de entrada: la lista L y el nuevo elemento. Datos de salida: la lista L con el nuevo elemento al final. Precondicin: Ninguna Postcondicion: La lista L contiene un elemento nuevo al final. INSERTAR-ENTRE-NODOS

Utilidad: aadir un nuevo nodo en un orden especifico dentro de la lista L Datos de entrada: la lista L ,el nuevo elemento y el nodo predecesor Datos de salida: la lista L con el nuevo elemento insertado en el lugar que le corresponde. Precondicin: Ninguna Postcondicin: La lista L contiene al elemento nuevo en el orden que le corresponde. ELIMINAR-INICIO

Utilidad: quitar un elemento del inicio de la lista L Datos de entrada: la lista L. Datos de salida: la lista L con un nodo menos y el valor del nodo eliminado Precondicin: la lista L no est vaca Postcondicion: La lista con un nodo menos (el del inicio) ELIMINAR-FIN

Utilidad: quitar un elemento del final de la lista L Datos de entrada: la lista L. Datos de salida: la lista L con un nodo menos y el valor del nodo eliminado Precondicin: la lista L no est vaca

Postcondicion: La lista con un nodo menos (el del final) ELIMINAR- ENTRE-NODOS

Utilidad: quitar un nodo de un orden especfico de la lista Datos de entrada: la lista L, y el elemento a eliminar Datos de salida: la lista L con un elemento menos Precondicin: la lista L no est vaca y que contenga el nodo a eliminar Postcondicin: La lista L contiene un elemento menos y corresponde al que se elimino BUSCAR-NODO

Utilidad: recorrer la lista L, hasta encontrar un determinado nodo dentro de la lista L Datos de entrada: la lista L ,el elemento a buscar Datos de salida: verdadero si se ha encontrado el nodo caso contrario falso Precondicin: la lista no est vaca Postcondicin: Ninguna

Nivel fsico: Implementacin de operaciones de Listas Enlazadas Simples

CASOS PARA LA INSERCIN DE NODOS: 1.- Cuando la lista enlazada simple no existe 2.- Cuando el nodo se debe insertar antes del primer nodo 3.- Cuando el nodo se debe insertar despus del ltimo nodo 4.- Cuando el nodo se debe insertar entre nodos PASOS PARA LA SOLUCIN Caso 1: Cuando la lista enlazada simple no existe 1.- Leer (valor) 2.- Se crea un nodo y se asigna su referencia a top 3.- Inicializar su campo de no enlace 4.- Se asigna el valor null al campo de enlace Caso 2: Cuando el nodo se debe insertar antes de primero 1.- Leer (valor) 2.- Crear un nuevo nodo temporal 3.- Inicializar el campo de no enlace del nodo temporal 4.-Asignar la referencia de inicio de la lista (top),al campo de enlace del nodo temporal 5.-Asignar la referencia del nodo temporal al inicio de la lista Caso 3: Cuando el nodo a insertarse despus del ltimo nodo 1.- Leer (valor) 2.-Crear un nodo temporal 3.- Declarar una variable de referencia temp2(auxiliar)

4.- Inicializar el campo de no enlace del nodo temporal 5.-Asignar null al campo de enlace del nuevo nodo 6.- Recorrer la lista hasta el final 7.-Asignar la referencia del nodo temporal al campo de enlace del ltimo nodo de la lista Caso 4 : cuando el nodo debe insertarse entre nodos 1.- Leer(valor) 2.- Leer (valor) nodo predecesor 3.-Crear un nodo temporal 4.- Declarar una variable de referencia temp2 5.- Inicializar el campo de no enlace del nodo temporal 6.- Recorrer la lista hasta encontrar el nodo predecesor 7.-Asignar al campo de enlace del nodo temporal la referencia del nodo sucesor 8.- Asignar la referencia del nodo temporal al campo de enlace del nodo predecesor CASOS PARA LA ELIMINACIN DE NODOS: 1.- Borrar el primer nodo 2.- Borrar cualquier nodo que no sea el primero

PASOS PARA LA SOLUCIN Caso1: borrar el primer nodo 1.- Asignar el enlace del campo siguiente del nodo referenciado por top a top. Caso 2 :borrar cualquier nodo que no sea el primero 1.- Leer(valor) 2.- Localizar el nodo predecesor al nodo que se desea eliminar 3.- Asignar al campo de enlace del nodo predecesor la referencia del nodo sucesor al que se desea eliminar. Si el nodo a eliminar es el ltimo asignar null al campo de enlace del nodo predecesor. BUSCAR UN NODO 1.- Leer (valor) 2.- Recorrer la lista hasta encontrar el valor MODELADO: ListaSimple - dato: Object // campo dato - sig:ListaSimple // campo de enlace al siguiente nodo - top: ListaSimple // apuntador de cabecera de la lista simple + ListaSimple( ) + getDato ( ) : Object +getSig ( ) : ListaSimple +setDato( dato: Object): void

+setSig(sig.ListaSimple):void +esVacia( ):Boolean //Insercin de Nodos +insertaVacia(d:Object):void //Caso 1 +insertaInicio(d:Object):void //Caso 2 +insertaFinal(d:Object):void //Caso 3 +entreNodos(np: Object, d:Object):void // Caso 4 //Eliminacin de Nodos +eliminaInicio( ): void // Caso 1 +eliminaNodo( ): void //Caso 2 y 3 +buscarNodo( ):boolean +presenta( ):void IMPLEMENTACIN EN JAVA
package listas; /** * * @author Mireya */ public class ListaSimple { private Object dato; private ListaSimple sig; private ListaSimple top; public ListaSimple (){ setDato(null); setSig(null); } public Object getDato() { return dato; } public void setDato(Object dato) { this.dato = dato; } public ListaSimple getSig() { return sig; } public void setSig(ListaSimple sig) { this.sig = sig; } public boolean esVacia(){ if (top==null){ return true; }else{ return false; } } public void insertaVacia(String d){ if(esVacia()){

top= new ListaSimple(); top.setDato(d); System.out.println("El nodo insertado es el primero"); }else{ System.out.println("La lista ya contiene elementos"); } } public void insertarInicio(Object d){ if(!esVacia()){ ListaSimple temp= new ListaSimple(); temp.setDato(d); temp.setSig(top); top=temp; }else{ System.out.println("No puede insertarse al inicio... La lista no contienen nodos"); } } public void insertaFinal(Object d){ if(!esVacia()){ ListaSimple temp= new ListaSimple(); temp.setDato(d); ListaSimple aux ; aux=top; while(aux.getSig()!= null){ aux=aux.getSig(); } aux.setSig(temp); }else{ System.out.println("No se puede insertar al final...La lista esta vacia"); } } public void entreNodos(Object np,Object d){ if(!esVacia()){ ListaSimple temp= new ListaSimple(); temp.setDato(d); ListaSimple aux; aux=top; while(aux.getDato().equals(np)==false){ aux= aux.getSig(); } if(aux.getDato().equals(np)){ temp.setSig(aux.getSig()); aux.setSig(temp); }else{ System.out.println("No se puede insertar...Nodo predecesor no existe"); } }else{ System.out.println("No se puede insertar...La lista esta vacia"); } } public void presentar(){

if(esVacia()){ System.out.println("No hay nodos para presentar"); }else{ ListaSimple aux; aux= top; while(aux!= null){ System.out.println("["+aux.getDato()+"]"); aux=aux.getSig(); } } } }

Tarea 7: Implementar en la clase ListaSimple los casos de eliminacin de nodos y la operacin de bsqueda. Considere el modelo planteado.

5.3.2. Listas Doblemente Enlazadas Analiza: Piensa en varias aplicaciones informticas de la vida real, en donde se utilice la estructura: Lista Doblemente Enlazada, comenta con tus compaeros y con tu profesora..!!!

Problemas con las Listas Simples: Restringen el movimiento por los nodos a una sola direccin. No se puede atravesar la lista en direccin opuesta a menos que se utilice primeramente un algoritmo de inversin, lo que llevar algn tiempo. El borrado de nodos, se complica debido a que no se puede eliminar un nodo arbitrario sin acceder al predecesor del nodo. Una lista doblemente enlazada, es una lista enlazada de nodos, donde cada nodo tiene un par de campos de enlace, el que permite atravesar la lista hacia adelante mediante el campo de enlace sig (siguiente), y hacia atrs con el campo de ente ant(anterior). Es una coleccin de elementos homogneos que tiene una relacin lineal se da en ambos sentidos.

Caractersticas En cada nodo existe una referencia a su nodo predecesor y sucesor a ms del campo dato o de informacin. El recorrido se lo puede hacer en ambos sentidos Solo, en el nodo inicial o cabecera la referencia al nodo predecesor ser null o puede apuntar al ltimo nodo. Solo en el nodo final la referencia al nodo sucesor ser null o puede apuntar al primer nodo. Se requiere de dos variables de referencia para el recorrido.

Partes de un Nodo Doble Campo de Campo dato o Campo de

enlace anterior

info

enlace siguiente

Nivel fsico: Implementacin de operaciones de Listas Doblemente Enlazadas Si se utiliza un nodo cabecera en una lista de doble enlace ya no es necesario contar con las referencias primero y ltimo, puesto que el nodo cabecera tiene ambas referencias: su referencia siguiente es el primer elemento de la lista, y su referencia anterior es el ltimo elemento de la lista. De esta forma la lista de doble enlace queda circular de una manera natural, esto facilitar la implementacin de la lista doblemente enlazada, quedando la lista de la siguiente manera:

MODELADO: NodoDoble ant: NodoDoble sig: NodoDoble dato:Object + NodoDoble() + setAnt(nodo:NodoDoble):void + setSig(nodo:NodoDoble):void +setDato(datos:Object):void

+ getAnt():NodoDoble +getSig():NodoDoble + setDato():Object + insertarAntes (despus: NodoDoble,d:Object):void + insertarDespues(antes: NodoDoble,d:Object):void + insertarEntre(antes: NodoDoble,d:Object,despus: NodoDoble):void

ListaDoble + top: NodoDoble - numeroNodos:int + ListaDoble() + longuitud():int - incLonguitud():void +insertarAtHead(d:Object):void + insertarAtFinal(d: Object):void +insertarAt(indice:int, d: Object):void +deleteFirst()void +deleteNodo(ndice:int):void + getAt(indice: int): Object +printNodos():void IMPLEMENTACION
Clase: NodoDoble /* * NodoDoble.java * * Created on 09 de Agosto de 2009, 04:29 PM * * To change this template, choose Tools | Template Manager * and open the template in the editor. */ package listas; /** * * @author Ing. Mireya Erreyes */ public class NodoDoble { // Referencias al nodo anterior y posterior en la lista private NodoDoble sig; private NodoDoble ant; // Referencia a los datos actuales del objeto // Esto no funcionaria con tipos basicos, porque no // se pueden pasar como objetos private Object dato;

// Constructor Basico public NodoDoble() { // Reseteamos los apuntadores setSig( null ); setAnt( null ); // En principio, no hay datos setDato( null ); } // Construimos un nuevo nodo y lo insertamos en medio // de los dos que nos indiquen public NodoDoble( NodoDoble antes, NodoDoble despues,String d) { insertEntre( antes,despues,d); } // Inserta un nodo entre dos determinados // Acceso a los elementos de un nodo public NodoDoble getAnt() { return( ant ); } public NodoDoble getSig() { return( sig ); } public Object getDato() { return( dato ); } // Modificacion de los elementos de un nodo public void setAnt( NodoDoble nodo ) { ant = nodo; } public void setSig( NodoDoble nodo ) { sig = nodo; } public void setDato( Object d) { dato = d; } // Inserta un nodo antes del que nos indiquen public void insertAntes( NodoDoble despues,Object d) { // Fijamos nuestros apuntadores setAnt( despues.getAnt() ); setSig( despues ); // Fijamos los apuntadores de los otros nodos a nosotros getAnt().setSig( this ); despues.setAnt( this ); // Fijamos los datos del nodo setDato(d); } // Inserta un nodo despues del que nos indiquen public void insertDespues( NodoDoble antes,Object d) { // Fijamos nuestros apuntadores setAnt( antes );

setSig( antes.getSig() ); // Fijamos los apuntadores de los otros nodos a nosotros antes.setSig( this ); getSig().setAnt( this ); // Fijamos los datos del nodo setDato(d); } public void insertEntre( NodoDoble antes, NodoDoble despues,Object d) { // Fijamos nuestros apuntadores setAnt( antes ); setSig( despues ); // Fijamos los apuntadores de los otros nodos a nosotros antes.setSig( this ); despues.setAnt( this ); // Fijamos los datos del nodo setDato(d); } public void deleteEntre(NodoDoble antes, NodoDoble despues){ //Fijamos los apuntadores antes.setSig(despues); despues.setAnt(antes); } } Clase: Lista Doble /* * ListaDoble.java * * Created on 09 de Noviembre de 2009, 04:33 PM * * To change this template, choose Tools | Template Manager * and open the template in the editor. */ package listas; /** * * @author Ing. Mireya Erreyes */ public class ListaDoble { // Usaremos un nodo 'top' para controlar el principio y final // de la lista doblemente enlazada que estamos implementando, // lo que nos simplifica bastante las cosas public NodoDoble top; // Mantenemos un contador del numero de nodos en la lista private int numNodos; // Constructor basico public ListaDoble() { // Inicialmente, no hay ningun nodo numNodos = 0; // Creamos nuestro nodo

top = new NodoDoble(); // Hacemos que los apuntadores del nodo lo hagan a // si mismo, incluso que sus datos se refieran a los suyos top.insertEntre( top,top,null ); } // Acceso al nmero de nodos public int longitud() { return( numNodos ); } // Modificacion del numero de nodos private void incLongitud() { numNodos++; } private void decLongitud() { numNodos--; } // Insertamos los datos que nos indiquen como nueva cabecera // de la lista public void insertAtHead( Object d) { NodoDoble temp = new NodoDoble(); temp.insertDespues( top,d); incLongitud(); } // Insertamos los datos que nos indiquen al final de la lista public void insertAtFinal( Object d) { NodoDoble temp = new NodoDoble(); temp.insertAntes( top,d); incLongitud(); } // Insertamos los datos en la posicion que nos digan, o al // final de la lista en caso de que no sea tan larga como // indique el indice public void insertAt( int indice,Object d) { // Comprobamos que la lista tenga suficientes nodos if( longitud() < indice ) { // Si no los tiene, insertamos al final insertAtFinal(d); } else { NodoDoble temp; NodoDoble aux; // Vamos saltando de nodo en nodo hasta llegar al indicado aux = top; for( int i=0; i < indice-1; i++ ) aux = aux.getSig(); // Creamos un nuevo nodo en esa posicion y lo incorporamos a // la lista // temp= new NodoDoble(aux,aux.getSig(),d); temp=new NodoDoble();

temp.insertEntre(aux, aux.getSig(), d); incLongitud(); } } // Recupera los datos de un determinado nodo (o del ltimo elemento // si la lista no tiene tantos nodos), o devuelve null si la // lista esta vacia public void deleteFirst(){ if(longitud()==0){ System.out.println("Lista vacia...No se puede eliminar el nodo del inicio"); }else{ System.out.println("Nodo a eliminar :"+top.getSig().getDato()); top.setSig(top.getSig().getSig()); decLongitud(); } } public void deleteEnd(){ if(longitud()==0){ System.out.println("Lista vacia...No se puede eliminar el nodo del final"); }else{ System.out.println("Nodo a eliminar :"+top.getAnt().getDato()); top.setAnt(top.getAnt().getAnt()); decLongitud(); } } public Object getAt( int indice ) { // Comprobamos si la lista tiene tantos nodos como indica el indice if( longitud() < indice ) { // Comprobamos que la lista no est vacia if( longitud() == 0 ) // La lista est todava vacia return( null ); else return (top.getDato()); } else { // Estamos dentro del rango de la lista NodoDoble aux; // Vamos saltando por los nodos hasta alcanzar el pedido aux = top.getSig(); for( int i=0; i < indice; i++ ) aux = aux.getSig(); // Devolvemos los datos de ese nodo return( aux.getDato()); } } public void PrintNodos(){ // Comprobamos si la lista tiene tantos nodos como indica el indice if( longitud() == 0){ // Comprobamos que la lista no est vacia

System.out.print("La lista esta vacia"); }else{ // Estamos dentro del rango de la lista NodoDoble aux; // Vamos saltando por los nodos hasta alcanzar el pedido aux = top; System.out.println("PRESENTACION EN ORDEN ASCENDENTE \n"); for( int i=0; i<longitud(); i++ ){ // avanzar al siguiente nodo de la lista aux = aux.getSig(); System.out.println("Valor nodo : " +i+"\t"+aux.getDato()); //presentamos el valor del nodo } } } }

Tarea 8: Implementar el mtodo deleteNodos del la clase ListaDoble, controlar todos los casos posibles.

Exposicin Nro. 5: Investiga en el Api de Java para Listas, la clase: LinkedList, que pertenece al paquete Java.util; indicar detalladamente, los constructores de la clase y para la explicacin de las principales operaciones exponer la utilidad, sintaxis y un ejemplo de su utilizacin. Adems debe realizar un programa demostrativo de manipulacin de Listas en Java, por ejemplo una lista mensajes. Nota: Se tomar en cuenta el material de apoyo utilizado para la exposicin y debe entregar una copia digital a cada grupo, adems una copia impresa y digital a la profesora el da de la exposicin.

5.3.3. Lista Circulares Analiza: Piensa en varias aplicaciones informticas de la vida real, en donde se utilice la estructura: Lista Circular, comenta con tus compaeros y con tu profesora..!!!

Una lista circular es aquella en donde la referencia siguiente del ltimo nodo en vez de ser null apunta al primer nodo de la lista. El concepto se aplica tanto a listas de enlace simple como doblemente enlazadas. Se obtiene al considerar el primer nodo de la lista es el sucesor del ltimo nodo. Se utilizan con frecuencia en procesamiento repetitivo de nodos en un orden especfico. Caractersticas No podemos hablar de primer y ltimo nodo, Para su implementacin es necesario utilizar un apuntador general a la lista No existen direcciones nulas, excepto cuando la lista est vaca Si la lista contiene un solo nodo, el campo de enlace entonces apuntara a si mismo Es posible llegar a cualquier nodo a partir de cualquier posicin donde se encuentre apuntando a la variable de referencia llamada lista

Representacin

Nivel fsico: Implementacin de operaciones de Listas Circulares MODELADO: ListaCircular - sig: ListaCircular - dato: Object + lista: ListaCircular + ListaCircular ( ) + ListaCircular(d: Object) +getDato( ):Object + getSig( ): ListaCircular +setDato (d: Object):void +setSig(nodo: ListaCircular):void +insert(d:Object):void +delete(d:Oject): void + printNodos( ): void

IMPLEMENTACIN: Algoritmo para Insertar Nodos - Leer (valor) - Crear un nodo temporal - Fijar el dato - Si la lista est vaca es el primero a insertarse, asignar la referencia del nuevo nodo a lista sino insertar el nuevo nodo a continuacin de lista. - Enlazar el nuevo nodo a lista - Asignar la referencia del nuevo nodo a lista Algoritmo para eliminar Nodos - Crear una variable auxiliar - Asignar la referencia de lista a la variable auxiliar - Recorrer la lista hasta encontrar el dato a eliminar y lista sea diferente de auxiliar - Si el dato existe verificar que si el ltimo asignar null a lista sino fijar en auxiliar la referencia del sucesor del nodo a eliminar. Algoritmo para imprimir Nodos - Crear una variable auxiliar - Asignar a la variable auxiliar la referencia del inicio de lista - Recorrer la lista mientras auxiliar sea diferente de lista - En el recorrido presentar el valor de cada nodo visitado
package listas2; /** * * @author Ing. Mireya Erreyes */ public class ListaCircular { private ListaCircular sig; private Object dato; public ListaCircular lista=null; // Constructor Basico public ListaCircular(Object d) { // Fijamos el dato lista=new ListaCircular(); lista.setDatos(d); // Reseteamos el apuntador lista.setSig(lista); } public ListaCircular(){ setSig(null); setDatos(null); } // Acceso a los elementos de un nodo public ListaCircular getSig() { return( sig ); }

public Object getDatos() { return(dato); } public void setSig(ListaCircular nodo ) { sig = nodo; } public void setDatos( Object d) { dato = d; } public void insert(Object d) { ListaCircular temp=new ListaCircular(); temp.setDatos(d); if(lista==null){ lista=temp; lista.setSig(lista); }else{ temp.setSig(lista.getSig()); lista.setSig(temp); lista=temp; } } public void delete(Object d){ if(lista!=null){ ListaCircular aux; aux=lista; do{ aux=aux.getSig(); }while((aux.getSig().getDatos()!= d)&&(lista!=aux)); boolean existe = false; if(aux.getSig().getDatos()==d){ existe = true; } if(existe==true){ if(aux.getSig()!=lista){ //Varios nodos aux.setSig(aux.getSig().getSig()); }else{ if(aux.getSig() == aux){ //Existe un solo nodo lista=null; }else{ //Existen 2 nodos y uno de ellos se elimina lista=aux; aux.setSig(aux.getSig().getSig()); } } }else{ System.out.println("Nodo a eliminar no existe \n"); } }else{ System.out.println("No se puede eliminar la lista esta vacia \n"); } }

public void imprime(){ ListaCircular aux; aux=lista; if(aux!=null){ do{ System.out.println("["+aux.getDatos()+"]"); aux=aux.getSig(); }while(aux!=lista); }else{ System.out.println("La lista esta vacia"); } } }

5.3.4. Listas Ordenadas. Analiza: Piensa en varias aplicaciones informticas de la vida real, en donde se utilice la estructura: Lista ordenada, comenta con tus compaeros y con tu profesora..!!!

Usa la estructura diccionario en la que se guarda pares de clave-elemento: la clave (k) y el elemento (e). Para lograr mayor generalidad se permite que las claves y los elementos que se guarden en el diccionario sean cualquier clase de objeto. Ejemplo: El registro de alumnos (k,e); k numero de cedula o identificacin y e nombre, direccin, telfono, calificacin. Tipo de Listas Ordenadas. 1. Diccionario no ordenado o genrico: Se supone que no hay relacin de orden entre las claves y solo se usa la prueba de igualdad entre ellas. 2. Diccionarios Ordenados. Existen entre las claves una relacin de orden total, adems determina el orden relativo de dos claves mediante un comparador. Representacin en Memoria.

TDA: DICCIONARIO Elementos: Se guardan como elementos cualquier objeto, como un par ordenado: clave K

y elemento e. Estructura: Lineal entre cada artculo del diccionario D Dominio: depende de la aplicacin OPERACIONES: - INSERT-ELEMENTO Utilidad: Aadir un articulo con elemento e y clave K en el diccionario D. Datos de Entrada: Clave K,objeto o elemento e Datos de Salida: Diccionario D modificado - REMOVE- ELEMENTO Utilidad: quitar de D un articulo con clave K y regresar el elemento eliminado, si el artculo no existe en el diccionario regresar un mensaje clave no existe Datos de Entrada: Clave K Datos de Salida: Elemento e, o el mensaje en caso de que no hubo xito en la operacin - ENCONTRAR- ELEMENTO Utilidad: si D contiene un articulo cuya clave sea igual a K, regresa al elemento de ese artculo y si no u n mensaje indicando clave no existe Datos de Entrada: Clave K del objeto Datos de Salida: Elemento e, caso contrario el mensaje si no existe la clave .

Nivel fsico: Implementacin de operaciones de Listas Ordenadas MODELADO: ListaOrdenada - clave: int - valor: String - sig:ListaOrdenada + top: ListaOrdenada +ListaOrdenada( ) +ListaOrdenada(clave:int, valor:String) +getClave( ): int +getSig( ):ListaOrdenada +getValor( ):String +setClave(clave:int):void +setSig(sig:ListaOrdenada):void +setValor(valor:String):void +esVacia( ):Boolean +insert(clave:int, valor:String):void +delete(clave:int):String +search(clave:int):String +print( ):void

IMPLEMENTACIN:
public class ListaOrdenada { private int clave; private String valor; private ListaOrdenada sig; public ListaOrdenada top=null; //Constructor public ListaOrdenada(){ setClave(0); setValor(null); setSig(null); } public ListaOrdenada(int clave,String valor){ top=new ListaOrdenada(); top.setClave(clave); top.setValor(valor); top.setSig(null); } public int getClave() { return clave; } public ListaOrdenada getSig() { return sig; } public String getValor() { return valor; } public void setClave(int clave) { this.clave = clave; } public void setSig(ListaOrdenada sig) { this.sig = sig; } public void setValor(String valor) { this.valor = valor; } public boolean esVacia(){ if (top==null){ return true; }else{ return false; } } public void insert(int clave,String valor){

if(esVacia()){ top= new ListaOrdenada(); top.setClave(clave); top.setValor(valor); }else{ ListaOrdenada aux, aux1; aux=top; aux1=aux; boolean existe=false; while((aux.getSig()!=null)&&(clave>aux.getClave())){ aux1=aux; aux=aux.getSig(); } if(aux.getClave()==clave){ existe=true; } if(existe ==false){ ListaOrdenada temp=new ListaOrdenada( ); temp.setClave(clave); temp.setValor(valor); //Insertar como cabecera if((top==aux) && (clave < aux.getClave())){ temp.setSig(top); top=temp; }else //System.out.println("top = aux :"+top.getClave()+" ="+ aux.getClave() ); if(clave > aux.getClave()){ temp.setSig(aux.getSig()); aux.setSig(temp); }else{ aux1.setSig(temp); temp.setSig(aux); } }else{ System.out.println("No se puede insertar... Clave repetida"); } } } public String delete(int clave){ ListaOrdenada aux,aux1; aux1=aux=top; String dato=null; while((aux.getSig()!=null) && (clave>aux.getClave())){ aux1=aux; aux=aux.getSig(); } boolean existe=false; if(aux.getClave()==clave){ existe=true; dato=aux.getValor(); }else{ dato="Nodo a eliminar no existe"; }

if(existe==true){ if(top == aux){ top=top.getSig(); }else{ if(aux.getSig() == null){ aux1.setSig(null); }else{ aux1.setSig(aux.getSig()); } } } return dato; } public String search(int clave){ String dato=null; boolean existe=false; ListaOrdenada aux; aux=top; while((aux.getSig()!=null) && (clave > aux.getClave())){ aux=aux.getSig(); } if(aux.getClave()==clave){ existe=true; dato=aux.getValor(); }else{ dato="No existe"; } return dato; } public void print(){ ListaOrdenada aux; aux=top; while(aux!=null){ System.out.println("Clave = "+aux.getClave()+"\t "+"Valor = "+aux.getValor()); aux=aux.getSig(); } } }

Importante: Java tiene un propio framework para trabajar con este tipo de estructura de datos, todas estas clases se encuentran dentro del paquete java.util del JDK, lo que facilitan el trabajo sobre estas estructuras. A ms de las que se ha mencionado anteriormente podemos utilizar las siguientes: Interfaces java.util.List, java.util.Map, java.util.SortedMap. Clases java.util.ArrayList, java.util.AbstractList, java.util.LinkedList, java.util.HashMap, java.util.EnumMap, java.util.HashTable, entre otras. Existen muchas otras clases dentro de este paquete, lo cual es deber del alumno investigar y profundizar.

Tarea 9: Investigar el API de Java para la implementacin de listas ordenadas, la interfaz: java.util.Map le puede ayudar traer un ejemplo demostrativo.

5.3.5. PILAS Analiza:

Ejemplos donde estn aplicadas las pilas es: En la opcin deshacer o rehacer en aplicaciones de ofimticas. En el retroceso de pginas de los exploradores de internet.

Piensa en varias aplicaciones informticas de la vida real, en donde se utilice la estructura: Lista ordenada, comenta con tus compaeros y con tu profesora..!!!

Es una estructura lineal de objetos ordenados tales que estos se obtienen por un solo lado de la estructura siguiendo un sistema definido entre los que tenemos: UEPS = ultimo en entrar, primero en salir LIFO= Last in Firts out Una pila es una estructura de datos en la cual el acceso est limitado al ltimo elemento insertado (el ms reciente). Todas las operaciones que se definan sobre una pila deben de tener costo constante, independientemente del nmero de elementos de la pila. Las Operaciones bsicas son:

Insert Delete Search

Push Pop Tope

Representacin

TDA: Pila Elementos: Cualquier objeto, esto depende de la aplicacion a implementarse. Estructura: Lineal Dominio: La pila tendr la capacidad de almacenar la cantidad de elementos dependiendo de la aplicacin. OPERACIONES: 1. METER (PUSH) Utilidad: Agrega un elemento a la pila. Datos de Entrada: Elemento (e), pila (p) Datos de Salida: La pila con un elemento mas Precondiciones: Que la pila este creada y no est llena Postcondiciones: La pila con un elemento adicional agregado por el tope de la pila 2. SACAR(POP) Utilidad: eliminar el ltimo elemento que se agrego a la pila. Datos de Entrada: pila (p) Datos de Salida: La pila con un elemento menos y el elemento que se saca a la pila Precondiciones: Que la pila no est vaca Postcondiciones: La pila con un elemento menos que fue eliminado por el tope de la pila. 3. VACIA Utilidad: Verifica si una determinada pila est vaca o no. Datos de Entrada: la pila que se va a verificar Datos de Salida: valor booleano (trae, false) Precondiciones: Que la pila exista

Postcondiciones: 4. LLENA Utilidad: Verifica si una determinada pila est llena o no Datos de Entrada: la pila (p) que se va a verificar Datos de Salida: valor booleano (trae, false) Precondiciones: que la pila exista Postcondiciones:

Nivel fsico: Implementacin de operaciones de Pilas MODELADO: Pila - dato: String - sig: Pila + top: Pila + Pila ( ) + getDato( ): String + getSig( ): Pila + setDato( dato:String):void + setSig( sig: Pila):void + esVacia( ):Boolean + hacePush(d: String):void + hacePop( ): void + search( ): String +print( ): void

IMPLEMENTACIN: Algoritmo: PUSH/INSERTAR/METER/APILAR 1.-Leer valor 2.-Crear un nuevo nodo que sea tipo pila 3.-Inicilizar su campo de no enlace 4.-Enlazar la referencia de top con el nuevo nodo 5.-Avanza top Algoritmo: POP/ELIMINAR/SACAR/DESAPILAR 1._ Verificar si la pila est vaca si no lo est retornar el elemento. 2._ Asignar a top, la referencia del siguiente elemento apuntado por top
package listas2; /** * * @author Ing. Mireya Erreyes

*/ public class Pila { private String dato; private Pila sig; public Pila top=null; public Pila() { setSig(null); setDato(null); } public String getDato() { return dato; } public void setDato(String dato) { this.dato = dato; } public Pila getSig() { return sig; } public void setSig(Pila sig) { this.sig = sig; } public boolean esVacia( ){ if(top==null){ return true; }else{ return false; } } public void hacePush(String d) { Pila temp= new Pila(); temp.setDato(d); temp.setSig(top); top=temp; System.out.println( "push( "+top.getDato()+" )" ); } public void hacePop() { if (esVacia()){ System.out.print("No hay elementos en la pila");} else{ System.out.println( "pop( "+top.getDato()+" )" ); top=top.getSig(); } } public String search(){ if(esVacia()){ return null; }else{ return top.getDato(); } } public void print(){

Pila aux; aux=top; System.out.print("Pila : ["); while(aux!=null){ if(aux.getSig()!=null){ System.out.print(aux.getDato()+ ","); }else{ System.out.print(aux.getDato()); } aux=aux.getSig(); } System.out.print("]\n"); } public static void main(String[] args) { Pila p = new Pila(); p.print(); p.hacePush("Franklin"); p.hacePush("Mireya"); p.hacePush("Wilson"); p.hacePush("Gabrielita"); System.out.println("Elemento de la cima de la pila es:"+p.search()); p.hacePush("Xavier"); p.hacePush("July"); p.print(); System.out.println("Elemento de la cima de la pila es:"+p.search()); p.hacePop(); p.hacePop(); p.hacePop(); p.hacePop(); p.hacePush("Nuevo"); p.print(); } }

Tarea 10: Investigar el API de Java para la implementacin de Pilas, la clase Stack del paquete java.util le puede ayudar traer un ejemplo demostrativo.

5.3.6. Colas o Filas Analiza:

Ejemplos donde se pueden aplicar las colas son: Los drivers de la impresora, todos los trabajos que reciben para su impresin, siempre los colocan en una cola de acuerdo a cmo han llegado. Las colas de los bancos. En los sistemas operativos al momento de asignar algn recurso a los procesos.

Piensa en varias aplicaciones informticas de la vida real, en donde se utilice la estructura: Lista ordenada, comenta con tus compaeros y con tu profesora..!!!

Una cola es una estructura de datos en la cual el acceso est limitado al elemento insertado recientemente. Adems una cola es una coleccin ordenada de elementos homogneos en la que solo se puede aadir por el final y eliminar por el frente y se requiere dos punteros, para su manipulacin. Aplica la filosofa FIFO(first in first out) o PEPS (primero en entrar, primero en salir) Las operaciones bsicas son: Insert Encolar Delete Desencolar Search Tope

Representacin

TDA: COLA O FILA Elementos: cualquier clase de objetos, dependiendo de la aplicacin. Estructura: Lineal. Dominio: se maneja cantidades de objetos de acuerdo a la aplicacin. OPERACIONES: 1._ INSERTAR /ENCOLAR: Utilidad: Agregar un elemento e, a la fila o cola. Dato de entrada: El elemento e y la cola. Dato de Salida: La cola con un elemento adicional.

Precondiciones: que la cola este creada y no est llena Postcondiciones: La cola con un elemento ms agregado por el final. 2._ ELIMINAR/DESENCOLAR: Utilidad: elimina el primer elemento que se agreg a una cola Dato de entrada: La cola a la que se va a quitar el elemento Dato de salida: La cola con un elemento menos y el elemento que se elimin Precondiciones: La cola este creada y no est vaca. Postcondiciones: La cola con un elemento menos eliminado por el frente de la cola. 3._ VACIA: Utilidad: Verificar si una determinada cola se encuentra vaca o no. Datos de entrada: La cola que se va a verificar. Datos de salida: Booleano, que indique si la cola est vaca o no. Precondiciones: Que la cola a verificar exista Postcondiciones: Ninguna 4._ LLENA: Utilidad: Verificar si una determinada cola este llena o no. Dato de entrada: La cola que se va a verificar Dato de salida: Valor booleano que indique si la cola est llena o no Precondiciones: la cola este creada. Postcondiciones: Ninguna

Nivel fsico: Implementacin de operaciones de Colas MODELADO: Cola - dato: Object - sig : Cola + top : Cola + Cola( ) + Cola (dato: Object) + getDato( ): Object + getSig ( ): Cola + setDato( dato: Object) + setSig(nodo:Cola ) + esVacia( ):boolean + encolar(Object d):void + desencolar( ):void + print( ):Object IMPLEMENTACIN:
package listas2; public class Cola {

private Object dato; private Cola sig; public Cola top; public Cola last; public Cola( ){ top = last = null; } public Cola(Object dato){ this.dato=dato; this.sig = null; } public Object getDato(){ return dato; } public Cola getSig(){ return sig; } public void setSig(Cola nodo){ this.sig=nodo; } public void setDato(Object dato){ this.dato=dato; } public boolean esVacia( ){ if(top == null){ return true; }else{ return false; } } public void vaciar( ){ top = last = null; } public void desencolar( ){ if (esVacia( )){ System.out.print("\n Error al desencolar ..."); }else{ System.out.print("\n -> ["+top.getDato()+"]"); top = top.getSig(); } } public void encolar(Object d){ Cola temp = new Cola(d); if (esVacia( ) ){ top = last = temp; }else{ last.setSig(temp); last = temp; } System.out.print("\n <- ["+last.getDato()+"]"); } public void print(){

Cola aux; aux=top; System.out.print("\n Cola : ["); while(aux!=null){ if(aux.getSig()!=null){ System.out.print(aux.getDato()+ ","); }else{ System.out.print(aux.getDato()); } aux=aux.getSig(); } System.out.print("]"); } public static void main(String[] args)throws Exception { Cola c= new Cola(); c.encolar("Maria"); c.encolar("Jos"); c.encolar("Juan"); c.encolar("Andres"); c.print(); c.desencolar(); c.desencolar(); c.desencolar(); c.desencolar(); c.desencolar(); c.encolar("Xavier"); c.encolar("Gabrielita"); c.encolar("Franklin"); System.out.println("\n Nodo desencolado: "+c.desencolarDato()); c.desencolar(); c.print(); } }

Tarea 11: Investigar el API de Java para la implementacin de Colas, la interfaz Queue le puede ayudar traer un ejemplo demostrativo.