ESTRUCTURAS DE DATOS

LISTAS
Una lista es una estructura de datos secuencial.
Una manera de clasificarlas es por la forma de acceder
al siguiente elemento:
lista densa: la propia estructura determina cuál es el
siguiente elemento de la lista. Ejemplo: un array.
- 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.
 ESTRUCTURAS DE DATOS
LISTAS

Una lista enlazada se puede definir recursivamente

de la siguiente manera:
-una lista enlazada es una estructura vacía o
- un elemento de información y un enlace hacia una
-lista (un nodo).
Gráficamente se suele representar así:
La lista vacía con la constante NULL.
 ESTRUCTURAS DE DATOS
LISTAS
Cuando haya que insertar un nuevo elemento en la lista
ordenada
hay que hacerlo en el lugar que le corresponda, y esto depende
del orden y de la clave escogida.
Para las listas enlazadas se debe definir un registro
de la siguiente manera
Typedef lista=record
Int clave;
Lista *sig;
}
Para simplicidad Se utilitaran solo apuntadores
Lista *primero, *anterior, *actual, *nuevo;
 ESTRUCTURAS DE DATOS
LISTAS
El proceso de inserción se realiza en tres pasos:
1.- Localizar el lugar correspondiente al elemento a insertar.
Se
utilizan dos punteros: anterior y actual, que garanticen la
correcta
posición de cada enlace.
2.- Reservar memoria para él (puede hacerse como primer
paso).
Se usa un puntero *nuevo para reservar memoria.
3.- Enlazarlo. Esta es la parte más complicada, porque hay que
considerar la diferencia de insertar al principio, no importa si la
lista está vacía, o insertar en otra posición. Se utilizan los tres
punteros antes definidos para actualizar los enlaces.
Busqueda, creacion de nodo e insercion en una lista
ordenada
int main(void)
lista *Primero;
Primero = NULL; /* Lista vacia */
/* para probar la insercion se han tomado 3 elementos */
insertar(&Primero, 0);
insertar(&Primero, 1);
insertar(&Primero, -1);
return 0;
void insertar(lista **Primero, int elem)
lista *actual, *anterior, *nuevo;
/* 1.- se busca su posicion */
anterior = actual = *Primero;
while (actual != NULL && actual->clave < elem) {
anterior = actual;
actual = actual->sig;
}
/* 2.- se crea el nodo */
nuevo = (struct lista *) malloc(sizeof(struct lista));
nuevo->clave = elem;
/* 3.- Se enlaza */
If Primero== NULL Then
Primero=nuevo; /*primer elemento en la lista
else {
if *Primero == actual) { /* inserta al principio */
nuevo->sig = actual;
*Primero = nuevo; /* importante: al insertar al
principio actualiza la cabecera */
}
else { /* inserta entre medias o al final */
nuevo->sig = actual;
anterior->sig = nuevo; /*importante enlazar antes el
nuevo nodo para no perder
en enlace y la lista*/
}
}
El procedimiento consiste en localizarlo y borrarlo si existe. Aquí también se distingue el caso de
borrar al principio o borrar en cualquier otra posición. Se puede observar que el algoritmo no tiene
ningún problema si el elemento no existe o la lista está vacía.
void borrar(struct lista **primero, int elem)
{
struct lista *actual, *anterior;
/* 1.- busca su posicion. Es casi igual que en la insercion, ojo al (<)
*/
*anterior = *actual = *Primero;
while (actual != NULL && actual->clave < elem) {
anterior = actual;
actual = actual->sig;
}
/* 2.- Lo borra si existe */
If Primero==NULL then
Writeln ( “Lista vacia” )
else {
if (actual != NULL && actual->clave == elem) {
if (primero == actual) /* borrar el primero */
*Primero = primero->sig; /* o tambien *Primero= actual->sig; */
else /* borrar en otro sitio */
anterior->sig = actual->sig;
free(actual);
}
}
}
 ESTRUCTURAS DE DATOS
LISTAS
int main(void) /*Recorrido sin recursion*/
struct lista *Primero;
struct lista *actual;
int suma;
Primero = NULL;
/* crear la lista */
/*ver algoritmos anteriores*/
...
actual = Primero;
suma = 0;
while (actual != NULL) {
printf("%d, ", actual->clave);
suma = suma + actual->clave;
actual = actual->sig;
}
return suma;
}
 ESTRUCTURAS DE DATOS
LISTAS
Al igual que el anterior muestra el valor de la clave y almacena la suma de todos los valores
en una variable pasada por referencia (un puntero a entero) Note que el recorrido recursivo
int main(void)
{
lista *Primero
lista *actual;
int suma;
Primero = NULL;
/* crear la lista */
...
actual=primero
suma = 0;
recorrer(actual, &suma);
return 0;
}
void recorrer(struct lista *Primero, int suma)
{
if (actual = NULL) then return Suma
else
{
printf("%d, ", actual->clave);
*suma = *suma + actual->clave;
recorrer(actual->sig, suma);
}
}
Elabore este algoritmo de manera recursiva, tal que la suma se ejecute en el proceso de backtracking
 ESTRUCTURAS DE DATOS
LISTAS
Otros ejemplo de manejo de Lista
Type lista=record
Clave: Integer;
*sig: lista;
Fin registro
int main(void)
inicio
*Primero, *actual: lista;
i:integer;
Primero= NULL; /* Crea una lista vacia */
for (i = 4; i >= 1; i--)
inicio
/* Reserva memoria para un nodo */
actial = lista * malloc(sizeof(struct lista));
actual->clave = i; /* Introduce la informacion */
actual->sig = Primero; /* reorganiza */
Primero= actual; /* los enlaces */
fin del for
return 0;
End function
Es recursiva esta funcion Porque? Indique que hace este algoritmo?