Leccion 3.2 Colas

Leccion 3.
2 COLAS
Definición:
Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la
operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro.
También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en
entrar será también el primero en salir.
Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros),
dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante
colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en
lenguajes orientados a objetos mediante clases, en forma de listas enlazadas.
Otra definicion seria: Son aquellas que solo tiene 2 operaciones, Push(Inserción) y Pop(Eliminación).
Push solo se puede efectuar por un extremo llamado Frente y Pop por el extremo Llamado Final. Sin
Embargo se le pueden aplicar todas las operación al igual que a las listas.
Usos concretos de la cola
La particularidad de una estructura de datos de cola es el hecho de que sólo podemos acceder al primer y
al último elemento de la estructura. Así mismo, los elementos sólo se pueden eliminar por el principio y
sólo se pueden añadir por el final de la cola.
ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 1

Ejemplos de colas en la vida real serían: personas comprando en un supermercado, esperando para entrar
a ver un partido de béisbol, esperando en el cine para ver una película, una pequeña peluquería, etc. La
idea esencial es que son todos líneas de espera.
En estos casos, el primer elemento de la lista realiza su función (pagar comida, pagar entrada para el
partido o para el cine) y deja la cola. Este movimiento está representado en la cola por la función pop o
desencolar. Cada vez que otro elemento se añade a la lista de espera se añaden al final de la cola
representando la función push o encolar. Hay otras funciones auxiliares para ver el tamaño de la cola
(size), para ver si está vacía en el caso de que no haya nadie esperando (empty) o para ver el primer
elemento de la cola (front).
Operaciones Básicas
• Crear: se crea la cola vacía.
• Encolar (añadir, entrar, push): se añade un elemento a la cola. Se añade al final de esta.
• Desencolar (sacar, salir, pop): se elimina el elemento frontal de la cola, es decir, el primer elemento que
entró.
• Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primero elemento que
entró.
Recorrido
Definición:
Ya que las colas son FIFO(First in - First Out) el Recorrido se hace sacando el primer dato que se inserto
hasta que llegue al extremo llamado Final.
Detalle:
En un principio se compara para saber si tiene algún dato en la Cola, si no es así desplegara “Cola
Vacía…”. De otra forma compara si Frente es mayor o igual a Final, de esta forma simplemente hace un
Recorrido lineal como los anteriores. De otra forma usar Max como bandera para saber cuando empezar
a contar de 0 a Final (Ya que sabemos que el Frente después del nodo Final).
Algoritmo:
Recorrido(Cola, Frente, Final, Max)
Si Frente ≠ Nulo
Si Frente ≤ Final, entonces:
Apuntador <-- Frente
Repetir mientras Apuntador ≤ Final

Imprimir Cola[Apuntador]
Apuntador <-- Apuntador + 1
Fin del ciclo
Si no, si Frente > Final, entonces:
Repetir mientras Apuntador ≠ Final
Si Apuntador > Max, entonces:
Apuntador <-- 0
Imprimir Cola[Apuntador]
Fin del ciclo
Si no:
Imprimir "Cola Vacía"
Salir
Diagrama:

Corrida:
Push
Definición:
Push es simplemente el método por el cual va agregando un Dato nuevo a la Cola tomando en cuenta el
Tamaño Máximo de Capacidad (Max), el Frente y el Final de la Cola.
Detalle:
Primer nos aseguramos que la Cola no este Llena, para que de esta manera sea capaz de insertar un
Elemento nuevo. Si no desplegara Cola Llena. Después compara para determinar las posiciones de
Frente y Final y de esta manera poder moverlo con libertad. Ya que determina los valores de Frente y
Final, nos Indica que Cola[Final] tomara el valor de Elemento.
Algoritmo:
Push(Cola, Frente, Final, Max, Elemento)
Si Frente = 0 y Final =9, o si Frente = (Final + 1)
Imprimir "Cola Llena" y Salir
Si Frente = Nulo
Frente <-- 0
Final <-- 0
Si no, si Final = Max
Final <-- 0
Si no:

Final <-- Final + 1
Cola[Final] = Elemento
Salir
Diagrama:
Corrida:

