P

República Bolivariana de Venezuela

Ministerio del poder popular para la educación Superior S

Instituto universitario politécnico “Santiago Mariño”

Maracaibo-Estado-Zulia
M

Listas
Enlazadas
Estructura
De Datos
do
2 Corte
mer
Profesora: ING. IVETT KOOL
Ciudad: SAN CRISTOBAL
Extensión sede o ampliación:
1 10% Alumno: JESÚS MARQUINA
Cedula: 24.253.109
Teléfono: 0412-651-05-35
Correo: jesus.armando.marquina@gmail.com
PSM SAN CRISTOBAL
 INTRODUCCION

Hasta este punto se han visto las estructuras de datos presentadas por Arreglos, Pilas y Colas,
éstas son denominadas estructuras estáticas, porque durante la compilación se les asigna un
espacio de memoria, y éste permanece inalterable durante la ejecución del programa.

En la siguiente unidad se muestra la estructura de datos “Lista”. La cual es un tipo de estructura

lineal y dinámica de datos. Lineal debido a que a cada elemento le puede seguir sólo otro elemento,
y dinámica porque se puede manejar la memoria de manera flexible, sin necesidad de reservar
espacio con anticipación.

Una de las principales ventajas de manejar un tipo dinámico es que se pueden obtener posiciones
de memoria a medida que se va trabajando con el programa, y éstas se liberan cuando ya no se
requiere, de ese modo se crea una estructura más dinámica que cambia dependiendo de la
necesidad, según se agreguen o eliminen elementos.

Lo anterior solucionaría en gran manera el manejo de los espacios en memoria, necesarios para la
solución de problemas y así optimizar el uso de los recursos del sistema, es importante destacar que
las estructuras dinámicas no pueden reemplazar a los arreglos en todas sus aplicaciones. Hay casos
numerosos que podrían ser solucionados, de modo fácil, aplicando arreglos, en tanto que si se
utilizaran estructuras dinámicas, como las listas, la solución de tales problemas se complicaría.
 INDICE

1) Listas simplemente enlazadas lineales.

 Representación de un nodo
 Creación de un nodo.
 Implementación.
 Crear un L.S.E.L.
 Desplegar una L.S.E.L.
 Eliminar un nodo de una L.S.E.L
 Algoritmo de eliminación
 Algoritmo que cuenta el número de nodos de una L.S.E.L.
 Algoritmo que despliega la lista de forma invertida.
 Ejemplos de listas en la vida cotidiana
2) Listas Circulares
 Operaciones básicas con L.C.
 Algoritmo que crea una L.C.
 Insertar un nodo después de x dato.
 Insertar un nodo antes de x dato en L.C.
 Algoritmo de eliminación de un nodo en una L.C.
 Algoritmo que ordena una L.C.
 Algoritmo que despliega una L.C.
 Ejemplos de la vida cotidiana en la cual se puede realizar una lista circular
3) Lista doblemente enlazadas
 Tipos de L.D.E.
 Algoritmo que crea una L.D.E.C.
 Algoritmo que recorre una L.D.E.C.
 Algoritmo que inserta un nodo después de x dato.
 Algoritmo que elimina un nodo con x dato.
 Algoritmo que ordena una L.D.E.C. moviendo apuntadores.
 Ejemplo de lista doble en la vida cotidiana
 DESARROLLO

Listas enlazadas

 Utiliza posiciones de memoria no contigua para almacenar los datos.

 Es dinámica, no tiene longitud fija, añade y elimina memoria cuando lo necesita.
 Se apoya en otros objetos (nodos) para mantener los datos.
 Cada nodo de la lista es un objeto distinto suele haber una clase nodo separada.
 Una lista enlazada no sabe cuántos datos almacena.
 En una lista enlazada los nodos almacenan la información.
 El orden de los elementos de la lista coincide con el orden de los nodos en la cadena.
 El primer nodo es la cabeza o inicio de la lista.

Tipos de listas

 Listas simplemente enlazadas lineal.

 Listas simplemente enlazadas circular
 Listas doblemente enlazadas circular o lineal.

 La diferencia fundamental está en el nodo que se utiliza para llevar a cabo la implementación.
 Una lista almacenará un puntero (referencia) al primer elemento de la lista el cual se le puede
llamar (top, cabeza, inicio).
 La posición actual se representa como un puntero (referencia) a un nodo de la lista.

Listas simplemente enlazadas lineales.

 La lista simplemente enlazada lineal tiene un nodo muy simple.

 El nodo pertenece a la implementación de la lista enlazada y no a la interfaz pública de la
