Estructuras de

datos Abstractas
Clase 3
Listas abiertas

 La forma más simple de estructura dinámica

 En esta forma los nodos se organizan de modo que cada

uno apunta al siguiente

 El último no apunta a nada

 El primer nodo es llamado cabeza de la lista

Declaración típica de un nodo

struct nodo {
int dato;
struct nodo *siguiente;
};

typedef struct nodo* elemento;

struct nodo {
int dato;
elemento siguiente;
};
Forma de una lista simple
Ejercicio

 Crear un funciones de una lista simple para agregar

elementos, obtener elementos y borrar elementos,
moverse por la lista y eliminar la lista simple.

 Nota: nodo es el elemento a agregar o a regresar.

Paso 0.- Definir el nodo

 Obvio no?

typedef struct _nodo {

int dato;
struct _nodo *siguiente;
} tipoNodo;
Paso 1.- insertar un nodo

 Insertar el primer nodo

 Insertar en la primera posición de una lista no vacía

Paso 1.- Insertar un nodo

 Insertar al final de una lista no vacía

 Insertar después de n elementos de una lista

Paso 2.- Localizar un nodo

 Asignamos al puntero índice el valor de Lista.

 Abriremos un bucle que al menos debe tener una

condición, que el índice no sea NULL.

 Dentro del bucle asignaremos al índice el valor del nodo

siguiente al índice actual.
Simple no?

typedef struct _nodo {

int dato;
struct _nodo *siguiente;
} tipoNodo;

typedef tipoNodo *pNodo;

typedef tipoNodo *Lista;
//...
pNodo indice;
//...
indice = Lista;

while(indice) {
printf("%d\n", indice->dato);
indice = indice->siguiente;
}
3.- Eliminar un nodo de la
lista
 Eliminar el primer nodo.
 Hacemos que nodo apunte al primer elemento de la lista,
es decir a Lista.
 Asignamos a Lista la dirección del segundo nodo de la
lista: Lista->siguiente.
 Liberamos la memoria asignada al primer nodo, el que
queremos eliminar.
3.- Eliminar un nodo

 Eliminar cualquier otro nodo.

 Hacemos que nodo apunte al nodo que queremos borrar.
 Asignamos como nodo siguiente del nodo anterior, el
siguiente al que queremos eliminar:
anterior->siguiente = nodo->siguiente.
 Eliminamos la memoria asociada al nodo que queremos
eliminar.
4.- Moverse a travéz de una
lista
 Primer Nodo

 El nodo siguiente

 EL nodo anterior

 En último nodo
Eliminar la lista

 El algoritmo genérico para borrar una lista completa

consiste simplemente en borrar el primer elemento
sucesivamente mientras la lista no esté vacía.
Pilas

 Tipo especial de lista abierta con comportamiento LIFO

 Sólo se pueden insertar y eliminar nodos

 Estas operaciones se conocen como "push" y "pop“

 Las escrituras de datos siempre son inserciones de nodos

 Las lecturas siempre eliminan el nodo leído.

Declaración de pilas

typedef struct _nodo {

int dato;
struct _nodo *siguiente;
}tipoNodo;
typedef tipoNodo *pNodo;
typedef tipoNodo *Pila;
Lo mismo que para una lista…
A trabajar 

 Realizar las operaciones pop y push en una pila

typedef struct _nodo {

int dato;
struct _nodo *siguiente;
}tipoNodo;
typedef tipoNodo *pNodo;
typedef tipoNodo *Pila;

 Nota: nodo es el elemento a agregar o a regresar.

1.- Push

 Pila vacía
 nodo->siguiente apunte a NULL.
 Pila apunte a nodo.

 Pila no tan vacía

 Hacemos que nodo->siguiente apunte a Pila.
 Hacemos que Pila apunte a nodo.
2.- Pop

 Hacemos que nodo apunte al primer elemento de la

pila, es decir a Pila.
 Asignamos a Pila la dirección del segundo nodo de la
pila: Pila->siguiente.
 Guardamos el contenido del nodo para devolverlo como
retorno, recuerda que la operación pop equivale a leer
y borrar.
 Liberamos la memoria asignada al primer nodo, el que
queremos eliminar.
Colas

 Una cola es un tipo especial de lista abierta.

 Sólo se pueden insertar nodos en uno de los extremos de la

lista.

 Sólo se pueden eliminar nodos en el otro.

 Este tipo de lista es conocido como lista FIFO.

Declaración de colas

