Colas en C++

Una cola (tambin llamada fila) es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operacin de insercin push se realiza por un extremo y la operacin de extraccin pop por el otro. Tambin se le llama estructura FIFO (del ingls First In First Out), debido a que el primer elemento en entrar ser tambin el primero en salir.

Las colas se utilizan en sistemas informticos, transportes y operaciones de investigacin (entre otros), dnde 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.

Implementacion

en

C++

/* Name: Colas Copyright: casicodigo.blogspot.com Author: Jose Martin Cruz Otiniano Date: 27/10/12 12:27

Description: Encola elemento, Desesencola elemento, Mostrar cola, Vaciar cola */ #include <iostream>
#include <stdlib.h>

using namespace std;

/* struct nodo { int nro;

Estructura de los nodos de la cola

-----------------------------------------------------------------*/

struct nodo *sgte; };

/* struct cola { nodo *delante; nodo *atras }; ;

Estructura de la cola

-----------------------------------------------------------------*/

/* */

Encolar elemento

-----------------------------------------------------------------void encolar( struct cola &q, int valor ) { struct nodo *aux = new(struct nodo); aux->nro = valor; aux->sgte = NULL; if( q.delante == NULL) q.delante = aux; else // encola el primero elemento

(q.atras)->sgte = aux; q.atras = aux; elemento } /* */ int desencolar( struct cola &q ) { int num ; struct nodo *aux ; aux = q.delante; num = aux->nro; q.delante = (q.delante)->sgte; delete(aux); return num; } /* */ void muestraCola( struct cola q ) { struct nodo *aux; aux = q.delante; while( aux != NULL ) { cout<<" } } /* Eliminar todos los elementos de la Cola "<< aux->nro ; aux = aux->sgte; Mostrar Cola // libera memoria a donde apuntaba aux // aux apunta al inicio de la cola Desencolar elemento // puntero que siempre apunta al ultimo

------------------------------------------------------------------

-------------------------------------------------------------------

------------------------------------------------------------------*/ void vaciaCola( struct cola &q) { struct nodo *aux; while( q.delante != NULL) { aux = q.delante; q.delante = aux->sgte; delete(aux); } q.delante = NULL; q.atras } /* -*/ void menu() { cout<<"\n\t IMPLEMENTACION DE COLAS EN C++\n\n"; cout<<" 1. ENCOLAR cout<<" 2. DESENCOLAR cout<<" 3. MOSTRAR COLA cout<<" 4. VACIAR COLA cout<<" 5. SALIR cout<<"\n INGRESE OPCION: "; } /* -*/ int main() { struct cola q; q.delante = NULL; q.atras = NULL; Funcion Principal "<<endl; "<<endl; "<<endl; "<<endl; "<<endl; Menu de opciones = NULL;

-------------------------------------------------------------------

-------------------------------------------------------------------

int dato; int op; int x ;

// numero a encolar // opcion del menu // numero que devuelve la funcon pop

system("color 0b"); do { menu(); cin>> op;

switch(op) { case 1: cout<< "\n NUMERO A ENCOLAR: "; cin>> dato; encolar( q, dato ); cout<<"\n\n\t\tNumero encolado...\n\n"; break; " << dato << "

case 2: x = desencolar( q ); cout<<"\n\n\t\tNumero desencolado...\n\n"; break; "<< x <<"

case 3: cout << "\n\n MOSTRANDO COLA\n\n"; if(q.delante!=NULL) muestraCola( q ); else break; cout<<"\n\n\tCola vacia...!"<<endl;

case 4:

vaciaCola( q ); cout<<"\n\n\t\tHecho...\n\n"; break; } cout<<endl<<endl; system("pause"); }while(op!=5); system("cls");

return 0; }

Colas Dobles en C++

La doble cola 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 insercin de elementos por un extremo; mientras que puede eliminar por ambos.

Doble cola de salida restringida.- Este tipo de doble cola acepta solamente la eliminacin de elementos por un extremo; mientras que puede insertar por ambos. El codigo esta emplementado con insersion y eliminacion por ambos lados de la cola. Implementacion en C++
/* Name: Colas Dobles Copyright: casicodigo.blogspot.com Author: J. Martin Cruz Otiniano Date: 11/11/12 23:27 Description: Inserta y elimina por delante y detras de la cola */

#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 *delante;

nodo *atras };

/*

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.delante==NULL) { aux->sgte = q.delante; q.delante = aux; q.atras } else { aux->sgte = q.delante; q.delante = aux; } } else { = aux;

if( q.atras==NULL ) { aux->sgte = q.atras; q.delante = aux; q.atras } else { aux->sgte = (q.atras)->sgte; (q.atras)->sgte = aux; } } } = aux;

/*

Desencolar elemento

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

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

while( aux->sgte!=q.atras ) aux = aux->sgte;

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

delete(q.atras); q.atras = aux; }

return __c; }

/*

Mostrar Cola

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

aux = q.delante;

while( aux != NULL ) { cout<<" "<< aux->dato ;

aux = aux->sgte; } }

/*

Menu de opciones

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

cout<<"\n INGRESE OPCION: "; }

/*

Funcion Principal

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

q.delante = NULL; q.atras = NULL;

char c; char x ; int op; int pos;

// caracter a encolar // caracter que devuelve la funcion pop (desencolar) // opcion del menu // posicion de isertar o eliminar (inicio o fin)

do { menu(); cin>> op;

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

cout<<"\n\t[1] Inserta al inicio " <<endl; cout<<"\t[2] Inserta al final cout<<"\n\t cin>> pos; Opcion : "; " <<endl;

encolar( q, c, pos );

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

break;

case 2: cout<<"\n\t[1] Elimina al inicio " <<endl; cout<<"\t[2] Elimina al final cout<<"\n\t cin>> pos; Opcion : "; " <<endl;

x = desencolar( q, pos );

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

'"<<

<<"'

break;

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

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

break; }

cout<<endl<<endl; system("pause"); system("cls");

}while(op!=4);

return 0; }

Cola con prioridad en C++

Una cola de prioridades es una estructura de datos en la que los elementos se atienden en el orden indicado por una prioridad asociada a cada uno. Si varios elementos tienen la misma prioridad,se atendern de modo convencional segn la posicin que ocupen. Este tipo especial de colas tienen las mismas operaciones que las colas , pero con la condicin de que los elementos se atienden en orden de prioridad. Ejemplos de la vida diaria seran la sala de urgencias de un hospital, ya que los enfermos se van atendiendo en funcin de la gravedad de su enfermedad. Entendiendo la prioridad como un valor numrico y asignando a altas prioridades valores pequeos, las colas de prioridad nos permiten aadir elementos en cualquier orden y recuperarlos de menor a mayor.

Implementacion en C++ /* Name: Colas con prioridad Copyright: casicodigo.blogspot.com Author: J. Martin Cruz Otiniano Date: 10/11/12 12:27 Description: Se encola caracteres de acuerdo a su prioridad(entero) ingresada. */

#include <iostream> #include <stdlib.h> using namespace std;

/*

Estructura de los nodos de la cola

-----------------------------------------------------------------------*/ struct nodo { char dato; int priori; struct nodo *sgte; }; // prioridad del nodo

/*

Estructura de la cola

-----------------------------------------------------------------------*/ struct cola { nodo *delante; nodo *atras }; ;

/*

Crear Nodo

-----------------------------------------------------------------------*/ struct nodo *crearNodo( char x, int pr) { struct nodo *nuevoNodo = new(struct nodo); nuevoNodo->dato = x; nuevoNodo->priori = pr; return nuevoNodo; };

/*

Encolar cacarter con prioridad

-----------------------------------------------------------------------*/ void encolar( struct cola &q, char valor, int priori ) {

struct nodo *aux = crearNodo(valor, priori); aux->sgte = NULL;

if( q.delante == NULL) q.delante = aux; else (q.atras)->sgte = aux; // encola el primero elemento

q.atras = aux; elemento }

// puntero que siempre apunta al ultimo

/*

Mostrar Cola

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

aux = q.delante;

cout << " Caracter

Prioridad " << endl;

cout << " ------------------- " << endl;

while( aux != NULL ) { cout<<" endl; aux = aux->sgte; } } "<< aux->dato << " | " << aux->priori <<

/*

Ordenar

por prioridad( criterio de O. por Burbuja)

-----------------------------------------------------------------------*/

void ordenarPrioridad( struct cola &q ) { struct nodo *aux1, *aux2; int p_aux; char c_aux;

aux1 = q.delante;

while( aux1->sgte != NULL) { aux2 = aux1->sgte;

while( aux2 != NULL) { if( aux1->priori > aux2->priori ) { p_aux = aux1->priori; c_aux = aux1->dato;

aux1->priori = aux2->priori; aux1->dato = aux2->dato;

aux2->priori = p_aux; aux2->dato } = c_aux;

aux2 = aux2->sgte; }

aux1 = aux1->sgte; } } /* Inserta cacacteres en una cola

-----------------------------------------------------------------------*/ void insertar( struct cola &q, char c, int pr )

{ /* Encolando caracteres */ encolar( q, c, pr );

/* Ordenando por prioridad */ ordenarPrioridad( q ); }

/*

Menu de opciones

-----------------------------------------------------------------------*/ void menu() { cout<<"\n\t COLAS CON PRIORIDAD EN C++ \n\n"; cout<<" 1. ENCOLAR cout<<" 2. MOSTRAR cout<<" 3. SALIR "<<endl; "<<endl; "<<endl;

cout<<"\n INGRESE OPCION: "; }

/*

Funcion Principal

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

q.delante = NULL; q.atras = NULL;

char c ; int pr; int op; int x ;

// caracter a encolar // prioridad del caracter // opcion del menu // numero que devuelve la funcon pop

do { menu(); cin>> op;

switch(op) { case 1:

cout<< "\n Ingrese caracter: "; cin>> c;

cout<< "\n Ingrese prioridad: "; cin>> pr;

insertar( q, c, pr );

cout<<"\n\n\t\tCaracter encolado...\n\n"; break;

'"

<<

<<

"'

case 2:

cout << "\n\n MOSTRANDO COLA DE PRIORIDAD\n\n";

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

default: cout<<"\n\tOpcion incorecta..!"<<endl; system("pause"); exit(0); }

cout<<endl<<endl; system("pause"); system("cls");

}while(op!=3);

return 0; }