clase.
 El primer nodo es el inicio o principio de la lista.
 Gráficamente una L.S.E.L. seria:
Representación de un nodo

Un nodo está compuesto por dos partes principales las cuales son el campo dato y el campo
referencia al siguiente nodo de la lista.

class Nodo {
int dato;
Nodo liga;
public Nodo()
{
dato=0;
sig=null;
}
public Nodo (int elem)
{
dato = elem;
sig = null;
}
}

Creación de un nodo.

La creación del nodo en C# lo hacemos al momento de invocar al constructor de la clase

public Nodo (int elem)

{
dato = elem;
sig= null;
}
De la manera siguiente
q=new Nodo(dato);

Implementación.

• Para llevar a cabo la implementación se requiere de lo siguiente:

 Inicio: este apuntador siempre estará posicionado en el primer nodo de la lista.

 Final: este apuntador estará siempre posicionado en el último nodo de la lista
Crear un L.S.E.L.

Para crear la lista se puede hacer que las inserciones se han por donde esta posicionado el
apuntador inicio en la lista como se muestra a continuación:

public void crear_lista(ref Lista lis,int dato)

{
Nodo q=null;
if(lis.Inicio==null) //primer nodo
lis.Inicio=lis.final=new Nodo(dato);
else
{
q=new Nodo(dato);
q.sig=null;
lis.final.sig=q;
lis.final=q;
}
}

Otra manera de crear la lista es la de insertar los nodos al final de la lista.

public void InsertarFinal(ref Lista lis,int dato)

{
Nodo q=null;
if(this.Inicio==null)
lis.Inicio=lis.final=new Nodo(dato);
else
{
q=new Nodo(dato);
lis.final.sig=q;
lis.final=q;
q=null;
}
}

Desplegar una L.S.E.L.

Para desplegar la lista basta con posicionar un apuntador al inicio de la lista e ir recorriendo nodo
por nodo hasta llegar a final como lo podemos ver en el siguiente algoritmo:

private void button3_Click(object sender, EventArgs e)

{
Nodo q = null;
if (L1.Inicio != null) {
q = L1.Inicio;
listBox1.Items.Clear();
while(q!=null) {
listBox1.Items.Add(q.dato);
q=q.liga;
}
}
 else
MessageBox.Show("La lista esta vacia");
}

Eliminar un nodo de una L.S.E.L.

 Para quitar un nodo de la lista es necesario primeramente localizar el dato que se desea
eliminar.
 Posteriormente se actualiza el campo sig del nodo anterior (Q) para que podamos entonces
eliminar el nodo. Como lo podemos ver a continuación suponer que el dato a eliminar es el 4.

Algoritmo de eliminación

Procedimiento eliminar(info)
sw <- false
si inicio != null entonces
p <- inicio
mientras p!=null haz
si p(dato) = info entonces
sw <- true
si p = inicio entonces
inicio<- inicio(liga)
en caso contrario
si p=final entonces
final=q;
q(liga) <- p(liga)
p(liga) <- null
p <- null
en caso contrario
q <- p
p <- p(liga)
en caso contrario
mensaje( 'no hay lista')
si not sw entonces
mensaje('no existe información')
en caso contrario
mensaje('información borrada')
Algoritmo que cuenta el número de nodos de una L.S.E.L.

Se desea saber el número de nodos con que cuenta la lista, para esto suponer que tenemos la
siguiente lista:

Lo primero que tenemos que realizar es colocar un apuntador al primer nodo de la lista y también
inicializar un contador en cero, posteriormente ir recorriendo la lista, e ir incrementando el contador
en uno por cada movimiento que tenga el apuntador, este recorrido termina hasta que el apuntador
sea igual a null.

A continuación se describe el algoritmo que realiza dicha operación.

si inicio != null entonces

i <- 0
p <- inicio
mientras p != null haz
i <- i +1
p <- p(liga)
mensaje('El numero de nodos en la lista = ', i)
en caso contrario
mensaje('no hay lista')

Algoritmo que despliega la lista de forma invertida.

Se desea desplegar el contenido de la lista en forma inversa esto quiere decir que se debe de
recorrer la lista de derecha a izquierda. El algoritmo seria:

si inicio!= null entonces

p = null
q=inicio
haz
q=inicio;
while (q(liga)!=p)
q=q(liga)
p <- q
escribe(p(dato))
mientras p != inicio
en caso contrario
mensaje('no hay lista')
Ejemplos de listas en la vida cotidiana

 Lista de estudiantes ordenada alfabéticamente (independientemente del orden en el que se

inscribieron)
 Se pueden utilizar listas como base para implementar otras estructuras de datos como pilas,