Pop
Definición:
Pop es simplemente el método por el cual va sacando el primer Dato de la Cola (esto se comprueba ya
que las Colas son FIFO), para esto toma en cuenta el Frente.
Detalle:
Compara para determinar si la cola esta vacía, de otra forma lo que hace es Imprimir “Eliminando el
Dato…”. Después se hacen una series de comparaciones para determinar la nueva posición de Frente, de
esa forma el Dato que existía en Frente es Eliminado.
Algoritmo:
Pop(Cola, Frente, Final, Max)
Si Frente ≠ Nulo
Imprimir "Eliminado el Dato..."
Si Frente = Final
Frente = Nulo
Final = Nulo
Si no, si Frente = Max
Frente = 0
Si no:
Frente <-- Frente + 1
Si no:
Salir
Diagrama:

Corrida:
Búsqueda
Definición:
Este método usa el recorrido para encontrar Elemento y desplegar un mensaje si la búsqueda es exitosa.
Detalle:
El algoritmo usa básicamente la misma estructura del Recorrido, la única diferencia es que compara
cada uno de los Datos con Elemento, de esta forma se da cuenta si este Dato existe en la Cola.
Algoritmo:

Busqueda(Cola, Frente, Fin, Max, Elemento)
Si Frente ≠ Nulo
Si Frente ≤ Final, entonces:
Repetir mientras Apuntador ≤ Final
Si Elemento = Cola[Apuntador]
Imprimir "Dato encontrado..." y Salir
Fin del ciclo
Si no, si Frente > Final, entonces:
Repetir mientras Apuntador ≠ Final
Si Apuntador > Max, entonces:
Apuntador <-- 0
Si Elemento = Cola[Apuntador]
Imprimir "Dato encontrado..." y Salir
Fin del ciclo
Imprimir "Dato no encontrado..."
Si no:
Salir
Diagrama:

Corrida:
Eliminacion
Definición:
Este método busca un Dato dentro de la cola y lo elimina.
Detalle:
Este Método es la mezcla de todos en uno, Recorrido, Búsqueda, Pop y Push. Debido que a busca el
Dato haciendo un Recorrido, y en el proceso copia todos los Datos que no son en un Arreglo Temp, para
después meterlos a la Cola original, esto lo hace hasta encontrar el dato deseado que posteriormente lo
Elimina.

Diagrama:
Corrida:
Al igual que con las pilas, veamos ahora el pseudocodigo para crear el programa de COLAS. Igualmente
esta desarrollado en SLE y es muy semejante al anterior. Igualmente, no esta terminado para que puedas
completarlo basandote en el codigo presentado en el Apendice.
/* Algoritmo que muestra el funcionamiento de las COLAS */

/* El programa no esta completo, ya que falta algo, el alumno debera
identificar que es... */
programa Colas
var
cola : vector [10] numerico
frente = 0

final = 0
max = 10
res,op : numerico
inicio
mientras (op<>6)
{
cls()
imprimir ("\n1) Recorrido\n2) Busqueda\n3) Push\n4) Pop\n5) Eliminar Dato\n6) Salir")
imprimir ("\nQue deseas hacer? ")
leer (op)
eval
{
caso ( op == 1)
imprimir ("\nSelecciono recorrido")
recorrido()
readkey()
caso (op == 2 )
imprimir ("\nQue numero deseas buscar?")
leer (res)
//busqueda( res )
readkey()
caso ( op == 3 )
imprimir ("\nQue numero deseas insertar?")
leer (res)
push_insertar( res )
readkey()
caso (op == 4 )
imprimir ("\nSelecciono Pop")
//pop_sacar()
//recorrido()
readkey()
caso (op == 5 )
imprimir ("\nSelecciono Eliminar")
sino
imprimir ("\nsalida")
}
}
fin
/**************************************************************/
subrutina push_insertar ( valor : numerico )
/* Insertar un elemento */
inicio
si ((frente==0 && final == 9) || (frente==(final+1)))
{
imprimir ("\nCola Llena")

}
si (frente==-1)
{
frente = 0
final = 0
sino si (final==max)
final=0
sino
final = final + 1
cola[final] = valor
}
fin
/*************************************************************/
subrutina recorrido()
var
i : numerico
inicio
si (frente<>-1)
{
si (frente<=final)
{
desde i=1 hasta final
{
imprimir ("\nCola: ", cola[i] )
}
sino si (frente>final)
desde i=frente hasta final
{
si (i>max)
{
i=0
imprimir ("\nCola: ",cola[i])
}
}
}
sino
imprimir ("\nCola Vacia..." )
}
fin
Igualmente puedes descargar el programa compilado (escrito en C++) sobre las colas desde la seccion de
biblioteca.

