ESCUELA SUPERIOR POLITÉCNICA DE CHIMBORAZO

SEMESTRE 4 “2”

Informe No. 2

IDENTIFICACION
Facultad: Informática y Electrónica

Carrera: Software

Materia: Estructuras de Datos

Semestre: 4

Paralelo: 2

Docente: Ing. María Belén Paredes Regalado

Integrantes: Danilo Baquero

Fecha: 20 – 11 – 2022

Revisado
Calificación
TEMA: Colas Dobles

OBJETIVO GENERAL
• Conocer aspectos teóricos de las Colas Dobles para poderlos aplicar en
el desarrollo de algoritmos para la solución de problemas.

OBJETIVOS ESPECÍFICOS
● Conocimiento teórico y práctico
● Manejo e implementación de Colas Dobles

MARCO TEÓRICO

La cola (queue o cola simple) es una estructura de datos lineal, en la cual el

elemento obtenido a través de la operación ELIMINAR está predefinido y es el
que se encuentra al inicio de la misma.
Una cola simple implementa la política First-In, First-Out (FIFO), esto es, el
primer elemento que se agregó es el primero que se elimina.
La cola simple es una estructura de datos de tamaño fijo y cuyas operaciones se
realizan por ambos extremos; permite INSERTAR elementos al final de la
estructura y permite eliminar elementos por el inicio de la misma. La operación
de insertar también se le llama encolar y la operación de eliminar también se le
llama desencolar.
En una cola simple, cuando se eliminan elementos se recorre el apuntador head
(frente) al siguiente elemento de la estructura, dejando espacios de memoria
vacíos al inicio de la misma. Existen dos mejoras de la cola simple que utilizan
de manera más eficiente la memoria: la cola circular y la cola doble.
En este caso nos centraremos únicamente en la cola doble ya que es nuestro
objetivo de aprendizaje.
 Cola Doble

La doble cola o bicola es una cola bidimensional en la que las inserciones y

eliminaciones se pueden realizar en cualquiera de los dos extremos de la lista
pero no por la mitad.

Variantes de las Bicolas

Existen dos variantes de la doble cola:
Doble cola de entrada restringida: Este tipo de doble cola acepta solamente
la inserción de elementos por un extremo; mientras que puede eliminar por
ambos.
Doble cola de salida restringida: Este tipo de doble cola acepta solamente
la eliminación de elementos por un extremo; mientras que puede insertar por
ambos.

APLICACIÓN PRÁCTICA
El código está implementado con inserción y eliminación por ambos lados de la
cola.

/*
Colas Dobles
Inserta y elimina elementos por el frente y final de la cola.
Danilo Baquero - 6858
*/
#include <iostream>
#include <stdlib.h>

using namespace std;

/* Estructura de los nodos de la cola

----------------------------------------------------------------------*/
struct nodo
{
char dato;
struct nodo *sgte;
};

/* Estructura de la cola
----------------------------------------------------------------------*/
struct cola
{
nodo *frente;
nodo *final;
};

/* Crear Nodo
----------------------------------------------------------------------*/
struct nodo *crearNodo( char x)
{
struct nodo *nuevoNodo = new(struct nodo);
nuevoNodo->dato = x;
return nuevoNodo;
};

/* Encolar elemento
----------------------------------------------------------------------*/
void encolar( struct cola &q, char x, int pos )
{
struct nodo *aux = crearNodo(x);

if( pos==1 )
{
if(q.frente == NULL)
{
aux -> sgte = q.frente;
q.frente = aux;
q.final = aux;
}
else
{
aux -> sgte = q.frente;
q.frente = aux;
}
}
else
{
if( q.final==NULL )
{
aux -> sgte = q.final;
q.frente = aux;
q.final = aux;
}
else
{
aux -> sgte = (q.final) -> sgte;
(q.final) -> sgte = aux;
}
 }
}

