Listas Pilas Colas

Listas, pilas y colas
Eva Lucrecia Gibaja Galindo

Dpto. Informtica y Anlisis Numrico
Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico
Operadores de estructuras
Operador miembro de estructura. Conecta el

nombre de la estructura con el nombre del
miembro.
struct punto
{
int x;
int y;
};
struct punto p;
printf(%d, %d, p.x, p.y);
En muchos casos, se utilizan punteros a

estructuras.
struct punto* p;
printf(%d, %d, (*p).x, (*p).y);
Los parntesis son necesarios en (*p).x

debido a que la precedencia del operador . es
mayor que la de *.
La expresin *p.x significa *(p.x), lo cual
es ilegal ya que x no es un puntero.
Los punteros a estructuras son tan frecuentes que se ha

proporcionado una notacin alternativa como abreviacin.
Si p es un puntero a estructura, entonces p->miembro de
estructura se refiere al miembro en particular.
struct punto* p;
printf(%d, %d, p->x, p->y);
// Equivale a printf(%d, %d, (*p).x, (*p).y);
p
*p
(*p).x
(*p).y
p
p->x
p->y
Listas
Dado un dominio, D, una lista de elementos de

dicho conjunto es una sucesin finita de
elementos del mismo.
struct lista
{
int n;
n siguiente
struct lista *sig;

};
5
Listas
struct lista *nuevoElemento();

void insertarDelante(struct lista **cabeza, int n);
void insertarDetras(struct lista **cabeza, int n);
void recorrerLista(struct lista *cabeza);
int buscarElemento(struct lista *cabeza, int n);
void borrarElemento(struct lista **cabeza, int n);
void insertarOrden(struct lista **cabeza, int n);
void recorrerListaInverso(struct lista *elemento);
void borrarLista(struct lista **elemento);
void borrarElementoRecursivo(struct lista **cabeza,
int n);
void insertarOrdenRecursivo(struct lista **cabeza,
int n);
void ordenarLista(struct lista *cabeza)
Listas. En la funcin main()

main()
{
int n, encontrado;
struct lista *cabeza = NULL; //LISTA VACIA
printf("Elemento a insertar :");
scanf("%d", &n);
/* Comprueba si el elemento ya existe */
encontrado = buscarElemento(cabeza, n); //PASO POR VALOR
if (!encontrado)
{
insertarDelante(&cabeza, n); //PASO POR REFERENCIA
printf("\n Elemento insertado");
}
}
Listas. NuevoElemento
Crea un nuevo elemento struct lista
struct lista *nuevoElemento()

{
return ((struct lista *)malloc(sizeof(struct lista)));
}
Listas.InsertarDelante
pasamos doble puntero (**)

porque vamos a modificar la
direccin de comienzo de la lista
void insertarDelante(struct lista **cabeza, int n)

{
struct lista *nuevo = NULL;
/* Se reseva espacio para el nuevo elemento */
nuevo = nuevoElemento();
nuevo->n = n;
/*El nuevo elemento se enlaza a la cabeza, y este
ser la nueva cabeza */
nuevo->sig = *cabeza; 1
*cabeza = nuevo; 2
}
n1
n2
ni
*cabeza
nuevo elemento
cabeza
10
n1
n2
ni
*cabeza
1
n
nuevo elemento
cabeza
11
n1
n2
ni
nuevo elemento
2
*cabeza
cabeza
12
Listas.InsertarDetras
void insertarDetras(struct lista **cabeza, int n)
{
struct lista *nuevo = NULL;
struct lista *aux = NULL;
/* se reserva espacio para el nuevo elemento */
nuevo->n = n;
Condicin de ltimo elemento de la lista. No lo
nuevo->sig = NULL;
hace el constructor y lo tenemos que hacer a mano
if (*cabeza == NULL) /* la lista est vacia y el

nuevo ser la cabeza */
*cabeza = nuevo;
13
else /* se localiza el ltimo elemento para enlazarlo
al nuevo */
{
aux = *cabeza;
Esto nos servir
siempre que queramos
while(aux->sig != NULL)
recorrer la lista
{
aux = aux->sig;
}
aux->sig = nuevo;
}
}
Si utilizramos aux!=NULL no nos quedaramos con un puntero al ltimo elemento,
sino al ltimo puntero a NULL
14
Caso 1. Lista vaca
n
nuevo elemento
*cabeza
*cabeza
cabeza
cabeza
15
n1
n2
ni
n
nuevo elemento
*cabeza
cabeza
aux
Caso 2. Lista NO vaca