colas, árboles, grafos, etc.

Listas Circulares

Las listas circulares se desprenden de las listas descritas anteriormente, con respecto al manejo y
a su creación son casi iguales.

Una lista circular tiene la característica que su último nodo tiene la dirección del primer nodo de la
lista, a diferencia de la lista lineal, en donde el último nodo de la lista apunta a null. Gráficamente una
lista circular se puede representar de la siguiente manera:

Operaciones básicas con L.C.

Las operaciones básicas con las listas circulares, son las que se llevan a cabo en cualquier
variable, las cuales son:

 Creación.
 Inserción.
 Eliminación.
 Desplegar
 Ordenar

Algoritmo que crea una L.C.

public void Crear(ref ListaCirc lis, int dato)

{
Nodo q = new Nodo(dato);
if (lis.Inicio == null)

lis.Inicio = lis.ult = q;
else
{
lis.ult.liga= q;
lis.ult = q;
 }
q.sig = lis.Inicio;
}

Insertar un nodo después de x dato.

Se desea insertar el nodo con el dato 6 que se encuentra con líneas azules en la lista después del
nodo cuya información es 3, el algoritmo seria:

public void InsertarDespues(ref ListaCirc Lis, int X, int dato)

{
Nodo p = null, q = null;
if (Lis.Inicio != null)
{
p = Lis.Inicio;
do
{
if (p.dato == X)
{
q = new Nodo(dato);
q.liga = p.liga;
p.liga = q;
if (p == Lis.ult)
Lis.ult = p;
p = Lis.Inicio;
}
else
p = p.liga;
} while (p != Lis.Inicio);
}
else
MessageBox.Show("No existe lista circular");
}

Insertar un nodo antes de x dato en L.C.

Otra situación diferente a la anterior, es la de insertar el nodo antes del nodo cuya información es
3, como se muestra a continuación:
public void InsertarAntes(ref ListaCirc Lis, int X, int dato)
{
Nodo p = null, q = null, r = null;
if (Lis.Inicio != null)
{
p = Lis.Inicio;
do
{
if (p.dato == X)
{
q = new Nodo(dato);
q.liga = p;
if (p == Lis.Inicio)
{
Lis.Inicio = q;
Lis.ult.liga = Lis.Inicio;
p.liga = q;
}
else
r.liga = q;
p = Lis.Inicio;
}
else
{
r = p;
p = p.liga;
}
} while (p != Lis.Inicio);
}
}

Algoritmo de eliminación de un nodo en una L.C.

Supongamos que tenemos la siguiente lista circular:

El cual se desea eliminar el nodo cuya información sea 1. La lista nos quedaría de la siguiente
manera:
El algoritmo que realiza la tarea de eliminar el nodo con x datos seria:

Procedimiento eliminar(entero x)
si inicio != null entonces
p <- inicio;
sw <- false
haz
si p(dato) = x entonces
sw <- verdadero
si p = inicio entonces
si inicio(liga) = inicio entonces
inicio<- nil
en caso contrario
ult(liga) <- inicio(liga)
inicio<- inicio(liga)
en caso contrario
q(liga) <- p(liga)
si ult=p entonces
ult=q
p->liga <- null
p <- inicio
en caso contrario
q <- p
p <- p(liga)
mientras p != inicio
si sw entonces
mensaje(´nodo borrado´)
en caso contrario
mensaje(´no existe información ´)
en caso contrario
mensaje(´no existe lista´)

Algoritmo que ordena una L.C.

Suponga que se tiene la siguiente lista circular:

El cual se desea ordenarla de manera ascendente. El algoritmo que se describe a continuación,

ordena la lista circular, moviendo únicamente la información del nodo.
si inicio != null entonces
p <- inicio
haz
q <- p(liga)
mientras q != inicio haz
si p(dato) > q(dato) entonces
x <- q(dato)
q(dato) <- p(dato)
p(dato) <- x
q <- q(liga)
p <- p(liga)
mientras p(liga) != inicio
en caso contrario
escribe(´no existe lista´)

Algoritmo que despliega una L.C.

si inicio != null entonces

p <- inicio
haz
escribe(p(dato))
p <- p(liga)
mientras p != inicio
en caso contrario
mensaje(´no existe lista´)

Ejemplos de la vida cotidiana en la cual se puede realizar una lista circular

 Escalera mecánica
 Problema de tiempo compartido utilizado por el planificador durante la programación de los
procesos en el sistema operativo.
 Juego de mesa para múltiples jugadores

Lista doblemente enlazadas

