Pilas y Colas

Profesor: José Andrés Vázquez Flores

2
Introducción

 Una estructura de datos es un conjunto de

variables, quizá de tipos distintos, que se relacionan
entre sí y que se pueden operar como un todo.
 Son fundamentales para el manejo de información y
el desarrollo de sistemas.
 Varían en la forma como permiten el acceso a los
miembros del conjunto y algunas imponen
restricciones.
 3
Pilas

 Una pila es una lista de elementos en la cual los

elementos se insertan o se eliminan sólo por uno de los
extremos.

 Una pila (stack) es una estructura tipo LIFO (Last Input

First Out), así que el primero en entrar es el último en
salir.
 4
Pilas
 Por ejemplo, en una cafetería de autoservicio donde se
tienen charolas, las cuales se encuentran apiladas.

Tope
Tope

Fondo
 5
Representación
 Las pilas no están definidas como tales en los
lenguajes de programación, se representan mediante el
uso de Arreglos o Listas ligadas.

Decrece
Crece
4
3
2
1
0
6
Representación

 Para el manejo de la pila se requiere de un apuntador

(Tope) el cual apunta una posición después del último
elemento almacenado en la pila.

 Este apuntador se mueve sobre el arreglo, hacia arriba o

hacia abajo, según la pila crezca o decrezca.

 Debido a que se maneja memoria estática, el Tope se

mueve sobre el arreglo.
 7
Manejo
 El Tope de la pila, siempre apunta a un espacio vacío.

4
3
2
1
0 Tope
 8
Operaciones
 En una pila se pueden hacer dos operaciones:
 Insertar: meter a la pila (PUSH)
 Eliminar: sacar de la pila (POP)

Pop
Push 4 Tope
3 3 Tope
2 9 Tope
1 1 Tope
0 5 Tope
9
Manejo

 COMPORTAMIENTO DEL TOPE

 El estado inicial del Tope es 0 (cuando la pila esta
vacía).
 Este se incrementa cuando se inserta información en
la pila y se decrementa cuando se elimina
información de la misma.
 Si se llega al valor MAX, entonces la pila esta llena.
 Si se llega al valor 0, entonces la pila esta vacía.
Manejo

 Push:
 Introducir el dato.
 Incrementar el Tope.
 Que pasa si la pila esta llena y se intenta introducir algún
dato?
 Pop:
 Decrementar el Tope.
 Sacar el dato.
 Que pasa si la pila esta vacía y se intenta sacar algún
dato? 10
11
Operaciones

 COMPORTAMIENTO DE LA PILA
 Constructor: debe crear una pila vacía de tamaño n;
Pila (int n);
 Función para checar si la pila esta vacía:
boolean EsPilaVacia( );
 Función para checar si la pila esta llena:
boolean EsPilaLlena( );
 Función para insertar un elemento a la pila:
Push(int dato);
 Función para sacar un elemento de la pila:
int Pop( );
 Función para imprimir el estado actual de la pila:
VerPila( );
12
Colas

 Una cola es una lista de elementos en la cual los

elementos se insertan por un extremo y se
eliminan por otro.

 Una cola (queue) es una estructura tipo FIFO

(First In First Out), así que el primero en entrar
es el primero en salir. Aquí los elementos salen
en el mismo orden en que entraron.
 13
Colas
 Diariamente se tienen colas, como por ejemplo en
supermercados, teatros, bancos, etc.

Atrás Frente
Frente

Frente

Atrás
Atrás
 14
Representación
 Las colas no están definidas como tales en los
lenguajes de programación, éstas se representan
mediante el uso de Arreglos o Listas ligadas.

1 2 3 4 5 6 7 8 9 10 11

3 2 5

Frente Atrás
15
Representación 1
 Recorriendo información del arreglo
 Los elementos se colocan a partir de la primera
posición hasta la posición máxima.

1 2 3 4 5 6 7 8 9 10 11

4 8 5 2 23 91 9 18 3 11 7

Frente Atrás
 Representación 1
16

Recorriendo información del arreglo

 Al momento de sacar un elemento, los restantes se recorren una

posición hacia adelante en el arreglo, de tal manera que el frente de la
cola siempre está dado por la primera posición del arreglo. 

 Así únicamente se requiere un apuntador que indique donde se

encuentra el final de la cola

1 2 3 4 5 6 7 8 9 10 11

8 5 2 23 91 9 18 3 11 7

Frente Atrás
17
Representación 1

 Recorriendo información del arreglo

 Ventaja: Representación sencilla que facilita la implantación

de las operaciones.

 Desventaja: El corrimiento de los elementos cada vez que se

saca un elemento de la cola, lo que repercute en la eficiencia,
cuando la cola guarda una cantidad significativa de datos.
18
Representación 2

 Para manejarla se requiere de dos apuntadores

(subíndices):

 Uno que apunte o se refiera al último elemento

almacenado en la cola. Denominado ATRÁS. 

 Otro que apunte o se refiera al primer elemento

almacenado en la cola. Denominado FRENTE.
 19
Operaciones
 Se tiene que max es igual a la última posición del
arreglo y mín es igual a la primera posición del arreglo,
el estado inicial del Frente y Atrás es igual al mín.

1 2 3 4 5 6 7 8 9 10 11

Frente=Atrás mín max

20
Representación 2
Para manejarla se requiere de dos apuntadores (subíndices):

 En esta representación los elementos no se recorren cada vez que se