APENDICE
Codigo en lenguaje C++ de una cola
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <iomanip.h>
#include <iostream.h>
class Alumno
{
private:
int Cola[10],Frente,Final,Max;
char Cola1[10][10];
public:
Alumno()
{
int i,j;
char Nulo[2]=" ";
Frente=-1;
Final=-1;
Max=9;
for(i=1;i<9;i++)
{
Cola[i]=0;
strcpy(Cola1[i],Nulo);
}
}
void Push(char Elem[10])

{
if((Frente==0&&Final==9)||(Frente==(Final+1)))
{
cout<<"Cola Llena"<<endl;
return;
}
if(Frente==-1)
{
Frente=0;
Final=0;
}
else if(Final==Max)
Final=0;
else
Final++;
strcpy(Cola1[Final],Elem);
}

void Push(int Elem)
{
{
return;
}
if(Frente==-1)
{
Frente=0;
Final=0;
}
else if(Final==Max)
Final=0;
else
Final++;
Cola[Final]=Elem;
}
void Push(float Elem)

{
{
return;
}
if(Frente==-1)
{
Frente=0;
Final=0;
}
else if(Final==Max)
Final=0;
else
Final++;
Cola[Final]=Elem;
}
void Push(double Elem)

{
{
return;
}
if(Frente==-1)
{
Frente=0;
Final=0;
}
else if(Final==Max)
Final=0;
else
Final++;
Cola[Final]=Elem;

}
void Pop(void)
{
if(Frente!=-1)
{
cout<<"Elmininado el Dato: "<<Cola[Frente];
if(Frente==Final)
{
Frente=-1;
Final=-1;
}
else if(Frente==Max)
Frente=0;
else
Frente++;
}
else
cout<<"Cola Vacia... Imposible Eliminar"<<endl;
}
void Recorrido(void)
{
int i;
if(Frente!=-1)
{
if(Frente<=Final)
for(i=Frente;i<=Final;i++)
cout<<Cola[i]<<endl;
else if(Frente>Final)
for(i=Frente;i!=Final;i++)
{
if(i>Max)
i=0;
cout<<Cola[i]<<endl;
}
}
else
cout<<"Cola Vacia...";
}
void Busqueda(char Elem[10])

{
int i;
if(Frente!=-1)
{
if(Frente<=Final)
if((strcmp(Elem,Cola1[i]))==0)
{
cout<<"Dato "<<Cola1[i]<<" encontrado..."<<endl;
return;
}
{

if(i>Max)
i=0;
{
cout<<"Dato "<<Cola1[i]<<" encontrado..."<<endl;
return;
}
}
}
else
cout<<"Dato no encontrado...";
}
void Busqueda(int Elem)

{
int i;
if(Frente!=-1)
{
if(Frente<=Final)
if(Elem==Cola[i])
{
cout<<"Dato "<<Cola[i]<<" encontrado..."<<endl;
return;
}
{
if(i>Max)
i=0;
if(Elem==Cola[i])
{
return;
}
}
}
else
}
void Busqueda(float Elem)

{
int i;
if(Frente!=-1)
{
if(Frente<=Final)
if(Elem==Cola[i])
{
return;
}
{

if(i>Max)
i=0;
if(Elem==Cola[i])
{
return;
}
}
}
else
}
void Busqueda(double Elem)

{
int i;
if(Frente!=-1)
{
if(Frente<=Final)
if(Elem==Cola[i])
{
return;
}
{
if(i>Max)
i=0;
if(Elem==Cola[i])
{
return;
}
}
}
else
}
void Borrar(char Elem[10])

{
char Temp[10][10];
int i,j;
if(Frente!=-1)
{
if(Frente<=Final)
for(j=0,i=Frente;i<=Final;i++,j++)
{
{
cout<<"Eliminado el Dato "<<Cola1[i]<<endl;
if(Frente==Final)
{
Frente=-1;

Final=-1;
return;
}
Frente=0;
else
Frente++;
for(j--,i=Frente;j!=-1;i++,j--)
strcpy(Cola1[i],Temp[j]);
return;
}
strcpy(Temp[j],Cola1[i]);
}
for(j=0,i=Frente;i!=Final;i++,j++)
{
if(i>Max)
i=0;
{
cout<<"Eliminado el Dato "<<Cola1[i]<<endl;
if(Frente==Max)
Frente=0;
else
Frente++;
{
if(i>Max)
i=0;
strcpy(Cola1[i],Temp[j]);
}
return;
}
strcpy(Temp[j],Cola1[i]);
}
cout<<"Dato no Encontrado...";
}
else
cout<<"Cola Vacia... Imposible Eliminar...";
}
void Borrar(int Elem)

{
int Temp[10],i,j;
if(Frente!=-1)
{
if(Frente<=Final)
{
if(Elem==Cola[i])
{
cout<<"Eliminado el Dato "<<Cola[i]<<endl;
if(Frente==Final)
{
Frente=-1;

Final=-1;
return;
}
Frente=0;
else
Frente++;
Cola[i]=Temp[j];
return;
}
Temp[j]=Cola[i];
}
{
if(i>Max)
i=0;
if(Elem==Cola[i])
{
if(Frente==Max)
Frente=0;
else
Frente++;
{
if(i>Max)
i=0;
Cola[i]=Temp[j];
}
return;
}
Temp[j]=Cola[i];
}
}
else
}
void Borrar(float Elem)

{
int Temp[10],i,j;
if(Frente!=-1)
{
if(Frente<=Final)
{
if(Elem==Cola[i])
{
if(Frente==Final)
{
Frente=-1;
Final=-1;

return;
}
Frente=0;
else
Frente++;
Cola[i]=Temp[j];
return;
}
Temp[j]=Cola[i];
}
{
if(i>Max)
i=0;
if(Elem==Cola[i])
{
if(Frente==Max)
Frente=0;
else
Frente++;
{
if(i>Max)
i=0;
Cola[i]=Temp[j];
}
return;
}
Temp[j]=Cola[i];
}
}
else
}
void Borrar(double Elem)

{
int Temp[10],i,j;
if(Frente!=-1)
{
if(Frente<=Final)
{
if(Elem==Cola[i])
{
if(Frente==Final)
{
Frente=-1;
Final=-1;

return;
}
Frente=0;
else
Frente++;
Cola[i]=Temp[j];
return;
}
Temp[j]=Cola[i];
}
{
if(i>Max)
i=0;
if(Elem==Cola[i])
{
if(Frente==Max)
Frente=0;
else
Frente++;
{
if(i>Max)
i=0;
Cola[i]=Temp[j];
}
return;
}
Temp[j]=Cola[i];
}
}
else
}
}tec;
main()
{
int res,op=0;
while(op!=6)
{
clrscr();
cout<<"\n1) Recorrido\n2) Busqueda\n3) Push\n4) Pop\n5) Eliminar un Dato\n6)
salir"<<endl;
gotoxy(1,1);
cout<<"Que deseas hacer?: ";
cin>>op;
gotoxy(1,10);
switch (op)
{
case 1:

tec.Recorrido();
break;
case 2:
cout<<"Que Numero deseas buscar?"<<endl;
cin>>res;
tec.Busqueda(res);
break;
case 3:
cout<<"Que Numero quieres Insertar?"<<endl;
cin>>res;
tec.Push(res);
break;
case 4:
tec.Pop();
break;
case 5:
cout<<"Que Numero deseas eliminar?"<<endl;
cin>>res;
tec.Borrar(res);
break;
case 6:
cout<<"Salida...";
break;
default:
cout<<"Opcion Erronea"<<endl;
break;
}
getch();
}
}
Colas en Maude
La ColaNV es la cola no vacía, que diferenciamos de la cola normal a la hora de tomar en cuenta
errores. A su vez, el elemento X representa el tipo de valor que puede contener la cola: entero, carácter,
registro....
fmod COLA {X :: TRIV} is

