Listas doblemente enlazadas

Leonardo Esteban Yáñez Melo

Estructura de Datos

Instituto IACC

16 de diciembre de 2019
 Desarrollo

1. Un inspector de un tren está indagando si el pasajero del asiento 23a está en el vagón de la
imagen, para validar el proceso el inspector deberá consultar el ticket del pasajero. Indique
qué operación de listas doblemente enlazadas está realizando el inspector. Explique con sus
palabras y aplicando los conceptos tratados en los contenidos, la forma en la cual se
desarrolla esta operación.

Para este caso nos encontramos con la operación BÚSQUEDA, ya que el inspector necesita

localizar un nodo (para este caso un pasajero con ticket), en este caso se muestra que la búsqueda

del nodo que se requiere puede realizarse en ambas direcciones, el fin es encontrar el elemento

de la lista doblemente enlazada que se requiere. En este tipo de listas la verificación se puede

realizar tanto de inicio a final como viceversa, debido a que el nodo que se solicita encontrar

(23a) ya está estipulado. Para los fines de realizar la comprobación del ticket referente (en este

caso) al pasajero del 23a en este vagón, debe realizar el recorrido de búsqueda del asiento en sí.
2. Realice una tabla comparativa entre listas enlazadas y listas doblemente enlazadas,
considerando 2 diferencias y/o similitudes en cada caso.
LISTAS ENLAZADAS
Enlazan contenido dinámicamente
Se implementan con apuntadores
Tienen un apuntador al inicio de la lista
Se debe recorrer de forma lineal de inicio a
final de la lista. Se denomina que son de
acceso secuencial.
No es posible regresar al elemento anterior
Los nodos pueden crearse cada vez que sea
necesario e insertar donde se desee.
Se almacenan en cualquier parte de la
memoria
Operadores:
- Insertar
- Eliminar
- Buscar
- Vaciar
Se pueden insertar nuevos elementos hasta
que la memoria lo permita, como son de
tamaño pequeño, pueden ingresarse cuanto
nodo se necesite
Para la búsqueda de un nodo se debe recorrer
todos los anteriores a este.
El código puede complicarse
Se puede insertar un nodo al final, el nodo
ingresado pasa a ser parte del final apuntado a
NULL
LISTAS DOBLEMENTE ENLAZADAS
Cada nodo se compone del dato y dos
punteros. Un puntero apunta al elemento
anterior y otro al siguiente
La lista se puede recorrer desde ambos lados
para encontrar un nodo (de inicio a final o
viceversa)
Los nodos pueden eliminarse de una forma
más fácil, una vez encontrado el nodo se
procede a eliminar
Operadores:
- Insertar
- Eliminar
- Buscar (la búsqueda se puede realizar
en ambas direcciones).
- Vaciar
Pueden ingresarse y eliminar elementos
cuando se necesite
El recorrido puede ser en ambas direcciones
Se puede insertar un nodo al final, el nodo
ingresado pasa a ser parte del final apuntado a
NULL
3. Usando la siguiente imagen ejemplifique cómo se realiza operación de inserción de un nodo

20 entre el nodo 12 y el nodo 57. Explique paso a paso cómo se realiza el proceso.

Pasos para ingresar un nuevo dato:

Primero: Debemos crear nuestro nuevo NODO al que se le dará un valor (Dato) que en

este caso es 20. Como es una lista doblemente enlazada, nuestro nuevo nodo se compone,

además del dato, de dos punteros en null.

20

Segundo: Procedemos a ingresar el nuevo elemento a la lista ya estipulada, por lo que

debemos ubicar nuestro nodo en un lugar que le permita conectar con los otros nodos (el

anterior y siguiente de su posición final)

20

12 57 95
 Tercero: Procedemos a conectar los punteros, en este apartado se enlazan los datos entre

sí, el dato 20 se enlaza con el dato anterior que corresponde al nodo con valor 12, además

se enlaza con el nodo siguiente que se detalla como un nodo con valor 57.

20

12 57 95

Cuarto: La forma final de la lista con el nuevo componente sería, donde se puede

verificar que los nodos se encuentran con el mismo orden, pero con el dato de valor 20

ingresado en la lista con sus respectivos punteros.

12 20 57 95

Proceso para la inserción de un nuevo elemento (como ejemplo, no es a partir del ejemplo
anterior)
void insertar (tElemento x, tPosicion p, tLista l)
Argumentos:
l: Es modificada.
p: Es una posición válida para la lista l.
x: Dirección válida de un elemento del tipo T con que se instancia la lista, distinta de NULL.
Efecto: Inserta elemento x en la posición p de la lista l desplazando todos los demás elementos
en una posición.
En este ejemplo se procede a eliminar un elemento de la lista

void borrar (tPosicion *p, tLista l)

Argumentos:
l: Es modificada.
p: Es una posición válida para la lista l.
Efecto: Elimina el elemento de la posición p de la lista l desplazando todos los demás elementos
en una posición.

A continuación se presenta un ejemplo de la implementación de una lista doblemente enlazada

(solo a modo de ejmeplo)

typedef struct celda {

tElemento elemento;
struct celda *siguiente,*anterior;
} tipocelda;

typedef tipocelda *tPosicion;

typedef tipocelda *tLista;

static void error(char *cad)

{
fprintf(stderr, "ERROR: %s\n", cad);
exit(1);
}

tLista Crear()
{
tLista l;

l = (tLista)malloc(sizeof(tipocelda));
if (l == NULL)
Error("Memoria insuficiente.");
l->siguiente = l->anterior = l;
return l;
}

void Destruir (tLista l)

{
tPosicion p;

for (p=l, l->anterior->siguiente=NULL; l!=NULL; p=l) {

l = l->siguiente;
 free(p);
}
}

tPosicion Primero (tLista l)

{

return l->siguiente;
}

tPosicion Fin (tLista l)

{

return l;
}

void Insertar (tElemento x, tPosicion p, tLista l)

{
tPosicion nuevo;

nuevo = (tPosicion)malloc(sizeof(tipocelda));
if (nuevo == NULL)
Error("Memoria insuficiente.");
nuevo->elemento = x;
nuevo->siguiente = p;
nuevo->anterior = p->anterior;
p->anterior->siguiente = nuevo;
p->anterior = nuevo;
}

void Borrar (tPosicion *p, tLista l)

{
tPosicion q;

if (*p == l){
Error("Posicion fin(l)");
}
q = (*p)->siguiente;
(*p)->anterior->siguiente = q;
q->anterior = (*p)->anterior;
free(*p);
(*p) = q;
}

tElemento elemento(tPosicion p, tLista l)

{

if (p == l){
Error("Posicion fin(l)");
}
return p->elemento;
}

tPosicion siguiente (tPosicion p, tLista l)

{

if (p == l){
Error("Posicion fin(l)");
}
return p->siguiente;
}

tPosicion anterior( tPosicion p, tLista l)

{

if (p == l->siguiente){
Error("Posicion primero(l)");
}
return p->anterior;
}

tPosicion posicion (tElemento x, tLista l)

{
tPosicion p;
int encontrado;

p = primero(l);
encontrado = 0;
while ((p != fin(l)) && (!encontrado))
if (p->elemento == x)
encontrado = 1;
else
p = p->siguiente;
return p;
}
 Bibliografía

Instituto IACC 2019. Estructura de Datos. Semana 6. Listas Doblemente enlazadas

Galeón.com. Listas doblemente enlazadas.

http://edatosucb.galeon.com/Exposiciones.htm

Listas doblemente enlazadas.

http://decsai.ugr.es/~jfv/ed1/tedi/cdrom/docs/ldoble.html