You are on page 1of 6

LISTAS ENLAZADAS Y SUS OPERACIONES

(DATOS PRIMITIVOS)

Una lista enlazada es una estructura dinámica 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 están 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 vacía si es el último).
 Doblemente enlazadas: es una lista de dos vías 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
están 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 inserción como la eliminación de datos pueden realizarse al inicio, al final,
antes de y después de un nodo.
En este resumen se realizarán operaciones con listas simples y doblemente
enlazadas.



INSERCIÓN 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 dirección
del que pasa a ser el segundo nodo, o null.
P


La creación del nodo se gestiona con new.
p = new Nodo (x, p);
Al crear el nodo se obtiene una dirección 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 través del
parámetro al momento de su creación.


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
dirección del que pasa a ser el segundo nodo.
P


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

La inserción 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 Vacía”);
}
}





INSERCIÓN 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 después 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 inserción 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 inserción 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);
}






INSERCIÓN ANTES DE
SIMPLE DOBLE
Para realizar esta inserción es necesario tener
la referencia del nodo anterior al que se va a
insertar, para poder enlazarlo. Esa referencia se
consigue a través de una búsqueda.

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

P



La inserción 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 Vacía”);
}
}
La misma estrategia utilizada en la inserción
simple, se utilizará en la doble.

La lista se recorre hasta encontrar el nodo “r”
que contiene el dato que se le pasó por
parámetro, 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 dirección
de s y en su parte siguiente la dirección de r.

P



La inserción 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();
}
}





INSERCIÓN DESPUÈS DE
SIMPLE DOBLE
La lista se recorre hasta encontrar el nodo que
contiene el dato que se le pasó por parámetro
en la búsqueda, y se ubica allí una variable que
contiene la referencia de ese nodo.

La referencia es utilizada como parámetro para
la inserción del nuevo nodo.
P



La inserción 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 vacía”);
}
La misma estrategia utilizada en la inserción
simple, se utilizará en la doble.
P



La inserción 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 vacía”);
}


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;