saca un elemento de la cola., sino que el apuntador al Frente se
mueve hacia adelante del arreglo, cada vez que se saca un dato.

 Ventaja: Esta representación elimina el problema de los corrimientos.

 Desventaja: Se podría llegar al caso extremo en que se desperdicien

localidades de memoria, pues cuando el indicador del final de la cola
este en la posición máxima del arreglo, ya no podrán agregarse
elementos a la cola, aunque se tengan lugares disponibles.
 21
Operaciones
 En una cola se pueden llevar a cabo dos operaciones:
 Insertar: meter dato en la cola.
 Eliminar: sacar dato de la cola.

1 2 3 4 5 6 7 8 9 10 11

Insertar 4 8 5
Eliminar

Frente Atrás
22
Operaciones

 COMPORTAMIENTO DE LA COLA
 Constructor: debe crear una cola vacía de tamaño n;
Cola (int n);
 Función para checar si la cola esta vacía:
boolean EsColaVacia( );
 Función para checar si la cola esta llena:
boolean EsColaLlena( );
 Función para insertar un elemento a la cola:
Inserta(int dato);
 Función para sacar un elemento de la cola:
int Sacar( );
 Función para imprimir el estado actual de la cola:
VerCola( );
 23
Cola Circular
 Suponga que se tiene la siguiente cola:

1 2 3 4 5 6 7 8 9 10 11

4 8 5 2 23 91 9 18 3 11 7

Frente Atrás

 Donde se tiene que la cola esta llena, si se realizan varias

eliminaciones de datos dentro de la cola, quedaría:
 24
Cola Circular

1 2 3 4 5 6 7 8 9 10 11

2 23 91 9 18 3 11 7

Frente Atrás

 Nótese que a pesar de que se tiene espacio dentro de la

cola, al intentar insertar un nuevo elemento, se marca
el error de “Cola Llena”.
 25
Cola Circular
 En este caso, lo que se tiene es que al llegar atrás al
final de la cola, se reinicie el mismo.

1 2 3 4 5 6 7 8 9 10 11

4 8 5 2 23 91 9 18 3 11 7

Frente Atrás
 26
Representación
 Por lo que se puede representar:
1 Frente
8
Atrás

7 2

6 3

5 4
 27
Operaciones
 Se tienen las mismas operaciones que en una cola
lineal. Frente
8 1
Atrás
5
Frente

7 2
7 Atrás

Insertar
Eliminar 9 Frente
6 3
Atrás

5 4 Atrás
28
Operaciones

 Ahora, para realizar las operaciones de inserción y

eliminación, es necesario saber cual fue la última
operación, debido a que si: Atrás = Frente, entonces la
cola o bien puede estar vacía o bien puede estar llena.
 Con la cual si:
 Atrás = Frente, y la última operación fue eliminar
entonces la cola esta vacía.
 Atrás = Frente, y la última operación fue insertar
entonces la cola esta llena.
 Operaciones
29

 Es importante observar que esta representación no tiene las

desventajas de las anteriores, pues no se requiere recorrer
datos ni se desperdicia espacio en el arreglo al considerar
todas las localidades disponibles en él.

 Nota: Puesto que un arreglo en la memoria no es físicamente

circular, al implementar las funciones se tendrá que controlar
esta característica.

 Es importante considerar que los dos apuntadores (Frente y

Atrás) siempre se incrementaran dentro del arreglo.
• Para agregar un dato se incrementa el índice Atrás.
• Para sacar un dato se incrementa el índice Frente.
 30
Operaciones

1 Frente
8
Atrás
5
Frente

7 2
7 Atrás

Insertar
Eliminar 9 Frente
6 3
Atrás

5 4 Atrás
 Operaciones
31

 En la acción de incrementar se tendrá que considerar la

circularidad del arreglo y se puede deducir que el
incremento se validará con una estructura de decisión
que verifique si se esta en la ultima posición del arreglo
para mandar a la posición inicial, o si no, incrementar
normalmente.
 Operaciones
32

 Son las mismas operaciones que se requieren para la cola

lineal, sin embargo, hay un truco de programación que
permite hacer más eficiente la acción de “incrementar
circularmente”,
debe por
crearmedio del vacía
una cola operador
de que permite
obtener el residuo
tamañoden;una división entera “%” (modulo).

 Constructor: debe crear una cola vacía de tamaño n;

Cola( )
{Frente = Atrás = -1;}
 Operaciones
33

 COMPORTAMIENTO DE LA COLA
 Constructor: debe crear una cola vacía de tamaño n;
ColaC (int n);
 Función para checar si la cola esta vacía:
boolean EsColaCVacia( )
{ return (Frente == -1); }
 Función para checar si la cola esta llena:
boolean EsColaCLlena( )
{ return ((Atrás +1) % n ==Frente); }
 Función para insertar un elemento a la cola:
InsertaC(int dato)
{ Atrás = (Atrás + 1) % n ;
arre[Atras] = dato ;
if ( Frente == -1) Frente = 0;
}
34
Operaciones

 COMPORTAMIENTO DE LA COLA
 Función para sacar un elemento de la cola:
int SacarC( )
{ dato = arreglo[Frente];
if (Frente == Atrás)
Frente = Atrás = -1;
else
Frente = (Frente + 1) % n;
return dato;
}
 Función para imprimir el estado actual de la cola:
VerColaC( ); ………… ?