CAPITULO 3 DOCUMENTO - COLAS Actualizado

UNIVERSIDAD MAYOR DE SAN ANDRÉS ESTRUCTURA DE DATOS (INF-131)
CARRERA INFORMATICA – CURSO DE TEMPORADA M. Sc. ZARA YUJRA CAMA
CAPÍTULO III
COLAS
1. INTRODUCCIÓN
La estructura de datos "cola" también llamada "Queue", es un tipo de datos abstracto
"TDA". Una cola TDA permite a una lista de cosas ser removidos en el orden en que
fueron almacenados.
Una cola es una lista de elementos en la que éstos se introducen por un extremo y se
eliminan por otro. Los elementos se eliminan en el mismo orden en el que se insertaron.
Por lo tanto, el primer elemento que entra a la cola será el primero en salir. Debido a esta
característica, las colas también reciben el nombre de estructuras FIFO (First In, First
Out: Primero en entrar, primero en salir).
Las colas en computación son muy similares a las colas de la vida real.
Ejemplos.-
a) Cola de clientes esperando pagar en una caja de supermercado
b) Cola de clientes esperando ser atendidos por algún cajero en un banco
c) Cola de procesos esperando ser ejecutados por una CPU
Al igual que la pila, la cola es una estructura de datos dinámica, pero puede ser
representado en forma estática (arreglos).
CARACTERÍSTICAS
Todos los elementos de la cola son del mismo tipo.
- Existe un orden de elementos ya que es una estructura lineal, pero los elementos no
están ordenados por su valor sino por orden de introducción en la cola.
- Existen dos extremos en la estructura lineal cola, el frente y el final de la cola.
- Sólo se puede acceder y eliminar al dato que está en el frente de la cola.
1
- Sólo se puede añadir información al final de la cola.

REPRESENTACIÓN DE LAS COLAS
Al igual que las pilas, las colas no existen como estructuras de datos estándares en los
lenguajes de programación. Las colas pueden representarse mediante el uso de:
- Arreglos
- Listas Enlazadas.
Como en el caso de las pilas, utilizaremos arreglos. Debe definirse el tamaño máximo
para la cola y dos variables auxiliares. Una de ellas para que guarde la posición del
primer elemento de la cola (FRENTE) y otra para que guarde la posición del último
elemento de la cola (FINAL). En el ejemplo siguiente se muestra una representación de
una cola en la cual se ha insertado cuatro elementos: 11, 22, 33 y 44, en ese orden.
El elemento 11 está en el frente ya que fue el primero que entró en la cola. Mientras que
el elemento 44, que fue el último en entrar, está en el FINAL de la cola.
Ejemplo.- Sea una cola Q de números enteros: MAX=6
ESTRUCTURA DE UNA COLA IMPLEMENTADO MEDIANTE ARREGLOS
Donde los elementos son:

V[MAX]: Es el vector que re presenta a la cola y es de tamaño MAX.
2
Frente: Es la variable que indica la posición del elemento del frente de la cola.
Fin: Es la variable que indica la posición del último elemento de la cola.
Y las operaciones, como se describen a continuación.
OPERACIONES CON COLAS
Análogamente a las pilas, es necesario definir el conjunto de operaciones básicas para
especificar adecuadamente una estructura cola. Estas operaciones serían:
- Insertar(e): Inserta un elemento al final de la cola.
- Eliminar(): Elimina un elemento del frente de la cola.
- Imprimir(): Imprime los elementos desde el frente hasta el final de la cola.
- Vacia(): Verifica si la cola esta vacía, retorna un valor booleano.
- Llena(): Verifica si la cola está llena, retorna un valor booleano.
- FRENTE(): Retorna el valor del frente.
- FINAL(): Retorna el valor del fin.
Insertar un elemento en la cola:

