JAVA

Estructuras
Dinmicas
Listas Simplemente Enlazadas










Aprovechando l o que aprendi mos hasta ahora
sobre cl ases, obj etos y mtodos, en el
presente capi tul o vamos a ver como se
i mpl ementa en Java Estructuras di nmi cas
Li stas Li neal es.
Captulo 6


















Contenido
4.1. Objetivos
4.2. Estructuras Dinmicas
4.3. Listas Lineales
4.4. Listas Lineales Simple-
mente Enlazadas
4.4.1. Operaciones
Bsicas
4.4.2. Insercin de un
elemento al
comienzo de la lista
4.4.3. Insercin de un
elemento al final de
la lista
4.4.4. Recorrido de una
lista
4.4.5. Eliminar una lista
Actividades.




www.zonajava.net
Pgina | 62
Universidad Peruana Los Andes
Ing. Ral Enrique Fernndez Bejarano
4.1. Introduccin
En este captulo se examinaran los conceptos de Estructuras
Dinmicas, Listas lineales, y como el lenguaje Java implementa estas
estructuras.
Veremos tambin que Java asigna memoria dinmicamente para un
objeto de un tipo cualquiera, como devuelve una referencia a la zona de memoria
asignada, para realizar esta operacin disponemos en Java del operador new.
Adems crearemos aplicaciones utilizando el lenguaje Java, para crear Listas
Lineales simplemente enlazadas y su uso en el campo de la informtica.
4.2. Estructuras Dinmicas
La principal caracterstica de las estructuras dinmicas es la facultad
que tienen para variar su tamao y hay muchos problemas que
requieren de este tipo de estructuras. Esta propiedad las distingue
claramente de las estructuras estticas fundamentales como las
matrices.
Cuando se crea una matriz su nmero de elementos se fija en ese instante y
despus no puede agrandarse o disminuirse elemento a elemento,
conservando el espacio actualmente asignado; en cambio, cuando se crea una
estructura dinmica eso s es posible.
Por tanto, no es posible asignar una cantidad fija de memoria para una estructura
dinmica, y como consecuencia un compilador no puede asociar direcciones
explcitas con las componentes de tales estructuras. La tcnica que se utiliza
ms frecuentemente para resolver este problema consiste en realizar una
asignacin dinmica para las componentes individuales, al tiempo que son
creadas durante la ejecucin del programa, en vez de hacer la asignacin de una
sola vez para un nmero de componentes determinado.
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.





www.zonajava.net
Pgina | 63
Algoritmos y Estructura de Datos II
Ing. Ral Enrique Fernndez Bejarano
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.
4.3. Listas Lineales
Hasta ahora hemos trabajado con matrices que como sabemos son
colecciones de elementos todos del mismo tipo, ubicados en
memoria uno a continuacin de otro; el nmero de elementos es fijado
en el instante de crear la matriz.
Si ms adelante, durante la ejecucin del programa, necesitramos modificar su
tamao para que contenga ms o menos elementos, la nica alternativa posible
sera asignar un nuevo espacio de memoria del tamao requerido y adems,
copiar en l los datos que necesitemos conservar de la matriz original. La nueva
matriz pasar a ser la matriz actual y la matriz origen se destruir, si ya no
fuera necesaria.
Es evidente que cada vez que necesitemos aadir o eliminar un elemento a una
coleccin de elementos, la solucin planteada en el prrafo anterior no es la ms
idnea; seguro que estamos pensando en algn mecanismo que nos permita
nadir un nico elemento a la coleccin, o bien eliminarlo.
Este mecanismo es viable si en lugar de trabajar con matrices lo hacemos
con 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 puede crecer o decrecer
elemento a elemento segn las necesidades previstas en el mismo.
Segn la definicin dada surge una pregunta: si los elementos no estn
consecutivos en memoria cmo pasamos desde un elemento al siguiente
cuando recorramos la lista? La respuesta es que 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: listas simplemente enlazadas, listas circulares, listas doblemente
enlazadas y listas circulares doblemente enlazadas.