typedef struct _nodo {

int dato;
struct _nodo *siguiente;
} tipoNodo;

typedef tipoNodo *pNodo;

typedef tipoNodo *inicioCola;
typedef tipoNodo *finCola
Y de nuevo a programar

 Escribir el código para añadir y leer de una cola

typedef struct _nodo {

int dato;
struct _nodo *siguiente;
} tipoNodo;

typedef tipoNodo *pNodo;

typedef tipoNodo *inicioCola;
typedef tipoNodo *finCola

 Nota: nodo es el elemento a agregar o a regresar.

1.- Añadir
 Cola vacía
 Hacer que nodo->siguiente apunte a NULL.
 Que el puntero primero apunte a nodo.
 Y que el puntero último también apunte a nodo.

 Cola no vacía
 Hacemos que nodo->siguiente apunte a NULL.
 Después que ultimo->siguiente apunte a nodo.
 Y actualizamos ultimo, haciendo que apunte a nodo.
2.- Leer

 Cola con un solo elemento.

 Hacemos que nodo apunte al primer elemento de la pila, es decir a
primero.
 Asignamos NULL a primero, que es la dirección del segundo nodo
teórico de la cola: primero->siguiente.
 Guardamos el contenido del nodo para devolverlo como retorno,
recuerda que la operación de lectura en colas implican también
borrar.
 Liberamos la memoria asignada al primer nodo, el que queremos
eliminar.
 Hacemos que ultimo apunte a NULL, ya que la lectura ha dejado la
cola vacía.
2.- Leer

 Cola con más de un elemento

 Hacemos que nodo apunte al primer elemento de la cola,
es decir a primero.
 Asignamos a primero la dirección del segundo nodo de la
pila:
primero->siguiente.
 Guardamos el contenido del nodo para devolverlo como
retorno, recuerda que la operación de lectura en colas
implican también borrar.
 Liberamos la memoria asignada al primer nodo, el que
queremos eliminar.
Lista circular

 Lista lineal en la que el último nodo a punta al primero.

 Las listas circulares evitan excepciones en la operaciones

que se realicen sobre ellas.

 En algunas listas circulares se añade un nodo especial de

cabecera.

 Evitar la única excepción posible, la de que la lista esté

vacía.
Declaración de nodos de
listas circulares
typedef struct _nodo {
int dato;
struct _nodo *siguiente;
} tipoNodo;
typedef tipoNodo *pNodo;
typedef tipoNodo *Lista;
1.- Añadir elemento
 Lista vacía
 lista apunte a nodo.
 lista->siguiente apunte a nodo.

 Lista no vacía
 Hacemos que nodo->siguiente apunte a lista->siguiente.
 Después que lista->siguiente apunte a nodo.
2.- Buscar un elemento

 Igual que en una lista simple

 Considerar el nodo donde se comenzó la búsqueda para

no entrar en un ciclo infinito.

 Se puede comenzar en cualquier nodo de la lista

3.- Eliminar un elemento

 Un nodo diferente a la cabeza

 Conseguir que lista apunte al nodo anterior al que
queremos eliminar. Esto se consigue haciendo que lista
valga
 Hacemos que lista->siguiente apunte a nodo->siguiente.
 Eliminamos el nodo.
3.- Eliminar un elemento

 Eliminar el único nodo en una lista

 Borramos el nodo apuntado por lista.
 Hacemos que lista valga NULL.
Lista doblemente enlazadas

 Una lista doblemente enlazada es una lista lineal en la

que cada nodo tiene dos enlaces.

 Un enlace al nodo siguiente, y otro al anterior.

 Pueden recorrerse en ambos sentidos a partir de

cualquier nodo.

 A partir de cualquier nodo, siempre es posible alcanzar

cualquier nodo de la lista
Declaración de nodos de
listas doblemente enlazadas
typedef struct nodo {
int dato;
struct _nodo *siguiente;
struct _nodo *anterior; }
tipoNodo; typedef tipoNodo *pNodo;
typedef tipoNodo *Lista;
Tarea
 Realizar las operaciones en listas doblemente enlazadas
 Añadir o insertar elementos.
 Vacía.
 Primera posición.
 Última posición
 En la enésima posición

 Buscar o localizar elementos.

 Borrar elementos.
 Eliminar el único nodo de una lista doblemente enlazada.
 Eliminar el primer nodo.
 Eliminar el último nodo.
 Eliminar un nodo intermedio.

 Borrar la lista enlazada