16
Listas.RecorrerLista
void recorrerLista(struct lista *cabeza)
{
aux = cabeza;
while (aux != NULL)
{
printf(" %d \n", aux->n);
aux = aux->sig;
}
}
Si utilizramos aux->sig!=NULL no escribiramos el ltimo elemento
17
Listas.RecorrerLista
n1
n2
cabeza
n1
ni
.....
ni
aux
n2
cabeza
.....
aux
18
Listas.BuscarElemento
int buscarElemento(struct lista *cabeza, int n)
{
int encontrado = 0;
aux = cabeza;
/* Se recorre la lista hasta encontrar el elemento o hasta
llegar al final */
while (aux != NULL && encontrado ==0)
{
if (aux->n == n)
encontrado = 1;
else
aux = aux->sig;
}
return encontrado;
19
}
Listas.BuscarElemento
n1
n2
cabeza
.....
ni
aux
20
Listas.BorrarElemento
void borrarElemento(struct lista **cabeza, int n)
{
struct lista *ant = NULL; /* almacena el elemento
anterior al que se borra*/
struct lista *aux = NULL; /* almacena el elemento a
borrar */
aux = *cabeza;
/* Busqueda del elemento a borrar y su anterior */
while (aux->n != n)
{
Se presupone que el
ant = aux;
elemento est en la
aux = aux->sig;
lista
}
21
if (aux == *cabeza) /* el elemento a borrar es la
cabeza */
{
1 *cabeza = aux->sig;/*la nueva cabeza es el siguiente*/
2 free(aux); /* se libera la antigua cabeza */
}
else /* El elemento a borrar no es la cabeza */
{
3 ant->sig = aux->sig; /* Se enlaza el anterior con
el siguiente */
4 free(aux); /* se libera el nodo a borrar */
}
}
22
n1
n2
*cabeza
ni
aux
n1
n2
2
cabeza
Caso 1. El elemento a
borrar es la cabecera
aux
ni
1
*cabeza
cabeza
23
n1
n2
*cabeza
cabeza
n3
ant
ni
aux
borrar NO es la cabecera
24
n1
n2
n3
ni
4
*cabeza
cabeza
ant
aux
borrar NO es la cabecera
25
Listas.InsertarOrden
Se presupone que la lista ha sido

previamente ordenada, o que todas
las inserciones se han hecho en orden
void insertarOrden(struct lista **cabeza, int n)