www.zonajava.net
Pgina | 64
Universidad Peruana Los Andes
Ing. Ral Enrique Fernndez Bejarano

4.4. Listas Lineales Simplemente Enlazadas
Una lista lineal simplemente enlazada 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 forma siguiente:

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 una 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 CListaSE
{
//Atributos
int dato;
CListaSE siguiente;

//Metodo
CListaSE(int d)
{
dato = d;
}
}
Se puede observar que la clase CListaSE definir una serie de atributos
correspondientes a los datos que deseamos manipular (dato en nuestro caso),
adems de un atributo especial denominado siguiente, para permitir que cada
elemento pueda referenciar a su sucesor formando as una lista enlazada.
Una vez creada la clase de objetos CListaSE la asignacin de memoria para un
elemento se hara as:





www.zonajava.net
Pgina | 65
Algoritmos y Estructura de Datos II
Ing. Ral Enrique Fernndez Bejarano


class CCrearLista
{
public static void main (String[] args)
{
CListaSE p;

//Asignar memoria para un elemento
p = new CListaSE();

//Este elemento no tiene sucesor
p.siguiente = null;
p = null;
}
}
El cdigo CListaSE p define una referencia p a un objeto de la clase CListaSE.
La sentencia p = new CListaSE() crea (asigna memoria para) un objeto de tipo
CListaSE, genera una referencia (direccin de memoria) que direcciona este
nuevo objeto y asigna esta referencia a la variable p. La sentencia p.siguiente =
null asigna al miembro siguiente del objeto referenciado por p el valor null,
indicando as que despus de este elemento no hay otro; esto es, que este
elemento es el ltimo de la lista.
El valor null, referencia nula, permite crear estructuras de datos finitas. As
mismo, suponiendo que p hace referencia al principio de la lista, diremos que
dicha lista est vaca si p vale null. Por ejemplo, despus de ejecutar las
sentencias:
p = null;
p = new CListaSE;
p.siguiente = null;
Grficamente seria:

En una sola clase seria de la siguiente manera:




www.zonajava.net
Pgina | 66
Universidad Peruana Los Andes
Ing. Ral Enrique Fernndez Bejarano



class CLista
{
int dato;
CLista siguiente;

public static void main (String[] args)
{
CLista p = new CLista();

p.dato = 10;
p.siguiente = null;
}
}



Ejemplo 01
Programa que crea la clase Clista.java que servir para futuras
aplicaciones de operaciones de listas enlazadas simples.

class Clista
{
private Nodosimple p=null;

class Nodosimple
{
//Atributos
private int dato;
private Nodosimple siguiente;
}
}
4.4.1. Operaciones Bsicas
Las operaciones que podemos realizar con listas incluyen
fundamentalmente las siguientes:
1. Insertar un elemento en una lista
2. Borrar un elemento de una lista
3. Recorrer los elementos de una lista
4. Borrar todos los elementos de una lista
5. Buscar un elemento en una lista





www.zonajava.net
Pgina | 67
Algoritmos y Estructura de Datos II
Ing. Ral Enrique Fernndez Bejarano


Los si gui entes ej empl os, que se ponen a vuestra
di sposi ci n son ej erci ci os real i zados en Lenguaj e Java, l os
cual es han si do probados en el I DE de JCreator Pro
(entregado en cl ase).
El siguiente Programa crea la clase Leer, esta clase permite el ingreso de datos y
ser utilizada para en los ejemplos descritos posteriormente.
import java.io.*;
public class Leer
{
public static String dato()
{
String sdato = "";
try
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader flujoE = new BufferedReader(isr);

sdato = flujoE.readLine();
}
catch(IOException e)
{
System.err.println("Error: " + e.getMessage());
}
return sdato; // devolver el dato tecleado
}

public static short datoShort()
{
try
{
return Short.parseShort(dato());
}
catch(NumberFormatException e)
{
return Short.MIN_VALUE; // valor ms pequeo
}
}