Debido a la implementación estática de la estructura cola es necesario determinar si
existen huecos libres donde poder insertar antes de hacerlo. Esto puede hacerse de
varias formas.
Eliminar un elemento en la cola:
Como vera la eliminación no borra nada 'físicamente', sólo se encarga de actualizar el
puntero 'frente' en una posición y devolver el valor x como mucho, aunque esto último
no sea estrictamente necesario. Aunque esa posición aun contenga datos será
considerada como vacía a efectos del otro puntero 'fin'.
2. COLAS LINEALES
A continuación, implementamos el código correspondiente al programa de manejo de
colas lineales en java:
3
Programa 15 en Java
//Cola lineal de números enteros y sus operaciones
package estructurasEstaticas;
import java.util.Scanner;
public class Cola
{
final int MAX = 20;
private int v[] = new int [MAX];
private int fin;
private int frente;
Scanner sc=new Scanner(System.in);
public Cola ()
{
frente = 0;
fin = 0;
System.out.println ("COLA CREADA....");
}
boolean vacia ()
{
if (frente == 0)
return (true);
else
return (false);
}
boolean llena ()
{
if (fin == MAX)
return (true);
else
return (false);
}
void insertar (int elem)
{
if (!llena ())
{
fin++;
v [fin] = elem;
if (frente == 0)
frente = 1;
}
else
{
System.out.println ("COLA LINEAL LLENA....");
System.exit (0);
}
}
4
int eliminar ()
{
int e = 0;
if (!vacia ())
{
e = v [frente];
if (frente == fin)
{
frente = 0;
fin = 0;
}
else
frente = frente + 1;
}
else
{
System.out.println ("LA COLA ESTA VACIA...");
System.exit (0);
}
return (e);
}
void imprimir ()
{
System.out.println ("IMPRIMIENDO LA COLA......");
for (int i = frente ; i <= fin ; i++)
System.out.println (v [i]);
}
int FINAL ()
{
return (fin);
}
int FRENTE ()
{
return (frente);
}
void llenarCola ()
{
int N;
int e;
System.out.println ("Cuantos elementos desea insertar a la cola ??");
N=sc.nextInt();
for (int i = 1 ; i <= N ; i++)
{
System.out.print ("Introduzca un elemento....");
e = sc.nextInt();
insertar (e);
}
}
} //Fin del programa
5
Ejemplo.- Aplicación de Colas Lineales

Eliminar los divisores de x de una cola.
Programa 15 en Java
public class EjerColaLineal
{
static Cola Q = new Cola ();
static Scanner sc=new Scanner(System.in);
static void EliminarDivisoresX (Cola A)
{
int x;
int e;
int m = A.FINAL ();
System.out.print ("/////" + m);
System.out.println ("***** Eliminando Divisores de X de la Cola Lineal****** ");
System.out.print ("Ingrese el valor de x....");
x = sc.nextInt();
while (A.FRENTE () != m + 1)
{
e = A.eliminar ();
if (x % e != 0)
A.insertar (e);
}
A.imprimir ();
}
public static void main (String args[])
{
Q.llenarCola ();
Q.imprimir ();
EliminarDivisoresX (Q);
}
}
Salida del programa
6
3. COLAS CIRCULARES
Para hacer un uso más eficiente de la memoria disponible se trata a la cola como una
estructura circular. Es decir, el elemento anterior al primero es el último. En la siguiente
figura se muestra la representación de una cola circular.
Ejemplo.-
Para el siguiente ejemplo (a), en el cual ya no es posible adicionar elementos siguiendo

la anterior estructura, se propone la alternativa (b):
(a)
(b)
El diseño de la estructura de datos de una cola circular no varia en relación a una
estructura de datos lineal, por tanto a continuación mostramos las operaciones que
sufren cambios en este tipo de colas.
7
OPERACIONES CON COLAS CIRCUALES

