Este documento describe las listas como una estructura de datos secuencial donde cada elemento se conoce como un nodo. Explica que las listas pueden ser estáticas o dinámicas dependiendo de si su tamaño puede cambiar en tiempo de ejecución. Detalla las operaciones básicas en listas como consultar, suprimir y añadir nodos. Además, explica cómo implementar listas enlazadas en C usando punteros para representar cada nodo y enlazarlos entre sí, permitiendo que la lista cambie de tamaño dinámicamente.

1. CARIBBEAN INTERNATIONAL UNIVERSITY
LICENCIATURA Y MAESTRIA EN GERENCIA
ESTRUCTURA DE DATOS
TRABAJO REALIZADO POR:
NELSON JAVIER VILLACRES GARCIA
CEDULA DE IDENTIDAD: 0915329767
PROFESORA:
ING. BARBARA BRICEÑO

2. Marcelo
Marcelo
Listas.
- Una lista es una estructura de datos secuencial.
- Es una estructura de datos interna que consiste en una secuencia lógica de elementos del
mismo tipo.
- Se denomina nodo a cada uno de los elementos de la lista, los que pueden ser datos simples o
estructuras de datos, principalmente registros.
- Como estructura abstracta se dice que es una estructura de datos dinámica pues el número de
nodos que la componen puede variar en tiempo de ejecución sin embargo la forma de
implementar la estructura puede limitar esta característica.
Ejemplo:
Lista del curso:
Luis
Juan
Marcelo
En una lista el acceso a los elementos se hace siempre a partir del anterior (excepto el
primero).
Operaciones:
- Consultar nodos
- suprimir nodos
- añadir nodos.
En una lista los elementos podrían ser insertados o eliminados en cualquier posición... sin
embargo esto está limitado por la forma de implementación de la lista.
- Estructuras estáticas (arreglos)
- Lista densa: la propia estructura determina cuál es el siguiente elemento de la lista.
- Estructuras dinámicas
- Lista enlazada: la posición del siguiente elemento de la estructura la determina el elemento
actual. Es necesario almacenar al menos la posición de memoria del primer elemento. Además
es dinámica, es decir, su tamaño cambia durante la ejecución del programa.

3. Lista con estructuras dinámicas
Gráficamente se suele representar así:
Como se ha dicho anteriormente, pueden cambiar de tamaño, pero su ventaja fundamental
es que son flexibles a la hora de reorganizar sus elementos; a cambio se ha de pagar una
mayor lentitud a la hora de acceder a cualquier elemento.
En la lista de la figura anterior se puede observar que hay dos elementos de información, x e
y. Supongamos que queremos añadir un nuevo nodo, con la información p, al comienzo de la
lista. - con crear ese nodo,
- Introducir la información p, y
- Hacer un enlace hacia el siguiente nodo, que en este caso contiene la información x.
Implementación
Para representar en lenguaje C esta estructura de datos se utilizarán punteros, un tipo de
datos que suministra el lenguaje. Se representará una lista vacía con la constante NULL. Se
puede definir la lista enlazada de la siguiente manera:
struct lista
{
int clave;
struct lista *sig;
};
Cuando se crea una lista debe estar vacía. Por tanto para crearla se hace lo siguiente:
struct lista *L; L = NULL;
- Inserción al comienzo de una lista:
Es necesario utilizar una variable auxiliar, que se utiliza para crear el nuevo nodo mediante
la reserva de memoria y asignación de la clave. Posteriormente es necesario reorganizar los
enlaces, es decir, el nuevo nodo debe apuntar al que era el primer elemento de la lista y a su
vez debe pasar a ser el primer elemento.
X Y VACIA

4. #include <stdlib.h>
struct lista{
int clave;
struct lista *sig;
};
int main(void){ struct lista *L; struct lista *p; int i;
L = NULL; /* Crea una lista vacia */
for (i = 4; i >= 1; i--)
{
/* Reserva memoria para un nodo */
p = (struct lista *) malloc(sizeof(struct lista));
p->clave = i; /* Introduce la informacion */
p->sig = L; /* reorganiza */
L = p; /* los enlaces */
}
}
- Recorrido de una lista.
La idea es ir avanzando desde el primer elemento hasta encontrar la lista vacía. Antes de
acceder a la estructura lista es fundamental saber si esa estructura existe, es decir, que no
está vacía. En el caso de estarlo o de no estar inicializada es posible que el programa falle y
sea difícil detectar donde, y en algunos casos puede abortarse inmediatamente la ejecución
del programa, lo cual suele ser de gran ayuda para la depuración.
El recorrido se hará de forma iterativa. En este caso se necesita una variable auxiliar que
se desplace sobre la lista para no perder la referencia al primer elemento.
int main(void)
{
struct lista *L; struct lista *p;
L = NULL;
/* crear la lista */
...
p = L;
while (p != NULL) {
printf("%d, ", p->clave);
p = p->sig;
}
}
A menudo resulta un poco difícil de entender la instrucción p = p->sig; Simplemente cambia
la dirección actual del puntero p por la dirección del siguiente enlace. También es común
encontrar instrucciones del estilo:

5. p = p->sig->sig; Esto puede traducirse en dos instrucciones, de la siguiente manera:
p = p->sig;
p = p->sig;
Obviamente sólo debe usarse cuando se sepa que p->sig es una estructura no vacía, puesto
que si fuera vacía, al hacer otra vez p = p->sig se produciría una referencia a memoria no
válida.