{
struct lista *ant = NULL;
/*anterior al que se inserta*/
/*posterior al que se inserta*/
struct lista *nuevo = NULL; /* nuevo elemento */
int encontrado = 0;
/*posicin de insercin encontrada*/
/* Se reserva espacio para el nuevo elemento */
nuevo->n = n;
if (*cabeza == NULL) /* lista vaca */
{
*cabeza = nuevo; /* la cabeza ser el nuevo elemento */
(*cabeza)->sig = NULL; /*condicin de ultimo de la lista */
}
26
else{ /* lista no vaca */
aux = *cabeza;
if ( aux->n > n){ /* Se inserta delante de la cabeza */
1 nuevo->sig = *cabeza; /*siguiente a nuevo ser la cabeza */
*cabeza = nuevo; /* La nueva cabeza ser el nuevo elemento */
2}
else{ /* busqueda de la posicion de insercion*/
while (aux != NULL && encontrado == 0){
if (aux->n > n) /*posicion de insercion encontrada*/
{encontrado = 1;}
else{ /* se actualizan los valores de aux y ant */
{
ant = aux;
aux = aux->sig;
}
}//while
nuevo->sig = aux; 3
ant->sig = nuevo;
4
}//else
}//else
}
27
Caso 1. Lista vaca
nuevo elemento
*cabeza
*cabeza
cabeza
cabeza
28
n1=9
n2
n3
ni
*cabeza
3
nuevo elemento
cabeza

2.1.Insercin en la cabeza
29
1
3
n1=9
n2
n3
ni
2
*cabeza
cabeza

2.1.Insercin en la cabeza
30
n2=2
n1=1
n2=9
n3
ni
*cabeza
3
nuevo elemento
cabeza

2.2.Insercin en el centro de la lista
31
4
n1=1
n2=2
3
3
n3 =9
ni
*cabeza
ant
cabeza
aux

2.2.Insercin en el centro de la lista
32
Listas.RecorrerListaInverso
void recorrerListaInverso(struct lista
*elemento)
{
if (elemento != NULL)
{
recorrerListaInverso(elemento->sig);
printf(" %d \n", elemento->n);
}
}
33
Listas.BorrarLista
void borrarLista(struct lista **elemento)
{
if (*elemento != NULL)
{
borrarLista(&((*elemento)->sig));
free(*elemento);
}
}
34
Listas.BorrarLista
n1
n2
n3
n4
*elemento
En la llamada a la funcin, se pasa la

direccin de memoria de la direccin
del puntero al primer elemento de la
lista
elemento
35
Listas.BorrarLista
*elemento
n1
n2
n3
n4
elemento
En las llamadas sucesivas, al hacer &((*elemento)->siguiente)

pasamos la direccin de memoria del puntero (*elemento)>siguiente
36
Listas.BorrarLista
*elemento
n1
n2
n3
n4
elemento
Caso base: *elemento==NULL
37
Listas.BorrarLista
*elemento
n1
n2
n3
n4
elemento
Vuelta atrs de la recursividad

38
Listas.BorrarElementoRecursivo
void borrarElementoRecursivo(struct lista **cabeza, int n)
{
struct lista *aux = NULL; /*elemento a borrar */
if ((*cabeza)->n != n)
{
borrarElementoRecursivo( &((*cabeza)->sig), n);
}
else
Se presupone que el elemento est
{
en la lista
aux = *cabeza; 1
*cabeza = aux->sig; 2
free (aux); 3
}
}
39
n1
n2
n3
n4
*cabeza
En la llamada a la funcin, se pasa la

direccin de memoria de la direccin
del puntero al primer elemento de la
lista
cabeza
40
*cabeza
n1
n2
n3
ni
cabeza
En las llamadas sucesivas, al hacer &((*cabeza)->siguiente)
pasamos la direccin de memoria del puntero (*cabeza)->siguiente
41
*cabeza
n1
n2
2
n3
3
ni
1
aux
cabeza
42
Listas.InsertarOrdenRecursivo
void insertarOrdenRecursivo(struct lista **cabeza,
int n)
{
struct lista *nuevo = NULL; /*nuevo elemento */
if (*cabeza == NULL) /* vacia o mayor que todos */
{
nuevo->n = n;
Se presupone que la lista ha sido
nuevo->sig = NULL;
previamente ordenada, o que todas
(*cabeza) = nuevo; 1
las inserciones se han hecho en orden
}
43
else
{
if ((*cabeza)->n > n)
{
nuevo->n = n;
nuevo->sig = (*cabeza); 2
*cabeza = nuevo;
3
}
else
{
insertarOrdenRecursivo( &((*cabeza)->sig), n);
}
}
}
44
9
11
13
*cabeza
15
nuevo elemento
cabeza
Caso 1. Lista vaca o mayor elemento
45
9
11
13
*cabeza
1
15
cabeza
Caso 1. Lista vaca o mayor elemento
46
*cabeza
9
11
13
10
nuevo elemento
cabeza
Caso 2. Insercin en el centro
47
*cabeza
9
2
10
11
13
cabeza
Caso 2. Insercin en el centro
48
Listas.OrdenarLista
Algoritmo de Seleccin
void ordenarLista(struct lista *cabeza)

{
struct lista *aux;
//Intercambio aux y minimo
struct lista *aux1;
struct lista *minimo;
minimo_n = minimo->n;
int minimo_n;
minimo->n = aux->n;
aux = cabeza;
aux->n = minimo_n;
//Recorrer toda la lista
//Preparar siguiente iteracin
while(aux->sig != NULL)//while1
aux = aux->sig;
{ aux1 = aux->sig;
}//While1
minimo = aux;
}
while(aux1 != NULL)//while2
{
if (aux1->n < minimo->n)
{
minimo = aux1; //seleccionar minimo
}
aux1 = aux1->sig;
}//while 2
49
Otras implementaciones
Mediante vectores
Los elementos son

posiciones consecutivas de
un vector.
Las listas son de longitud
variable y los vectores de
longitud fija. Se considerarn
vectores de tamao igual a la
longitud mxima de la lista.
Se aade un entero para
indicar el ltimo elemento
vlido de la lista.
struct lista
{
int utiles;
int elementos[LMAX];
};
utiles
0
LMAX-1
50
Inconvenientes
En algunas operaciones hay que mover todos los elementos que

ocupen una posicin superior a la considerada para realizar dicha
operacin. Esto tiene como consecuencia que la eficiencia de las
operaciones no es muy buena, del orden del tamao de la lista.
Para la operacin de insercin hay que hacer previamente un hueco donde

realizar dicha insercin.
Para el borrado, hay que rellenar el hueco dejado por el elemento borrado.
Otro inconveniente es que las listas tienen un tamao mximo que no

se puede pasar.
Siempre hay una porcin de espacio reservada para los elementos de
la lista, y que no se utiliza al ser el tamao de la lista en un momento
dado, menor que el tamao mximo.
51
Listas doblemente enlazadas
En algunas aplicaciones podemos desear:

Recorrer una lista hacia delante y hacia atrs.
Conocer rpidamente los elementos anterior y siguiente dado un un determinado elemento.
La solucin es dotar a cada elemento de la lista de un puntero a los elementos anterior y

siguiente.
El precio que se paga es la presencia de un puntero adicional en cada elemento.
struct lista{
int n;
anterior
n siguiente
struct lista *sig, * ant;

};
52
Listas doblemente enlazadas
Se suele hacer que la cabecera de una lista doblemente enlazada sea una celda
que complete el crculo es decir:
El anterior a la celda de la cabecera es la ltima celda de la lista.

El siguiente a la celda de la cabecera es es la primera de la lista.
El resultado es una implementacin de listas doblemente enlazadas con

cabecera y estructura circular en el sentido de que, dado un nodo, y por medio
de los punteros siguiente, podemos volver hasta el.
cab
Lista circular
53
Pilas
Una pila es una clase especial de lista en la que todas

las inserciones y borrados tienen lugar en un extremo
denominado extremo, cabeza o tope.
Otros nombres de las pilas son:
Listas LIFO (Last Input First Output)

Listas pushdown (empujadas hacia abajo)
El modelo intuitivo de una pila es un conjunto de

objetos apilados de forma que:
Al aadir un objeto se coloca encima del ltimo aadido.

Al quitar un objeto hay que quitar antes los que estn
encima de el.
54
Pilas
Push(A)
Push(D)
Push(H)
Push(E)
Pop
Pila vaca
55
Pilas
struct pila
nombre sig
{
char nombre[20];
struct pila *sig;
};
struct pila * nuevoElemento();

void apilar(struct pila **cabeza, char *nombre);
int vacia(struct pila *cabeza);
void desapilar(struct pila **cabeza, char *nombre);
void verCima(struct pila *cabeza, char *nombre);
56
Pilas.NuevoElemento.Apilar
struct pila * nuevoElemento()
{
return((struct pila *)malloc(sizeof(struct pila)));
}
void apilar(struct pila **cabeza, char *nombre)
{
struct pila *nuevo = NULL;
strcpy(nuevo->nombre, nombre);
nuevo->sig = *cabeza;
*cabeza = nuevo; 2
}
Es una insercin por

delante en una lista!
57
Pilas.Apilar
n1
n2
ni
1
n
nuevo elemento
2
*cabeza
cabeza
58
Pilas.Desapilar
void desapilar(struct pila **cabeza, char *nombre)
{
struct pila *aux1;
aux1 = *cabeza; 1
strcpy(nombre, (*cabeza)->nombre);
*cabeza = aux1->sig; 2
free (aux1); 3
}
Es un borrado por
59
Pilas.Desapilar
n1
3
n2
1
ni
2
*cabeza
aux
cabeza
60
Pilas.VerCima.Vacia
int vacia(struct pila *cabeza)
{
if (cabeza == NULL)
return 1;
return 0;
}
void verCima(struct pila *cabeza, char *nombre)

{
strcpy(nombre, cabeza->nombre);
}
61
Colas
Una cola es otro tipo especial de lista en la cual los elementos

se insertan por el extremo anterior (por el principio) y se
suprimen por el posterior (por el final).
Se conocen tambin como listas FIFO (Firs Input First Output)
Las operaciones para una cola son anlogas a las de las pilas.
Las diferencias sustanciales consisten en que:
Los borrados se hacen al final de la lista y no al principio.

La terminologa tradicional para colas y pilas no es la misma.
inserciones
borrados
62
Colas
struct cola
sig
int n;
struct cola *sig;
};
struct cola *nuevoElemento();