Las operaciones básicas con colas circulares son: insertar, eliminar y mostrar una cola
circular. A continuación mostramos la implementación en Java de una Cola Circular para
elementos de tipo entero.
Programa 16 en Java
public class ColaCircular
{
final int MAX = 20;
private int v[] = new int [MAX];
private int fin;
private int frente;
Public ColaCircular ()
{
frente = 0;
fin = 0;
}
boolean vacia ()
{
if (frente == 0)
return (true);
else
return (false);
}
boolean llena ()
{
if ((fin == MAX && frente == 1) || (fin + 1 == frente))
return (true);
else
return (false);
}
void insertar (int elem)

{
if (!llena ())
{
if (fin == MAX)
fin = 1;
else
if (frente == 0)
{
frente = 1;
fin = 1;
8
}
else
fin++;
v [fin] = elem;
}
else
{
System.out.println ("COLA CIRCULAR LLENA....");
System.exit (1);
}
}
int eliminar ()
{
int e = 0;
if (!vacia ())
{
e = v [frente];
if (frente == fin)
{
frente = 0;
fin = 0;
}
else
if (frente == MAX)
frente = 1;
else
frente = frente + 1;
}
else
{
System.out.println ("LA COLA ESTA VACIA...");
System.exit (0);
}
return (e);
}
void imprimir ()
{
System.out.println ("IMPRIMIENDO LA COLA......");
for (int i = frente ; i <= fin ; i++)
System.out.println (v [i]);
}
int FINAL ()
{
return (fin);
}
int FRENTE ()
{
9
return (frente);
}
void llenarCola ()
{
int N;
int e;
System.out.println ("Cuantos elementos desea insertar a la cola ??");
N=sc.nextInt();
for (int i = 1 ; i <= N ; i++)
{
System.out.print ("Introduzca un elemento....");
e = sc.nextInt();
insertar (e);
}
}
}
Ejemplo.- Aplicación de Cola Circuares

Eliminar los elementos negativos de la cola circular
Programa 16 en Java
// Eliminar los negativos de la Cola Circular
public class EjerColaCircular
{
static ColaCircular Q = new ColaCircular ();
static void EliminarNegativos (ColaCircular A)
{
int e;
int m = A.FINAL ();
System.out.println ("***** Eliminando elementos Negativos de la Cola Circular ****** ");
while (A.FRENTE () != m + 1)
{
e = A.eliminar ();
if (e>0)
A.insertar (e);
}
A.imprimir ();
}
10
public static void main (String args[])

{
Q.llenarCola ();
Q.imprimir ();
EliminarNegativos(Q);
}
}
Salida del programa
4. COLAS DE PRIORIDADES
Una cola de prioridad es una estructura característica, donde se pude retirar e insertar un ítem
teniendo en cuenta la clave más grande o más chica (según la implementación) definida por el
programador. Si los ítems tienen claves iguales, entonces la regla usual utilizada es que el primer
ítem insertado es el que se retirará primero.
Algunas aplicaciones de éste tipo de estructura son: la representación simulada de eventos
dependientes del tiempo, como por ejemplo el funcionamiento de un aeropuerto, controlando
partidas y aterrizajes de aviones. Otro ejemplo puede verse en los sistemas informáticos, el CPU
asigna prioridades a las distintas tareas que debe ejecutar y las inserta en su cola, para de esta
manera realizarlas en el orden correcto (multitareas).
Podemos representar una cola de prioridad como una lista contigua ordenada, en la cual retirar
un ítem es una operación inmediata, pero la inserción tomaría un tiempo proporcional al número
de elementos que se encuentren en la cola, hay que tener en cuenta que dicha operación se
debe realizar en forma tal que la cola quede ordenada. Otra forma de representación es a través
11
de una lista desordenada, en la cual el proceso de inserción es inmediato, pero el de extracción

es muy lento, ya que debo recorrer toda la cola para encontrar el ítem que debo retirar.
5. APLICACIÓN DE PILAS Y COLA