sorts ColaNV{X} Cola{X} .
subsort ColaNV{X} < Cola{X} .
*** generadores
op crear : -> Cola{X} [ctor] .
op encolar : X$Elt Cola{X} -> ColaNV {X} [ctor] .
*** constructores
op desencolar : Cola{X} -> Cola{X} .
*** selectores
op frente : ColaNV{X} -> X$Elt .
*** variables
var C : ColaNV{X} .
vars E E2 : X$Elt .

*** ecuaciones
eq desencolar(crear) = crear .
eq desencolar(encolar(E, crear)) = crear .
eq desencolar(encolar(E, C)) = encolar(E, desencolar(C)) .
eq frente(encolar(E, crear)) = E .
eq frente(encolar(E, C)) = frente(C) .
endfm
Especificación de una cola de colas de enteros en Maude:
view VInt from TRIV to INT is

sort Elt to Int .
endv
view VColaInt from TRIV to COLA{VInt} is

sort Elt to Cola{VInt} .
endv
fmod COLA-COLAS-INT is
protecting INT .
protecting COLA{VColaInt} .
*** operaciones propias de la cola de colas de enteros

op encolarInt : Int ColaNV{VColaInt} -> ColaNV{VColaInt} .
op desencolarInt : Cola{VColaInt} -> Cola{VColaInt} .
op frenteInt : ColaNV{VColaInt} -> [Int] .
*** variables
var CCNV : ColaNV{VColaInt} .
var CC : Cola{VColaInt} .
var CE : Cola{VInt} .
var E : Int .
*** ecuaciones
eq encolarInt(E, encolar(CE, CC)) = encolar(encolar(E, CE), CC) .
eq desencolarInt (encolar(CE, crear)) = encolar(desencolar(CE), crear) .