void insertarCola(struct cola **cabeza, int n);
int extraerCola(struct cola **cabeza);
int contiene(struct cola *cabeza);
63
Colas.NuevoElemento.Contiene
struct cola *nuevoElemento()
{
return ((struct cola *)malloc(sizeof(struct
cola)));
}
int contiene(struct cola *cabeza)
{
if (cabeza == NULL)
return 0;
return 1;
}
64
Colas.InsertaCola
void insertarCola(struct cola **cabeza, int n)
{
struct cola *nuevo = NULL;
nuevo->sig = *cabeza;
nuevo->n = n;
*cabeza = nuevo;
}
Es una insercin por

65
Colas.InsertaCola
n1
n2
ni
nuevo elemento
*cabeza
cabeza
La insercin es delante
66
Colas.ExtraerCola
int extraerCola(struct cola **cabeza)
{
struct cola *penultimo = NULL;
int aux;
if (((*cabeza)->sig) == NULL){ /* Hay un
solo elemento */
aux = (*cabeza)->n;
free(*cabeza);
*cabeza = NULL;
return aux;
}
67
Colas.ExtraerCola
else{
penultimo = *cabeza;
while(penultimo->sig->sig != NULL)
penultimo = penultimo->sig;
aux = penultimo->sig->n;
free(penultimo->sig); /* se borra el
ultimo*/
penultimo->sig = NULL;
return aux;
}
Es necesario
}
penltimo para poner
este valor a NULL
68
Colas.ExtraerCola
n1
*cabeza
Caso 1. Hay un solo elemento
cabeza
69
Colas.ExtraerCola
n1
n2
*cabeza
ni
penultimo
cabeza
Caso 2. Hay ms de un
elemento. Se borra el ltimo
70