Hasta ahora se ha tratado solamente con la representación en memoria y manipulación
de una única pila o cola. Se han visto dos representaciones secuenciales eficientes para
dichas estructuras. Sin embargo, en ocasiones, es preciso representar varias estructuras
utilizando el mismo espacio de memoria.
Supongamos que seguimos transformando las estructuras de datos en representaciones
Secuenciales, tipo array. Si sólo hay que representar dos pilas sobre un mismo array
A[1..n], la solución puede resultar simple. Se puede hacer crecer las dos pilas partiendo
desde los extremos opuestos del array, de forma que A[1] será el elemento situado en el
fondo de la primera pila y A[n] el correspondiente para la segunda pila. Entonces, la pila
1 crecerá incrementando los índices hacia A[n] y la pila 2 lo hará decrementando los
índices hacia A[1]. De esta manera, es posible utilizar eficientemente todo el espacio
disponible.
Si se plantea representar más de dos pilas sobre ese mismo array A, no es posible seguir
la misma estrategia, ya que un array unidimensional sólo tiene dos puntos fijos, A[1] y
A[n], y cada pila requiere un punto fijo para representar el elemento más profundo.
Cuando se requiere representar secuencialmente más de dos pilas, por ejemplo m pilas,
es necesario dividir en m segmentos la memoria disponible, A[1..n], y asignar a cada uno
de los segmentos a una pila. La división inicial de A[1..n] en segmentos se puede hacer
en base al tamaño esperado de cada una de las estructuras. Si no es posible conocer
esa información, el array A se puede dividir en segmentos de igual tamaño. Para cada
pila i, se utilizará un índice f(i) para representar el fondo de la pila i y un índice c(i) para
indicar dónde está su tope. En general, se hace que f(i) esté una posición por debajo del
fondo real de la pila, de forma que se cumpla la condición f(i)=c(i) si y solamente si la pila
i está vacía.
12
Ejemplo.- Aplicación de Colas Dinámicas

Programa 17 en Java
package estructurasDinamicas;
public class Cola
{
class Nodo
{
int Info;
Nodo DirSgte;
}
Nodo Frente, Fin;
Cola()
{
Frente=null;
Fin=null;
}
public boolean esVacia()

{
if (Frente==null)
return true;
else
return false;
}
public void Insertar(int elem)

{
Nodo Q;
Q = new Nodo ();
Q.Info = elem;
Q.DirSgte = null;
if (esVacia ())
{
Frente = Q;
Fin = Q;
}
else
{
Fin.DirSgte = Q;
Fin = Q;
}
}
13
public int Eliminar()

{
int elem;
Nodo Q;
if (!esVacia ())
{
elem = Frente.Info;
if (Frente == Fin)
{
Frente = null;
Fin = null;
}
else
{
Q=Frente;
Frente = Frente.DirSgte;
Q=null;
}
return elem;
}
else
return Integer.MAX_VALUE;
}
public int Contar()

{
int c=0;
Nodo Q=Frente;
while (Q!=null)
{
c++;
Q=Q.DirSgte;
}
return c;
}
public void Imprimir()
{
Nodo Q=Frente;
System.out.println("Listado de todos los elementos de la cola.");
while (Q!=null)
{
System.out.print(Q.Info+", ");
Q=Q.DirSgte;
}
System.out.println();
}
14
public void LlenarCola()

{
int N;
int elem;
System.out.println("Cuantos elementos desea insertar a la cola...");
N=sc.nextInt();
for(int i=1; i<=N; i++)
{
System.out.print("Ingrese un elemento...");
elem=sc.nextInt();
Insertar(elem);
}
}
} // Fin del programa
Ejemplo.- Aplicación de Colas dinámicas Lineales

