CAPITULO 6

PILAS Y COLAS
6.1 PILA
Una Pila es un conjunto ordenado de elementos en el cual se pueden agregar y
eliminar elementos en un extremo, que es llamado el tope de la pila. Es un objeto dinámico
en continuo cambio. Veamos ahora la definición del TAD PILA.

6.1.1 Conceptualización de la estructura

Una pila es una colección de elementos (e1,...en) donde e1 es el tope de la pila.

Las características de esta estructura son:

1. Un solo extremo de pila se designa como tope.
Tope e 2. Solo puede agregarse nuevos elementos en el tope.
d 3. Cuando se agrega un elemento, el nuevo tope es este
c elemento (sube el tope).
b 4. Solo puede quitarse el primer elemento (tope) de la pila,
a en este caso, en el tope baja.
5. Se denomina a esta estructura LIFO, por su
comportamiento (last in first out), ver figura 6.1.
Figura 6.1. Estructura del LIFO
6. En cada momento solo es visible y accesible el tope de
la pila, por lo que el resto de ella (tanto elementos como
su numero) no importa, en dicho momento.

6.1.2 Operaciones primitivas

El TAD PILA contiene las primitivas que permiten hacer los dos cambios
fundamentales en la estructura, es decir, agregar y/o eliminar elementos del tope, Así como
también el constructor y el destructor del TAD. Veamos las primitivas del TAD PILA.

6.1.2.1 El constructor:

P_Crear: void  PILA

/* PRE: ninguna
POST: Devuelve una pila vacía
*/
El prototipo de esta operación es
PILA P_Crear();

6.1.2.2 El Destructor:

P_Destruir: PILA  void

/* PRE: dada una pila creada
POST: Libera el espacio de memoria ocupado por la pila
*/

1
 El prototipo de esta operación es
void P_Destruir (PILA P);

6.1.2.3 Los modificadores:

P_Pop: PILA  PILA

/* PRE: dada una una pila creada no vacía
POST: remueve el tope de la pila
*/
El prototipo de esta operación es
PILA P_Pop(PILA P);

P_Push: PILA x ELEM  PILA

/* PRE: dada una una pila creada y un elemento
POST: coloca el elemento como el nuevo tope de la pila
*/
El prototipo de esta operación es
PILA P_Push(PILA P, ELEM e);

6.1.2.4 Los observadores:

P_Top: PILA  ELEM

/* PRE: dada una una pila creada y no vacía
POST: devuelve el elemento del tope
*/
El prototipo de esta operación es
ELEM P_Top(PILA P);

P_Empty: PILA  bool

/* PRE: dada una una pila creada
POST: dice si la pila está vacía
*/
El prototipo de esta operación es
bool P_Empty(PILA P);

6.1.3 Implementación de la pila usando lista enlazada

La pila es una estructura dinámica que crece y decrece constantemente. Aunque
puede ser implementada en algunos casos de manera estática a través de un arreglo, su
comportamiento dinámico nos obliga a considerar implementarla como una estructura
dinámica de memoria. Es decir, usando listas enlazadas. En la figura 6.2. se presenta un
diagrama de lista enlazada equivamente a una pila.

Note que cada elemento de la pila aparece en un nodo diferente. El tope de la pila se
coloca en el inicio de la lista enlazada. Esto permite que las dos operaciones de modificación
de la estructura de la pila sean realizadas por el comienzo de la lista enlazada. Esto hará que
dichas operaciones sean muy sencillas de implementar.

2
 Pila
c
Tope c b a
b
a

Figura 6.2. Esquema de lista enlazada

Veamos como quedaría la estructura de datos:

typedef struct s_nodo

{
ELEM info;
struct s_nodo *sig;
} NODO;

typedef NODO *PILA;

Note que la estructura principal es el nodo y que la pila simplemente es un apuntador

a nodo.

6.1.4 Implementación de las Operaciones Primitivas

En el caso del constructor no hay que crear ningún encabezado por lo que el
constructor realmente no hace nada.

PILA P_Crear ()
/* PRE: ninguna
POST: Devuelve una pila vacía.
*/
{
return(NULL);
}

void P_Destruir (PILA P)

/* PRE: dada una pila creada
POST: Libera el espacio de memoria ocupado por la pila
*/
{
while !(P_Empty(P))
P=P_Pop(P);
}

PILA P_Pop(PILA P)

3
 /* PRE: dada una una pila creada no vacía
POST: remueve el tope de la pila
*/
{
NODO *aux;

aux=P;
P=P–>sig;
free(aux);
return(P);
}

PILA P_Push(PILA P,ELEM e)

/* PRE: dada una una pila creada y un elemento
POST: coloca el elemento como el nuevo tope de la pila
*/
{
NODO *aux;

if ((aux=(NODO *)malloc(sizeof(NODO))) != NULL)

{
aux->info = e;
aux->sig = P;
P = aux;
}
return(P);
}

ELEM P_Top(PILA P)
/* PRE: dada una una pila creada y no vacía
POST: devuelve el elemento del tope
*/
{
return (P->info);
}

