Universidad Autónoma de Nuevo León

Facultad de Ingeniería Mecánica y Eléctrica

Materia: Lab. Algoritmos Computacionales

Actividad Fundamental #5:

Listas enlazadas
Maestro: M.E. Pablo Eusebio De León Cepeda

Alumno: Estefany Gabriela Leija Reynaga

Matricula: 1954005
Grupo: 001
Hora y Día: V1 martes

Fecha de entrega: 17/02/22

Objetivo:

Entender, analizar y comprender el uso correcto y adecuado de las listas en el ambiente

informático de la programación

Introducción:

En esta actividad veremos el tema de listas enlazadas hablaremos de la definición y

especificar como se realiza su función, existen varias ramas de las listas enlazadas, pero
específicamente hablaremos de 3 listas enlazadas, primero daremos un conocimiento
básico de que es una lista enlazada, las listas enlazadas son apropiadas cuando se
trabaja con datos es una estructura lineal que almacena una colección de elementos
generalmente llamados nodos, en donde cada nodo puede almacenar datos y ligas a
otros nodos. De esta manera los nodos pueden localizarse en cualquier parte de la
memoria, utilizando la referencia que lo relaciona con otro nodo dentro de la
estructura.
Procedimiento:

Es una estructura de datos lineal y dinámica que se compone de un conjunto de nodos en

secuencia enlazados mediante un apuntador o referencia

La lista simple tiene un apuntador inicial

El último nodo de la lista apunta a nulo

Operaciones que se realizan:

Para la inserción y la eliminación, una única función bastará si está bien concebida de
acuerdo a lo que se necesite. Debo recordar que este artículo es puramente didáctico. Por lo
tanto, he escrito una función para cada operación de inserción y eliminación.

Ejemplo;
void inicializacion (Lista *lista);

Esta operación debe ser hecha antes de otra operación sobre la lista. Esta comienza el
puntero inicio y el puntero fin con el puntero NULL y el tamaño con el valor 0

La función:

void inicializacion (Lista *lista){

lista->inicio = NULL;

lista->fin = NULL;

tamaño = 0;

Estos son algunos de los pasos para la insercion que debemos seguir:

*Declaración del elemento que se va a insertar.

*Asignación de la memoria para el nuevo elemento.

*Introducción del contenido del campo de datos.

*Actualización de los punteros hacia el primer y último elemento si es necesario.

Ejemplo:

Inserción en una lista vacía

Ejemplo de la función:

int ins_en_lista_vacia (Lista *lista, char *dato);

La función retorna 1 en caso de error y en caso contrario devuelve 0.

/* inserción en una lista vacía */

int ins_en_lista_vacia (Lista * lista, char *dato){

Element *nuevo_elemento;

if ((nuevo_elemento = (Element *) malloc (sizeof (Element))) == NULL)

return -1;

if ((nuevo _elemento->dato = (char *) malloc (50 * sizeof (char))) == NULL)

return -1;

strcpy (nuevo_elemento->dato, dato);

nuevo_elemento->siguiente = NULL;

lista->inicio = nuevo_elemento;

lista->fin = nuevo_elemento;

lista->tamaño++;

return 0;

}
Una lista doblemente enlazada puede estar vacía o consistir de una secuencia de nodos,

donde cada nodo contiene un dato y sabe dónde están tanto el siguiente como el

anterior nodo o, alternativamente, que no hay siguiente o anterio.

Definiremos un tipo estructurado nodod para representar un nodo doble y un tipo listad

para representar una lista doblemente enlazada. El tipo nodod consiste de un dato y dos

apuntadores.

typedef struct nodod {

int a; // dato almacenado

struct nodod *sig ; // enlace al siguiente

struct nodod *ant ; // enlace al anterior

} nodod ;
Esta función pide la memoria para un nodo doble y llena sus campos. También revisa si

hubo memoria y si no termina el programa.

nodod * creaNodod (int x, nodod *p, nodod *q) {

nodod *t = ( nodod *) malloc ( sizeof ( nodod ) ) ;

if (t == NULL ) {

printf (" Error al crear nodod \n") ;

exit (0) ;

t- >a = x;

t- >sig = p;

t- >ant = q;

return t;

De nuevo tenemos el mismo repertorio de operaciones sobre este tipo listas:

Añadir o insertar elementos.

Buscar o localizar elementos.

Borrar elementos.

Moverse a través de la lista, siguiente y anterior.

Una lista circular es una lista lineal en la que el último nodo a punta al primero. Las
listas circulares evitan excepciones en las operaciones que se realicen sobre ellas. No
existen casos especiales, cada nodo siempre tiene uno anterior y uno siguiente.

En algunas listas circulares se añade un nodo especial de cabecera, de ese modo se

evita la única excepción posible, la de que la lista esté vacía.
El nodo típico es el mismo que para construir listas abiertas:

struct nodo {

int dato;

struct nodo *siguiente;

};

A pesar de que las listas circulares simplifiquen las operaciones sobre ellas, también
introducen algunas complicaciones. Por ejemplo, en un proceso de búsqueda, no es
tan sencillo dar por terminada la búsqueda cuando el elemento buscado no existe.

Se pueden entonces definir algunos métodos simples de actualización para una lista
circularmente ligada:

agregar: inserta un nuevo nodo v inmediatamente después del cursor; si la lista está
vacía, entonces v se convierte en el cursor y su apuntador sig apunta a el mismo.

remover: borra y regresa el nodo v inmediatamente después del cursor (no el propio
cursor, a menos que este sea el único nodo); si la lista queda vacía, el cursor es puesto
a null.

avanzar: avanza el cursor al siguiente nodo en la lista.

Este es un ejemplo de las operaciones de insertar

void inicialización (Lista *lista) {

lista->inicio = NULL;

lista->fin = NULL;

tamaño = 0;
}

Conclusión:

Este tema para mi es un poco complejo, que me costó realizar, tenia muy pocos
conocimientos sobre las listas y en esta actividad aprendí un poco mas sobre cómo es
su función y como es que se diferencian las unas a las otras, aunque solos nos
enfocamos a 3 listas en particular, tengo un poco mas de conocimiento de como es su
uso y la manera en la que se ve sus diagramas, se hablo de estas 3 por lo que son las
que mas frecuentamos y que deberíamos conocer bien.

Bibliografía:

http://www.itnuevolaredo.edu.mx/takeyas/apuntes/estructura%20de%20datos/Apunt
es/02-ListasSimples.pdf

https://www.programaenlinea.net/la-lista-enlazada-simple/

https://sites.google.com/site/edatosubo/4-estructura-de-datos-dinamicas/1-listas/2-
listas-doblemente-enlazadas

https://ccia.ugr.es/~jfv/ed1/tedi/cdrom/docs/ldoble.html

http://odin.fi-b.unam.mx/salac/practicasEDAA/eda1_p7.pdf

https://estr-datos-omar.blogspot.com/2011/10/listas-circulares.html