Listas Pilas Colas

Încărcat de

Informații document

Descriere originală:

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Listas Pilas Colas

Încărcat de

Drepturi de autor:

Formate disponibile

Listas, pilas y colas

Eva Lucrecia Gibaja Galindo

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Operador miembro de estructura. Conecta el

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

En muchos casos, se utilizan punteros a

Los parntesis son necesarios en (*p).x

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Los punteros a estructuras son tan frecuentes que se ha

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Dado un dominio, D, una lista de elementos de

struct lista *sig;

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

struct lista *nuevoElemento();

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Listas. En la funcin main()

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Crea un nuevo elemento struct lista

struct lista *nuevoElemento()

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

pasamos doble puntero (**)

void insertarDelante(struct lista **cabeza, int n)

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

if (*cabeza == NULL) /* la lista est vacia y el

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Caso 2. Lista NO vaca

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Se presupone que la lista ha sido

void insertarOrden(struct lista **cabeza, int n)

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Caso 2. Lista NO vaca

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Caso 2. Lista NO vaca

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Caso 2. Lista NO vaca

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Caso 2. Lista NO vaca

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

En la llamada a la funcin, se pasa la

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

En las llamadas sucesivas, al hacer &((*elemento)->siguiente)

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Caso base: *elemento==NULL

Eva Lucrecia Gibaja Galindo. Departamento de Informtica y Anlisis Numrico

Vuelta atrs de la recursividad

if (cabeza == NULL) / la lista est vacia y el

struct lista sig, ant;

void verCima(struct pila cabeza, char nombre)