bool P_Empty(PILA P)
/* PRE: dada una una pila creada
POST: dice si la pila está vacía
*/
{
return ((P == NULL));
}

6.2 COLA
Una Cola es un conjunto ordenado de elementos donde siempre se eliminan
elementos de un extremo (parte delantera) y se insertan elementos en el otro extremo (parte
posterior). En la figura 6.3 se puede observar dicho comportamiento para una cola.

4
6.2.1 Conceptualización de la estructura
Una cola es una colección de elementos (e 1,...en) donde e1 es el primero de la cola y
en es el último de la cola.

b c
a b c

Se eliminó a b c d e

Se agregó d y e
Figura 6.3. Simulación de cola

El comportamiento de una cola se conoce como FIFO (First in first out), es decir, el
primer elemento insertado en una cola es el primero en salir de ella. Existen ejemplos
abundantes en el mundo real de este comportamiento: paradas de autobús, fila del banco,
automóviles en un peaje, entre otros.

6.2.2 Operaciones primitivas

El TAD COLA contiene las primitivas que permiten hacer los dos cambios
fundamentales en la estructura, es decir, agregar elementos al final de la cola o eliminar
elementos del comienzo de la cola. También aparecen el constructor y el destructor del TAD.
Veamos las primitivas del TAD COLA.

6.2.2.1 El constructor:

C_Crear: void  COLA

/* PRE: ninguna
POST: Devuelve una cola vacía
*/
El prototipo de esta operación es
COLA C_Crear();

6.2.2.2 El Destructor:

C_Destruir: COLA  void

/* PRE: dada una cola creada
POST: Libera el espacio de memoria ocupado por la cola
*/
El prototipo de esta operación es
void C_Destruir (COLA C);

6.2.2.3 Los modificadores:

C_Remove: COLA  COLA

5
 /* PRE: dada una una cola creada no vacía
POST: remueve el primer elemento de la cola
*/
El prototipo de esta operación es
COLA C_Remove(COLA C);

C_Insert: COLA x ELEM  COLA

/* PRE: dada una una cola creada y un elemento
POST: coloca el elemento al final de la cola
*/
El prototipo de esta operación es
COLA C_Insert(COLA C, ELEM e);

6.2.2.4 Los observadores:

C_First: COLA  ELEM

/* PRE: dada una cola creada y no vacía
POST: devuelve el primer elemento a ser atendido
*/
El prototipo de esta operación es
ELEM C_First(COLA C);
C_Empty: COLA  bool
/* PRE: dada una cola creada
POST: dice si la cola está vacía
*/
El prototipo de esta operación es
bool C_Empty(COLA C);

6.2.3 Implementación de la cola usando listas enlazadas

Una cola puede ser implementada utilizando listas enlazadas como se observa en la
figura 6.4. En dicha lista se puede observar una estructura de encabezado donde se
almacena la dirección del primer elemento de la cola (siguiente elemento a ser atendido) y el
último de la cola (donde debe insertarse un nuevo elemento).

c b a

c b a

Figura 6.4. Implementación de la cola con listas enlazadas

Veamos como quedaría la estructura de datos:

typedef struct s_nodo

{
ELEM info;
6
 struct s_nodo *sig;
} NODO;

typedef struct s_enc

{
NODO *Primero;
NODO *Ultimo;
} ENCABEZADO;

typedef ENCABEZADO *COLA;

Note que cada elemento tiene asociado un nodo y que la estructura encabezado
almacena las direcciones del primero y último elemento. La cola es un es un apuntador a
encabezado.

6.2.4 Implementación de las operaciones primitivas

COLA C_Crear ()
/* PRE: ninguna
POST: Devuelve una cola vacía.
*/
{
COLA aux;
if ((aux = (COLA) malloc (sizeof (ENCABEZADO))) != NULL)
{
aux->Primero = NULL;
aux->Ultimo = NULL;
}
return(aux);
}

void C_Destruir (COLA C)

/* PRE: dada una cola creada
POST: Libera el espacio de memoria ocupado por la cola
*/
{
while !(C_Empty(C))
C=C_Remove(C);
free(C);
}

COLA C_Remove(COLA C)
/* PRE: dada una una cola creada no vacía
POST: remueve el primer elemento de la cola
*/
{

7
 NODO *aux;

aux = C->Primero;
C->Primero = C->Primero–>sig;
free(aux);
return(C);
}

COLA P_Insert(COLA C,ELEM e)

/* PRE: dada una cola creada y un elemento
POST: coloca el elemento como siguiente al último
*/
{
NODO *aux;

if ((aux=(NODO *)malloc(sizeof(NODO))) != NULL)

{
aux->info = e;
aux->sig = NULL;
C->Ultimo->sig = aux;
C->Ultimo = aux;
}
return(C);
}

ELEM C_First(COLA C)
/* PRE: dada una cola creada y no vacía
POST: devuelve el elemento al comienzo de la cola
*/
{
return (C->Primero->info);
}

bool C_Empty(COLA C)
/* PRE: dada una cola creada
POST: dice si la cola está vacía
*/
{
return ((C->Primero == NULL));
}