/* Desencolar elemento
----------------------------------------------------------------------*/
char desencolar( struct cola &q, int pos )
{
char __c ;
struct nodo *aux = q.frente;

if( pos==1 )
{
__c = (q.frente) -> dato;
q.frente = aux -> sgte;
delete (aux);
}
else
{
__c = (q.final) -> dato;

while( aux -> sgte != q.final )

aux = aux -> sgte;

aux -> sgte = (q.final) -> sgte;

delete (q.final);
q.final = aux;
}
return __c;
}

/* Mostrar Cola
----------------------------------------------------------------------*/
void muestraCola( struct cola q )
{
struct nodo *aux;

aux = q.frente;

while( aux != NULL )

{
cout << "[" << aux -> dato << "]\t" ;
aux = aux -> sgte;
}
}

/* Menu de opciones
----------------------------------------------------------------------*/
void menu()
{
cout << "\n\t IMPLEMENTACION DE COLAS DOBLES EN C++\n\n";
cout << " 1. INSERTAR" << endl;
cout << " 2. ELIMINAR" << endl;
cout << " 3. MOSTRAR COLA" << endl;
cout << " 4. SALIR" << endl;
cout << "\n INGRESE OPCION: ";
}

/* Funcion Principal
----------------------------------------------------------------------*/
int main()
{
struct cola q;

q.frente = NULL;
q.final = NULL;

char c; // caracter a encolar

char x ; // caracter que devuelve la funcion pop (desencolar)
int op; // opcion del menu
int pos; // posicion de isertar o eliminar (inicio o fin)

do
{
menu();
cin >> op;

switch(op)
{
case 1:
cout << "\n Ingrese caracter: ";
cin >> c;

cout << "\n\t1. Inserta al inicio " << endl;

cout << "\t2. Inserta al final " << endl;
cout << "\n\t Opcion : ";
cin >> pos;

encolar( q, c, pos );

cout << "\n\n\t\tCaracter '" << c << "' encolado...\n\n";

break;

case 2:
cout << "\n\t1. Elimina al inicio " <<endl;
 cout << "\t2. Elimina al final " <<endl;
cout << "\n\t Opcion : ";
cin >> pos;

x = desencolar( q, pos );

cout << "\n\n\t\tNumero '" << x << "' desencolado...\n\n";

break;

case 3:
cout << "\n\n MOSTRANDO COLA\n\n";

if(q.frente!=NULL)
muestraCola( q );
else
cout << "\n\n\tCola vacia...!" << endl;

break;

case 4:
cout << "\n\n\t***** GRACIAS POR USAR ESTE PROGRAMA
*****" << endl;
}
cout << endl << endl;
system("pause");
system("cls");
}while(op!=4);

return 0;
}
CONCLUSIONES
• Las Colas Dobles nos ofrecen una forma de programar muy útil en
algunos casos e interesante, conocer su estructura y funcionamiento nos
da la capacidad para incluirla en la resolución de problemas según lo
necesitemos.
• Nos ofrecen la libertad de elegir si queremos ingresar elementos al inicio
o al final de la cola y de igual manera si queremos desencolar o eliminar
algún elemento del inicio o el final.
• El ejemplo utilizado para poner en practica las colas dobles fue ingresar
y eliminar elementos a elección del usuario.

BIBLIOGRAFÍA

• COLAS DOBLES Y CIRCULARES. (2022, 18 noviembre). http://marycruz-

estructuradedatos.blogspot.com/2010/11/colas-dobles-y-
circulares_04.html

• Cruz, M. (2015, 6 septiembre). Colas Dobles en C++.

https://blog.martincruz.me/2012/11/colas-dobles-en-c.html

• García Cano, E. E. & Solano Gálvez, J. A. (2012). Guía práctica de

estudio 06. Estructuras de datos lineales: Cola circular y cola doble.
unam.mx. http://odin.fi-b.unam.mx/salac/practicasEDAA/eda1_p6.pdf