eq desencolarInt (encolar(CE, CCNV)) = encolar(CE, desencolarInt(CCNV)) .
eq frenteInt(CCNV) = frente(frente(CCNV)) .
endfm
Colas en C++
#ifndef COLA
#define COLA // Define la cola
template <class T>
class Cola{
private:
struct Nodo{
T elemento;
struct Nodo* siguiente; // coloca el nodo en la segunda posición

}* primero;
struct Nodo* ultimo;
unsigned int elementos;
public:
Cola(){
elementos = 0;
}
~Cola(){
while (elementos != 0) pop();
}
void push(const T& elem){
Nodo* aux = new Nodo;
aux->elemento = elem;
if (elementos == 0) primero = aux;
else ultimo->siguiente = aux;
ultimo = aux;
++elementos;
}
void pop(){
Nodo* aux = primero;
primero = primero->siguiente;
delete aux;
--elementos;
}
T consultar() const{
return primero->elemento;
}
bool vacia() const{
return elementos == 0;
}
unsigned int size() const{
return elementos;
}
};
#endif
Colas en JAVA
public void inserta(Elemento x) {

Nodo Nuevo;
Nuevo = new Nodo(x, null);
if (NodoCabeza == null) {
NodoCabeza = Nuevo;
} else {
NodoFinal.Siguiente = Nuevo;
}
NodoFinal = Nuevo;
}
public Elemento cabeza() throws IllegalArgumentException {

if (NodoCabeza == null) {
throw new IllegalArgumentException();
} else {
return NodoCabeza.Info;
}

}
public Cola() {
// Devuelve una Cola vacía
NodoCabeza = null;
NodoFinal = null; //Realizado Por Lic: Helton Petters
}
Colas en C#
public partial class frmPrincipal
{
// Variables globales
public static string[] Cola;
public static int Frente;
public static int Final;
public static int N;
[STAThread]
public static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frmPrincipal());
}
public frmPrincipal() // Constructor

{
InitializeComponent();
Cola = new string[5]; // Arreglo lineal de 5

N = 4;
Frente = -1;
Final = -1;
}
void CmdInsercionClick(object sender, System.EventArgs e)

{
frmInsercion Insercion = new frmInsercion();
Insercion.Show();
}
void CmdRecorridoClick(object sender, System.EventArgs e)

{
frmRecorrido Recorrido = new frmRecorrido();
Recorrido.Show();
}
void CmdBusquedaClick(object sender, EventArgs e)

{
frmBusqueda Busqueda = new frmBusqueda();
Busqueda.Show();
}

