Вы находитесь на странице: 1из 33

Curso de Estructuras de Datos Orientada a Objetos

1
1

Ing. Daysi M. Erreyes P.

5. ESTRUCTURA LISTA

5.1.Descripción Lógica de la Estructura Lista Una lista es una colección de elementos homogéneos, entre los elementos existe una relación lineal, en donde cada elemento indica la dirección donde se encuentra el siguiente elemento de la lista.

donde se encuentra el siguiente elemento de la lista. Representación : Una lista se puede representar

Representación:

Una lista se puede representar de dos formas:

Dinámica: su tamaño puede crecer indefinidamente en tiempo de ejecución Ej.:

Estática: su tamaño se limita en tiempo de compilación Ej.: arreglos

listas enlazadas simples, listas enlazadas dobles, listas circulares, pilas y colas.

Características

En cada elemento o nodo de la lista a excepción del primero, tiene un único

predecesor se debe indicar donde se encuentra el siguiente elemento. Cada elemento de la lista, a excepción del último tiene un único sucesor.

Las listas son flexibles y permiten cambios en la implementación.

Partes de un nodo

Campo

Campo

dato o

de

info

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.

Representación de la estructura en memoria:

de la lista. Representación de la estructura en memoria: Por lo general un nodo de una

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;

}

// métodos 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 información de un determinado nodo dentro de la lista

5.3.Tipos de listas

5.3.1.

Listas Simplemente Enlazadas

Analiza: Piensa en varias aplicaciones informáticas de la vida real, en donde se utilice la
Analiza:
Piensa en varias aplicaciones informáticas de la vida real, en
donde se utilice la estructura: Lista Simplemente Enlazada,
comenta con tus compañeros y con tu profesora… !!!

Es una colección de elementos homogéneos cuya relación lineal es determinada por la posición 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.

nula o apuntara a null. Esta dada en un solo sentido. Java inicializa los campos de

Java inicializa los campos de referencias de un objeto a null durante la construcción del objeto, no es necesario asignar explícitamente null a un campo de enlace. Pero sin embargo no olvide estas asignaciones de null en su código fuente, su ausencia reduce la claridad del código.

 

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á vacía el rango serán los elementos que tendrán las posiciones 0,1,2,3…N donde N es la cantidad de elementos de la lista.

OPERACIONES:

-

INSERTAR-INICIO

Utilidad: añadir 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. Precondición: Ninguna Postcondicion: La lista L contiene un elemento nuevo al inicio.

-

INSERTAR-FIN

Utilidad: añadir 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. Precondición: Ninguna Postcondicion: La lista L contiene un elemento nuevo al final.

-

INSERTAR-ENTRE-NODOS

Utilidad: añadir 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. Precondición: Ninguna Postcondición: 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 Precondición: la lista L no esté vacía 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 Precondición: la lista L no esté vacía

Postcondicion: La lista con un nodo menos (el del final)

- ELIMINAR- ENTRE-NODOS

Utilidad: quitar un nodo de un orden específico de la lista Datos de entrada: la lista L, y el elemento a eliminar Datos de salida: la lista L con un elemento menos Precondición: la lista L no esté vacía y que contenga el nodo a eliminar Postcondición: 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 Precondición: la lista no esté vacía Postcondición: Ninguna

Nivel físico: Implementación de operaciones de Listas Enlazadas Simples

CASOS PARA LA INSERCIÓN 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 después del último nodo 4.- Cuando el nodo se debe insertar entre nodos

PASOS PARA LA SOLUCIÓN

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 después 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 ELIMINACIÓN DE NODOS:

1.- Borrar el primer nodo

2.- Borrar cualquier nodo que no sea el primero

PASOS PARA LA SOLUCIÓN

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 //Inserción de Nodos +insertaVacia(d:Object):void

+insertaInicio(d:Object):void //Caso 2

+insertaFinal(d:Object):void

+entreNodos(np: Object, d:Object):void //Eliminación de Nodos +eliminaInicio( ): void // Caso 1 +eliminaNodo( ): void //Caso 2 y 3 +buscarNodo( ):boolean

+presenta( ):void

//Caso 1