Escribir un programa utilizando colas lineales dinámicas, para:
- Intercambiar el elemento del frente con el elemento del final de la cola.
- Eliminar el primer negativo.
Programa 17 en Java
estructurasDinamicas;
// COLAS LINEALES DINAMICAS
public class EjerColasDinamicas
{
static void IntercambiarFrenteFin(Cola A)
{
int x,y,m,i;
System.out.println("Intercambiando el frente con el final");
x=A.Eliminar();
m=A.Contar();
i=1;
while(i<m)
{
y=A.Eliminar();
A.Insertar(y);
i++;
}
A.Insertar(x);
}
static void EliminarPrimerNeg(Cola Q)
{
int x,m,i;
boolean sw=true;
m=Q.Contar();
i=1;
System.out.println("ELIMINANDO EL PRIMER NEGATIVO");
15
while(i<=m && sw)

{
x=Q.Eliminar();
if(x>=0)
Q.Insertar(x);
else
sw=false;
i++;
}
while (i<=m)
{
Q.Insertar(Q.Eliminar());
i++;
}
}
public static void main(String[] args)
{
Cola Q=new Cola();
Q.LlenarCola();
Q.Imprimir();
IntercambiarFrenteFin(Q);
Q.Imprimir();
EliminarPrimerNeg(Q);
Q.Imprimir();
}
}
Salida del programa
16
EJERCICIOS PROPUESTOS DE COLAS – PRÁCTICA # 3

Realizar los siguientes ejercicios aplicando Colas con Arreglos unidimensionales.
1) Realizar un programa para eliminar los elementos positivos de una cola.
2) Eliminar los elementos impares de la cola lineal.
3) Hallar el elemento mínimo y máximo de una cola lineal, luego intercambiar los mismos.
4) Insertar dos elementos después del elemento X de la cola.
5) Sumar dos colas A y B en una Cola C.
6) Intercambiar el elemento del frente de la cola por el elemento del final de la cola.
7) Intercambiar cada elemento con su adyacente.
8) Llevar los elementos primos al frente de la cola.
9) Escriba un programa que invierta los elementos de una cola.
10) Utilizando colas circulares resuelva el problema de Josefo.
17

CAPITULO 3 DOCUMENTO - COLAS Actualizado

Cargado por

Copyright:

Formatos disponibles

CAPITULO 3 DOCUMENTO - COLAS Actualizado

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

CAPITULO 3 DOCUMENTO - COLAS Actualizado

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD MAYOR DE SAN ANDRÉS ESTRUCTURA DE DATOS (INF-131)

CARRERA INFORMATICA – CURSO DE TEMPORADA M. Sc. ZARA YUJRA CAMA

- Sólo se puede añadir información al final de la cola.

ESTRUCTURA DE UNA COLA IMPLEMENTADO MEDIANTE ARREGLOS

Donde los elementos son:

Insertar un elemento en la cola:

Ejemplo.- Aplicación de Colas Lineales

Salida del programa

Para el siguiente ejemplo (a), en el cual ya no es posible adicionar elementos siguiendo

OPERACIONES CON COLAS CIRCUALES

void insertar (int elem)

Ejemplo.- Aplicación de Cola Circuares

public static void main (String args[])

Salida del programa

de una lista desordenada, en la cual el proceso de inserción es inmediato, pero el de extracción

5. APLICACIÓN DE PILAS Y COLA

Ejemplo.- Aplicación de Colas Dinámicas

public boolean esVacia()

public void Insertar(int elem)

public int Eliminar()

public int Contar()

public void LlenarCola()

Ejemplo.- Aplicación de Colas dinámicas Lineales

while(i<=m && sw)

Salida del programa

EJERCICIOS PROPUESTOS DE COLAS – PRÁCTICA # 3

1) Realizar un programa para eliminar los elementos positivos de una cola.

2) Eliminar los elementos impares de la cola lineal.

4) Insertar dos elementos después del elemento X de la cola.

5) Sumar dos colas A y B en una Cola C.

7) Intercambiar cada elemento con su adyacente.

8) Llevar los elementos primos al frente de la cola.

9) Escriba un programa que invierta los elementos de una cola.

10) Utilizando colas circulares resuelva el problema de Josefo.

También podría gustarte