void CmdEliminacionClick(object sender, EventArgs e)
{
frmEliminacion Eliminar = new frmEliminacion();
Eliminar.Show();
}
}
Algoritmo Insertar(Cola, N, Frente, Final, Elemento)
void CmdInsertarClick(object sender, System.EventArgs e)

{
elemento = txtInsercion.Text;
// Se verifica que haya espacio en la Cola
if (frmPrincipal.Frente == 0 && frmPrincipal.Final == frmPrincipal.N)
{
MessageBox.Show("La Cola esta llena");
return;
}
if (frmPrincipal.Frente == frmPrincipal.Final + 1)
{
MessageBox.Show("La Cola esta llena");
return;
}
// Si la cola esta vacia se inicializan punteros

if (frmPrincipal.Frente == -1)
{
frmPrincipal.Frente = 0;
frmPrincipal.Final = 0;
}
else if (frmPrincipal.Final == frmPrincipal.N)
{
frmPrincipal.Final = 0;
}
else
{
frmPrincipal.Final = frmPrincipal.Final + 1;
}
// Se agrega elemento a la Cola
frmPrincipal.Cola[frmPrincipal.Final] = elemento;
txtInsercion.Text = "";
Algoritmo Eliminación (Cola, Frente, Final, N)
void CmdEliminarClick(object sender, EventArgs e)

{
if (frmPrincipal.Frente == -1)
{
MessageBox.Show("Cola Vacia");
return;
}

string elemento = frmPrincipal.Cola[frmPrincipal.Frente];
// si la cola tiene un solo elemento

if (frmPrincipal.Frente == frmPrincipal.Final)
{
frmPrincipal.Frente = -1;
frmPrincipal.Final = -1;
}
else if (frmPrincipal.Frente == frmPrincipal.N)

{
frmPrincipal.Frente = 0;
}
else
{
frmPrincipal.Frente = frmPrincipal.Frente + 1;
}
lsEliminado.Items.Add(elemento);
}

Leccion 3.2 Colas

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Leccion 3.2 Colas

Enviado por

Direitos autorais:

Formatos disponíveis

Leccion 3.

Usos concretos de la cola

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 1

Recorrido(Cola, Frente, Final, Max)

Si Frente ≤ Final, entonces:

Apuntador <-- Frente

Repetir mientras Apuntador ≤ Final

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 2

Apuntador <-- Apuntador + 1

Fin del ciclo

Si no, si Frente > Final, entonces:

Apuntador <-- Frente

Repetir mientras Apuntador ≠ Final

Si Apuntador > Max, entonces:

Apuntador <-- Apuntador + 1

Fin del ciclo

Imprimir "Cola Vacía"

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 3

Push(Cola, Frente, Final, Max, Elemento)

Si Frente = 0 y Final =9, o si Frente = (Final + 1)

Imprimir "Cola Llena" y Salir

Si no, si Final = Max

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 4

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 5

Pop(Cola, Frente, Final, Max)

Imprimir "Eliminado el Dato..."

Si no, si Frente = Max

Frente <-- Frente + 1

Imprimir "Cola Vacía"

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 6

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 7

Si Frente ≤ Final, entonces:

Apuntador <-- Frente

Repetir mientras Apuntador ≤ Final

Imprimir "Dato encontrado..." y Salir

Apuntador <-- Apuntador + 1

Fin del ciclo

Si no, si Frente > Final, entonces:

Apuntador <-- Frente

Repetir mientras Apuntador ≠ Final

Si Apuntador > Max, entonces:

Imprimir "Dato encontrado..." y Salir

Apuntador <-- Apuntador + 1

Fin del ciclo

Imprimir "Dato no encontrado..."

Imprimir "Cola Vacía"

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 8

Este método busca un Dato dentro de la cola y lo elimina.

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 9

/* Algoritmo que muestra el funcionamiento de las COLAS */

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 10

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 11

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 12

Codigo en lenguaje C++ de una cola

void Push(char Elem[10])

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 13

void Push(float Elem)

void Push(double Elem)

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 14

void Busqueda(char Elem[10])

ESTRUCTURAS DE DATOS – LECCION 3.2 COLAS Página 15

void Busqueda(int Elem)

void Busqueda(float Elem)