//Caso 3

// Caso 4

IMPLEMENTACIÓN 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 y operación de búsqueda. Considere el modelo planteado.
Tarea 7: Implementar en la clase ListaSimple
y
operación de búsqueda. Considere el modelo
planteado.
los casos de eliminación de nodos
la

5.3.2.

Listas Doblemente Enlazadas

Analiza: Piensa en varias aplicaciones informáticas de la vida real, en donde se utilice la
Analiza:
Piensa en varias aplicaciones informáticas de la vida real, en
donde se utilice la estructura: Lista Doblemente Enlazada,
comenta con tus compañeros y con tu profesora… !!!

Problemas con las Listas Simples:

Restringen el movimiento por los nodos a una sola dirección.

No se puede atravesar la lista en dirección opuesta a menos que se utilice

primeramente un algoritmo de inversión, lo que llevará algún 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 atrás con el campo de ente ant(anterior).

Es una colección de elementos homogéneos que tiene una relación lineal se da en ambos sentidos.

que tiene una relación lineal se da en ambos sentidos. Características - En cada nodo existe

Características

- En cada nodo existe una referencia a su nodo predecesor y sucesor a más del campo dato o de información.

- 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

Campo

Campo

de

dato o

de

enlace

info

enlace

anterior

siguiente

enlace info enlace anterior siguiente Nivel físico: Implementación de operaciones de Listas Doblemente

Nivel físico: Implementación 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 implementación de la lista doblemente enlazada, quedando la lista de la siguiente manera:

enlazada, quedando la lista de la siguiente manera: MODELADO: NodoDoble - ant: NodoDoble - sig:

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 (después: NodoDoble,d:Object):void

+ insertarDespues(antes: NodoDoble,d:Object):void

+ insertarEntre(antes: NodoDoble,d:Object,después: 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 número 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á todavía 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 método deleteNodos del la clase ListaDoble, controlar todos los casos posibles.
Tarea 8: Implementar el método deleteNodos
del
la
clase
ListaDoble,
controlar
todos
los
casos posibles.
Exposición Nro. 5: Investiga en el Api de Java para Listas, la clase: LinkedList, que
Exposición 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 explicación de las principales operaciones exponer la utilidad, sintaxis y un
ejemplo de su utilización. Además debe realizar un programa demostrativo de
manipulación de Listas en Java, por ejemplo una lista mensajes.
Nota: Se tomará en cuenta el material de apoyo utilizado para la exposición y debe
entregar una copia digital a cada grupo, además una copia impresa y digital a la profesora

5.3.3. Lista Circulares

Analiza: Piensa en varias aplicaciones informáticas de la vida real, en donde se utilice la
Analiza:
Piensa en varias aplicaciones informáticas de la vida real, en
donde se utilice la estructura: Lista Circular, comenta con tus
compañeros 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 específico.

Características

No podemos hablar de primer y último nodo,

Para su implementación es necesario utilizar un apuntador general a la lista

No existen direcciones nulas, excepto cuando la lista está vacía

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 posición donde se encuentre apuntando a la variable de referencia llamada lista

Representación

a la variable de referencia llamada lista Representación Nivel físico: Implementación de operaciones de Listas

Nivel físico: Implementación 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

IMPLEMENTACIÓN:

Algoritmo para Insertar Nodos

- Leer (valor)

- Crear un nodo temporal

- Fijar el dato

- Si la lista está vacía es el primero a insertarse, asignar la referencia del nuevo nodo a lista sino insertar el nuevo nodo a continuación 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 informáticas de la vida real, en donde se utilice la
Analiza:
Piensa en varias aplicaciones informáticas de la vida real, en
donde se utilice la estructura: Lista ordenada, comenta con tus
compañeros 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 identificación y e nombre, dirección, teléfono, calificación.

Tipo de Listas Ordenadas.

1. Diccionario no ordenado o genérico:

Se supone que no hay relación de orden entre las claves y solo se usa la prueba de igualdad

entre ellas.

2. Diccionarios Ordenados.

Existen entre las claves una relación de orden total, además determina el orden relativo de

dos claves mediante un comparador.

Representación en Memoria.

claves mediante un comparador. Representación en Memoria. TDA: DICCIONARIO Elementos : Se guardan como elementos

TDA: DICCIONARIO

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

 

y elemento e.

Estructura: Lineal entre cada artículo del diccionario D

Dominio: depende de la aplicación

OPERACIONES:

-

INSERT-ELEMENTO

Utilidad: Añadir 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 artículo 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 operación

-

ENCONTRAR- ELEMENTO

Utilidad: si D contiene un articulo cuya clave sea igual a K, regresa al elemento de ese

artículo 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 físico: Implementación 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

IMPLEMENTACIÓN:

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

}

}

}