Las listas doblemente encadenadas, tienen las característica de que dado un apuntador p
posicionado en cualquier nodo que forme parte de la lista, esta puede ser examinada en ambos
sentidos, esto es de adelante hacia atrás y de atrás hacia adelante. Un nodo en una lista doblemente
encadenada tiene dos apuntadores, uno hacia el nodo siguiente y otro hacia el nodo anterior, como
lo podemos apreciar a continuación:
Tipos de L.D.E.

Existen dos tipos de lista doblemente encadenadas las cuales son :

 Circulares

 Lineales.

Algoritmo que crea una L.D.E.C.

top <- null

haz
mensaje('Desea crear un nodo S/N=')
leer(opc)
si opc = 's' entonces
si inicio= null entonces
inicio <- crear nodo()
leer(inicio(dato))
inicio(izq) <- inicio
inicio(der) <- inicio
en caso contrario
p <- crear nodo()
leer(p(dato)
p(der) <- inicio
p(izq) <- inicio(izq)
p(der(izq)) <- p
inicio(izq) <- p
hasta opc != 'N'

Algoritmo que recorre una L.D.E.C.

si inicio != null entonces

p <- inicio
haz
escribe(p(dato))
p <- p(der)
mientras p = top
en caso contrario
mensaje('Lista inexistente')
Algoritmo que inserta un nodo después de x dato.

si inicio != null Then

mensaje(‘Después de que dato quieres insertar=')
leer(x)
p <- inicio
haz
si p(dato) = x entonces
q <- crear nodo()
leer(q(dato))
q(der) <- p(der)
q(izq) <- p
p(izq(der)) <- q
p(der) <- q
en caso contrario
p <- p(der)
mientras (p != inicio o sw)
en caso contrario
mensaje('No existe lista')

Algoritmo que elimina un nodo con x dato.

si inicio != null entonces

mensaje('Información a borrar')
leer(info)
p <- inicio
haz
si p(dato) = info entonces
si p=inicio entonces
si inicio(der) = inicio entonces
inicio <- null
en caso contrario
inicio <- inicio(der)
p(izq(der)) <- p(izq)
p(der(izq)) <- p(der)
p(der) <- null
p(izq)<- null
en caso contario
p <- p(der)
mientras (p != inicio o sw)
en caso contrario
mensaje('Lista inexistente')

Algoritmo que ordena una L.D.E.C. moviendo apuntadores.

si inicio != null entonces

p <- inicio
haz
q <- p(der)
haz
si p(dato) > q(dato) entonces
 si p = inicio entonces
inicio<- q
q(der(izq)) <- q(der)
q(izq(der)) <- q(izq)
r <- q(der)
q(der) <- p
q(izq) <- p(izq)
q(izq(der)) <- q
q(der(izq)) <- q
p <- q
r <- q
en caso contrario
q <- q(der)
mientras q != inicio
en caso contrario
mensaje(‘no hay lista’)

Ejemplo de lista doble en la vida cotidiana

 CONCLUSION

De acuerdo a la forma de trabajo, y lo visto en este documento o trabajo realizado, podemos

concluir que:

Las listas simplemente enlazadas, son posiblemente las estructuras de datos más fáciles, rápidas y
sencillas de estudiar, aprender y entender. La resolución de una función relacionada con listas
simplemente enlazadas, es fácil y rápida, en especial porque no se requieren demasiadas líneas de
código, por ende la solución es inmediata.

La implementación de una aplicación basada en listas simplemente enlazadas, también supone un

fácil desarrollo, es especial si se trabaja con lenguajes de programación como Java, dada las
facilidades que brinda al momento de trabajar con este tipo de estructuras, un ejemplo es la facilidad,
eficacia y rapidez para eliminar un nodo de la lista, ya que con otras herramientas, lo más probable
sea tener que soltar el enlace nodo por nodo, mientras que en Java, solo soltamos el enlace del
nodo que queremos eliminar.

Las listas simplemente enlazadas, así como también otro tipo de estructuras similares, son útiles a
la hora de trabajar problemas como PILAS y COLAS, ya que se maneja la misma lógica de agregar,
borrar o buscar elementos. Algunos ejemplos pueden ser la fila para el cine o un banco, en donde tal
vez se necesite de estas tres funciones principales de listas simplemente enlazadas, para registrar
quien es el primero de la lista, el último, el tiempo que lleva en espera, etc.

A pesar, de que podríamos trabajar con árboles y/o grafos, cuando se trata de listas simplemente
enlazadas, lo más probable es que tanto nuestro árbol, como nuestro grafo, adquieran una
característica lineal.