LISTAS ENLAZADAS Y SUS OPERACIONES

(DATOS PRIMITIVOS)

Una lista enlazada es una estructura dinmica compuesta por nodos conectados
que permite almacenar datos de forma ordenada.
Dato Enlace

Cada uno de los elementos apunta al siguiente excepto el ltimo que ti ene como
valor de enlace null (excepto en las circulares).
Las listas enlazadas estn clasificadas en:
Simples: contiene dos valores, el valor actual del nodo y el enlace al
siguiente nodo (puede apuntar a null, o a la lista vaca si es el ltimo).
Doblemente enlazadas: es una lista de dos vas en la que cada nodo tiene
dos enlaces, uno apunta al nodo anterior o a null si es el primero, y otro
apunta al nodo siguiente o a null si es el ltimo.
Circulares: es una lista sin comienzo y sin fin, pues el primer y ltimo nodo
estn unidos. La parte siguiente del ltimo nodo apunta al primer nodo.
Doblemente circular: es una lista sin comienzo y sin fin. Cada nodo
contiene dos enlaces, donde el enlace anterior del primero apunta al ltimo
nodo, y el enlace siguiente del ltimo nodo apunta al primer nodo.
Con las listas enlazadas pueden realizarse las siguientes operaciones:
Recorrer
Insertar
Eliminar
Buscar
Ordenar
Tanto la insercin como la eliminacin de datos pueden realizarse al inicio, al final,
antes de y despus de un nodo.
En este resumen se realizarn operaciones con listas simples y doblemente
enlazadas.



INSERCIN AL INICIO
SIMPLE DOBLE
P puede estar apuntando a null o a al primer
nodo de la lista.
P apunta a null
P apunta al primer nodo
Al insertar, P debe apuntar al nuevo nodo, y la
parte siguiente de ste, almacena la direccin
del que pasa a ser el segundo nodo, o null.
P


La creacin del nodo se gestiona con new.
p = new Nodo (x, p);
Al crear el nodo se obtiene una direccin en
memoria. Esta es asignada a p para que
apunte al que se est insertando. La parte
siguiente del nodo insertado se direccion
hacia el que era el primer nodo a travs del
parmetro al momento de su creacin.


P puede estar apuntando a null o a al primer
nodo de la lista.
P apunta a null
P apunta al primer nodo
Al insertar, P debe apuntar al nuevo nodo. La
parte anterior de ste tendr null por ser el
primero, y la parte siguiente almacena la
direccin del que pasa a ser el segundo nodo.
P


p.setAnt(new NodoDoble (x, null, p));
p = p.getAnt();
La direccin que se obtiene al crear el nodo es
asignada a la parte anterior del que era el
primero.

La insercin con sus respectivas validaciones:
if (p != null){
p.setAnt(new NodoDoble (x, null, p));
p = p.getAnt();
}
else{
p = new NodoDoble (x, null, p);
}
ELIMINAR AL INICIO
SIMPLE DOBLE
Para eliminar un nodo solo es necesario dejar
de referencial el nodo para que el recolector de
basura se encargue de l.

if (p != null){
p=p.getSig();
if(p == null){
q=null;
}
}
if (p != null){
if (q != null){
p = p.getSig();
p.setAnt(null);
}
else{
p=q=null;
}
else{
System.out.println(Lista Vaca);
}
}





INSERCIN AL FINAL
SIMPLE DOBLE
Para insertar al final lo primero que se piensa
es en que debe recorrerse toda la lista para
llegar al ltimo nodo e insertar despus de
este, pero para evitar ese tedioso proceso es
posible apoyarnos en una nueva variable q.
P



Y para insertar:
q.setSig(new Nodo(x, null));

Debido a que la q es una variable de apoyo en
el ltimo nodo, debe esta trasladarse hacia el
nuevo ltimo nodo, y el null para al nuevo
nodo.
q = q.getSig();

La insercin con sus respectivas validaciones:
if (q != null){
q.setSig(new Nodo(x, null));
q = q.getSig();
}
else{
p = q = new Nodo(x, null);
}
La misma estrategia de la variable de apoyo
utilizada en la insercin simple, se utilizar en
la doble.

P



Se verifica que la lista contenga nodos.

if (q != null){
q.setSig(new NodoDoble (x, q, null));
q = q.getSig();
}
else{
p = q = new NodoDoble (x, null, null);
}






INSERCIN ANTES DE
SIMPLE DOBLE
Para realizar esta insercin es necesario tener
la referencia del nodo anterior al que se va a
insertar, para poder enlazarlo. Esa referencia se
consigue a travs de una bsqueda.

Nodo r = p; Nodo s = null;
while(r != null && r.getDato()!= x){
s = r;
r = r.getSig();
}

P



La insercin con sus respectivas validaciones:
if (p != null){
if (s != null){
s.setSig(new Nodo (y, r));
}
else{
p = new Nodo (y, r);
}
else{
System.out.println(Lista Vaca);
}
}
La misma estrategia utilizada en la insercin
simple, se utilizar en la doble.

La lista se recorre hasta encontrar el nodo r
que contiene el dato que se le pas por
parmetro, y se obtiene la referencia del nodo
anterior s. Luego se crea el nuevo nodo el
cual va a llevar en su parte anterior la direccin
de s y en su parte siguiente la direccin de r.

P



La insercin con sus respectivas validaciones:
if (p != null){
if (s != null){
s.setSig(new NodoDoble (y, s, r));
r.setAnt(s.getSig());
}
else{
p.setAnt(new NodoDoble (y, null, p);
p = p.getAnt();
}
}





INSERCIN DESPUS DE
SIMPLE DOBLE
La lista se recorre hasta encontrar el nodo que
contiene el dato que se le pas por parmetro
en la bsqueda, y se ubica all una variable que
contiene la referencia de ese nodo.

La referencia es utilizada como parmetro para
la insercin del nuevo nodo.
P



La insercin con sus respectivas validaciones:
if (p != null){
r.setSig(new Nodo (y, r.getSig()));
If (r == q){
q = q.getSig();
}
}
else{
System.out.println(Lista vaca);
}
La misma estrategia utilizada en la insercin
simple, se utilizar en la doble.
P



La insercin con sus respectivas validaciones:
if (p != null){
r.setSig(new NodoDoble (y, r, r.getSig()));
r = r.getSig();
r.getSig().setAnt(r);
if(r == q){
q = q.getSig();
}
}
else{
System.out.println(Lista vaca);
}


CONSULTAR, MODIFICAR Y ELIMINAR UN NODO
Nodo r = p;
Nodo s = null;

while (r != null && r.getDato() != x){
s = r;
r.r.getSig();
}

if (r != null){
// Se puede consultar, modificar y eliminar.
}
else{
System.out.println(Dato no existe);
}





Para modificar, en la parte del comentario anterior, se codifica:
r.setDato (y);

Para eliminar, en la parte del comentario anterior, se codifica:
if (r == p){
if (r == q){
p = q = null;
}
else{
p.getSig();
}
}
else{
if (r == q){
q = s;
}
s.setSig(r.getSig());
}
r = null;