public String delete(int clave){ ListaOrdenada aux,aux1;

Clave repetida");

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 más 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.

java.util.EnumMap, java.util.HashTable, entre otras. Existen muchas otras clases dentro de este paquete, lo cual

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 implementación de listas ordenadas, la interfaz:
Tarea 9: Investigar el
API de Java
para la
implementación de listas ordenadas, la interfaz:
java.util.Map le puede ayudar… traer un
ejemplo demostrativo.

5.3.5.

PILAS

Analiza: Ejemplos donde están aplicadas las pilas es: En la opción deshacer o rehacer en
Analiza:
Ejemplos donde están aplicadas las pilas es:
En la opción deshacer o rehacer en aplicaciones de
ofimáticas.
En el retroceso de páginas de los exploradores de
internet.
Piensa en varias aplicaciones informáticas de la vida real, en
donde se utilice la estructura: Lista ordenada, comenta con tus
compañeros y con tu profesora… !!!
comenta con tus compañeros y con tu profesora… !!! Es una estructura lineal de objetos ordenados

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 más reciente).

Todas las operaciones que se definan sobre una pila deben de tener costo constante, independientemente del número de elementos de la pila.

Las Operaciones básicas son:

Insert Push Delete Pop Search Tope

Representación

Insert Push Delete Pop Search Tope Representación   TDA: Pila Elementos : Cualquier objeto, esto
 

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 aplicación.

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é vacía 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á vacía 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 físico: Implementación 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

IMPLEMENTACIÓN:

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á vacía 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 implementación de Pilas, la clase Stack
Tarea 10: Investigar el API de Java para la
implementación 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
Analiza:
Ejemplos donde se pueden aplicar las colas son:
Los drivers de la impresora, todos los trabajos que reciben para su
impresión, siempre los colocan en una cola de acuerdo a cómo han llegado.
Las colas de los bancos.
En los sistemas operativos al momento de asignar algún recurso a los
procesos.
Piensa en varias aplicaciones informáticas de la vida real, en donde se utilice
la estructura: Lista ordenada, comenta con tus compañeros y con tu

Una cola es una estructura de datos en la cual el acceso está limitado al elemento insertado recientemente.

Además una cola es una colección ordenada de elementos homogéneos en la que solo se puede añadir por el final y eliminar por el frente y se requiere dos punteros, para su manipulación.

Aplica la filosofía FIFO(first in first out) o PEPS (primero en entrar, primero en salir)

Las operaciones básicas son:

Insert Encolar

Delete Desencolar

Search Tope

Representación

Delete Desencolar Search Tope Representación TDA: COLA O FILA Elementos : cualquier clase de objetos,

TDA: COLA O FILA

Elementos: cualquier clase de objetos, dependiendo de la aplicación.

Estructura: Lineal.

Dominio: se maneja cantidades de objetos de acuerdo a la aplicación.

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 más agregado por el final.

2

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é vacía. Postcondiciones: La cola con un elemento menos eliminado por el frente de la cola.

ELIMINAR/DESENCOLAR:

3 VACIA:

Utilidad: Verificar si una determinada cola se encuentra vacía o no. Datos de entrada: La cola que se va a verificar. Datos de salida: Booleano, que indique si la cola está vacía 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 físico: Implementación 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

IMPLEMENTACIÓN:

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 implementación de Colas, la interfaz Queue
Tarea 11: Investigar el API de Java para la
implementación de Colas, la interfaz Queue le
puede ayudar… traer un ejemplo demostrativo.