public static int datoInt()
{
try
{
return Integer.parseInt(dato());
}
catch(NumberFormatException e)
{
return Integer.MIN_VALUE; // valor ms pequeo




www.zonajava.net
Pgina | 68
Universidad Peruana Los Andes
Ing. Ral Enrique Fernndez Bejarano
}
}

public static long datoLong()
{
try
{
return Long.parseLong(dato());
}
catch(NumberFormatException e)
{
return Long.MIN_VALUE; // valor ms pequeo
}
}

public static float datoFloat()
{
try
{
Float f = new Float(dato());
return f.floatValue();
}
catch(NumberFormatException e)
{
return Float.NaN; // No es un Nmero; valor float.
}
}

public static double datoDouble()
{
try
{
Double d = new Double(dato());
return d.doubleValue();
}
catch(NumberFormatException e)
{
return Double.NaN; // No es un Nmero; valor double.
}
}
}
4.4.2. Insercin de un elemento al comienzo de la lista
Supongamos una lista lineal referenciada por p, para insertar
un elemento al principio de la lista, primero se crea el
elemento y despus se reasignan las referencias, tal como se
indica a continuacin.
q = new CListaSE();





www.zonajava.net
Pgina | 69
Algoritmos y Estructura de Datos II
Ing. Ral Enrique Fernndez Bejarano




q.dato = n; //asignacin de valores
q.siguiente = p; //reasignacin de referencias
p = q;
El orden en el que se realizan estas operaciones es esencial, el resultado
es:

Ejemplo 02
Programa que realiza la insercin de un elemento al comienzo de la
lista. (Tiene que utilizar las clases ClistaSe)

public class CInsertaIni
{
public static void main (String[] args)
{
CListaSE p,q;
int n, eof = Integer.MIN_VALUE;

//Crear una lista de nmeros enteros
System.out.println("Introducir Datos, Fin con Ctrl+Z ");

//Lista vacia
p = null;

System.out.print("Dato: ");
while((n = Leer.datoInt()) != eof)
{




www.zonajava.net
Pgina | 70
Universidad Peruana Los Andes
Ing. Ral Enrique Fernndez Bejarano
q = new CListaSE();
q.dato = n;
q.siguiente = p;
p = q;
System.out.print("Dato: ");
}

//Recorrer una Lista
System.out.println("\n Los Datos Ingresados son:");
q = p;
while (q != null)
{
System.out.println(q.dato);
q = q.siguiente;
}
}
}
Ejemplo 03
Mtodo anadirPrincipio(), realiza la insercin de un nodo al inicio
de la lista (trabaja con la clase Clista.java)

public void anadirPrincipio(int valor)
{
Nodosimple temp;

if (vacio()){
temp = new Nodosimple();
temp.dato = valor;
p = temp;
}

else {
temp = new Nodosimple();
temp.dato = valor;
temp.siguiente = p;
p = temp;
}
}
Ejemplo 04
Programa que realiza la insercin de un elemento al comienzo de la
lista. En una sola clase







www.zonajava.net
Pgina | 71
Algoritmos y Estructura de Datos II
Ing. Ral Enrique Fernndez Bejarano
class CLista {
int dato;
CLista siguiente;

public static void main (String[] args) {
CLista p,q;
int n, eof = Integer.MIN_VALUE;

//Crear una lista de nmeros enteros
System.out.println("Introducir Datos, Fin con Ctrl+Z ");

//Lista vacia
p = null;

System.out.print("Dato: ");

while((n = Leer.datoInt()) != eof){
q = new CLista();
q.dato = n;
q.siguiente = p;
p = q;
System.out.print("Dato: ");
}

//Recorrer una Lista
System.out.println("\n Los Datos Ingresados son:");
q = p;
while (q != null){
System.out.println(q.dato);
q = q.siguiente;
}
}
}
Ejemplo 05
Programa que realiza una clase que permite crear una lista lineal
simplemente enlazada en la que cada elemento conste de dos
miembros, un valor de tipo double y una referencia a un elemento del
mismo tipo.
class CListaLinealse {
private CElemento p = null;

private class CElemento{
//atributos
private double dato;
private CElemento siguiente;

//metodos - contructor
private CElemento(){}
}




www.zonajava.net
Pgina | 72
Universidad Peruana Los Andes
Ing. Ral Enrique Fernndez Bejarano

public void anadirPrincipio(double n){
CElemento q = new CElemento();
q.dato = n;
q.siguiente = p;
p = q;
}

public void mostrarTodos(){
//referencia al primer elemento
CElemento q = p;
while (q != null)
{
System.out.print(q.dato + " ");
q = q.siguiente;
}
}
}


class CIngresoLineal{
public static void main (String[] args) {
//crear una lista lineal vacia
CListaLinealse lse = new CListaLinealse();

//leer datos tipo entero y aadirlos a la lista
double n;
boolean eof = true;

System.out.println("Introducir Datos, Finalizar con Ctrl+Z ");
System.out.print("Dato: ");
while (Double.isNaN(n = Leer.datoDouble()) != eof)
{
lse.anadirPrincipio(n);
System.out.print("Dato: ");
}

//Mostrar la lista de datos
System.out.println();
lse.mostrarTodos();
}
}

4.4.4. Insercin de un elemento al final de la lista
Supongamos una lista lineal referenciada por p, para insertar un
elemento al final de la lista, primero crea el elemento y despus
se reasignan las referencias, tal como se indica en el ejemplo
siguiente.






www.zonajava.net
Pgina | 73
Algoritmos y Estructura de Datos II
Ing. Ral Enrique Fernndez Bejarano
Ejemplo 06
Mtodo anadirFinal(), realiza la insercin de un nodo al
final de la lista (trabaja con la clase Clista.java)

public void anadirFinal(int valor){
Nodosimple temp;
Nodosimple temp2 = null;

if (vacio()) {
temp = new Nodosimple();
temp.dato = valor;
p = temp;
}

else{
temp2 = p;
temp = new Nodosimple();
temp.dato = valor;
while (temp2.siguiente != null)
temp2 = temp2.siguiente;
temp2.siguiente = temp;
}
}
4.4.5. Recorrido de una lista
Supongamos una lista lineal referenciada por p, para realizar el
recorrido de lista, se visita el primer elemento.
System.out.print(temp.dato);
Luego si deseamos imprimir el segundo elemento solamente es necesario
asignarle a apuntador temp la direccin del segundo nodo, as:
temp = temp.siguiente;
Para el tercer nodo, el cuarto y as sucesivamente, lo cual sugiere un ciclo
como en el mtodo recorrido.







www.zonajava.net
Pgina | 74
Universidad Peruana Los Andes
Ing. Ral Enrique Fernndez Bejarano
Ejemplo 07
Mtodo Recorrido(), realiza el recorrido de la lista (trabaja
con la clase Clista.java)

public void Recorrido(){
if (vacio())
System.out.println("Lista vacia");
else {
Nodosimple temp = p;
while (temp != null)
{
System.out.print(temp.dato + ",");
temp = temp.siguiente;
}
}
}
Ejemplo 08
Mtodo vacio(), realiza la verificacin si un lista est vaca o
no (trabaja con la clase Clista.java).

public boolean vacio()
{
if (p == null)
return true;
else
return false;
}
4.4.6. Eliminar una lista
Podemos considerar, los siguientes casos:

Eliminar la lista totalmente
Eliminar el nodo siguiente al indicado por un apuntador.
Eliminar el nodo anterior al indicado por un apuntador.
Eliminar el nodo indicado.

Realizaremos el primero de ellos. Supongamos una lista lineal referenciada
por p, para eliminar una lista.





www.zonajava.net
Pgina | 75
Algoritmos y Estructura de Datos II
Ing. Ral Enrique Fernndez Bejarano
Ejemplo 09
Mtodo borrarLista(), realiza la eliminacin de una lista
llena de elementos (trabaja con la clase Clista.java).

public void borrarLista(){
if (vacia())
System.out.println("Lista vacia");
else
p=null;
}