INSTITUTO POLITCNICO NACIONAL ESCUELA SUPERIOR DE INGENIERA MECNICA Y ELCTRICA

UNIDAD CULHUACN

TRABAJO DE COLAS ESTRUCTURA DE BASE DE DATOS

PROFESOR: JESUS RODRIGUEZ BUENDIA

SILVA MIRANDA MARTIN

3EM6

Estructura de las colas

Una cola es un tipo especial de lista abierta en la que slo se puede insertar nodos en uno de los extremos de la lista y slo se pueden eliminar nodos en el otro. Adems, como sucede con las pilas, las escrituras de datos siempre son inserciones de nodos, y las lecturas siempre eliminan el nodo ledo. Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en entrar es el primero en salir. De manera similar a las pilas, las colas definen una estructura no estndar, de manera que se debe crear un nuevo tipo de dato, el tipo cola, que debe tener los siguientes elementos:

Un arreglo de elementos de algn tipo especfico, puede incluso ser un tipo estndar o no. Un nmero que indica el elemento que est en la posicin del frente de la cola. Un nmero que indica el elemento que est en la posicin trasera de la cola.

Es evidente, a la vista del grfico, que una cola es una lista abierta. As que sigue siendo muy importante que nuestro programa nunca pierda el valor del puntero al primer elemento, igual que pasa con las listas abiertas. Adems, debido al funcionamiento de las colas, tambin deberemos mantener un puntero para el ltimo elemento de la cola, que ser el punto donde insertemos nuevos nodos. Teniendo en cuenta que las lecturas y escrituras en una cola se hacen siempre en extremos distintos, lo ms fcil ser insertar nodos por el final, a continuacin del nodo que no tiene nodo siguiente, y leerlos desde el principio, hay que recordar que leer un nodo implica eliminarlo de la cola. Suponiendo que los elementos son nmeros enteros, una idea para representar una cola en C/C++ es usar un arreglo para contener los elementos y emplear otras dos variables para representar la parte frontal y trasera de la cola. #define maxQueue 100 struct cola{ int items[maxQueue]; int front; int rear; };

Esta representacin con arreglos es completamente vlida, pero debemos tener cuidado con los lmites del arreglo. Suponiendo que no existiera la posibilidad de caer en un desbordamiento del arreglo, es decir, que se insertaran ms elementos de lo que el arreglo puede almacenar, la operacin insert podra quedar como: void insert(struct cola *C, int e){ C->items[++C->rear]=e; } y al operacin x=remove(Q) int remove(struct cola *C){ return C->items[C->front++]; } y finalmente la operacin empty(Q): bool empty(struct cola *C){ if(C->front>C->rear) return true; else return false; La diferencia con las pilas reside en el modo de entrada y salida de los datos, en las colas las inserciones se realizan al final de la lista, no al principio. COLAS CON PRIORIDAD Una cola con prioridad es una estructura de datos en la que se ordenan los datos almacenados de acuerdo a un criterio de prioridad. Hay dos tipos de colas de prioridad:

Las colas de prioridad con ordenamiento descendente. Las colas de prioridad con ordenamiento ascendente.

En las colas de prioridad ascendente se pueden insertar elementos en forma arbitraria y solamente se puede remover el elemento con menor prioridad. Si CPA es una cola de prioridad ascendente, la operacin insert (CPA, x) inserta el elemento x en la cola CPA; y la operacin x=minRemove (CPA) asigna a x el valor del elemento menor (de su prioridad) y lo remueve de la cola. En las colas de prioridad descendente es similar, pero slo permite la supresin del elemento ms grande. Las operaciones aplicables a la cola de prioridad descendente son insert (CPD,x) y x=maxRemove(CPD), cuando CPD es una cola de prioridad descendente y x es un elemento. La operacin empty(C) se aplica a cualquier tipo de cola y determina si una cola de prioridad est vaca. Las operaciones de insertar y borrar se aplican solamente si la pila no est vaca.

Los elementos de la cola de prioridad no necesitan ser nmeros o caracteres para que puedan compararse directamente. Pueden ser estructuras complejas ordenadas en uno o varios campos. Por ejemplo, las agendas telefnicas constan de apellidos, nombres, direcciones y nmeros de telfono y estn ordenadas por apellido. A diferencia de las pilas y las colas, en las colas de prioridad se pueden sacar los elementos que no estn en el primer sitio del extremo donde salen los elementos. Esto es porque el elemento a retirar puede estar en cualquier parte del arreglo. Cuando se requiere eliminar un dato de una cola de prioridad se necesita verificar cada uno de los elementos almacenados para saber cul es el menor (o el mayor). Esto conlleva algunos problemas, el principal problema es que el tiempo necesario para eliminar un elemento puede crecer tanto como elementos tenga la cola. Para resolver este problema hay varias soluciones: 1. Se coloca una marca de ``vaco'' en la casilla de un elemento suprimido. Este enfoque realmente no es muy bueno, porque de cualquier modo se accesan los elementos para saber si es una localidad vaca o no lo es. Por otro lado, cuando se remueven elementos, se van creando lugares vacos y despus es necesario hacer una compactacin, reubicando los elementos en el frente de la cola. 2. Cada supresin puede compactar el arreglo, cambiando los elementos depus del elemento eliminado en una posicin y despus decrementando rear en 1. La insercin no cambia. En promedio, se cambian la mitad de los elementos de una cola de prioridad para cada supresin, por lo que esta operacin no es eficiente.

Ejemplos.-Se muestra un men con el cual se puede trabajar ya sea con pilas o colas , y dependiendo de la opcin el ususaio realizara las tares de insertar eliminar y mostrar. #include <iostream.h> #include <conio.h> #include <assert.h> template <class TIPONODO> class Cola; /////////////////////////////////// // definicion clase NodoCola ///// ////////////////////////////////// template <class TIPONODO> class NodoCola { TIPONODO dato; // dato NodoCola <TIPONODO> * sig; // puntero siguiente nodo public: NodoCola (const TIPONODO &); // constructor TIPONODO getDato() const; // devuelve dato del nodo friend class Cola <TIPONODO>; }; // constructor template <class TIPONODO> NodoCola <TIPONODO> :: NodoCola (const TIPONODO & info) : dato(info), sig (0) { } // devuelve una copia del dato que esta en el nodo template <class TIPONODO> TIPONODO NodoCola <TIPONODO> :: getDato() const { return dato; } // definicion enumeracion // enum bool { false, true }; ////////////////////////////////// // definicion clase Cola ///////// ////////////////////////////////// template <class TIPONODO> class Cola { NodoCola <TIPONODO> * primero; NodoCola <TIPONODO> * ultimo; public: // hace que Cola sea friend

// puntero al primer nodo // puntero al ultimo nodo

Cola (); // constructor ~Cola(); // destructor void encolar (const TIPONODO &); // permite insertar nodo bool decolar (TIPONODO &); // permite eliminar nodo bool estaVacia() const; // verifica si la cola esta vacia void imprimir() const; // imprime datos de la cola // funcin de utileria para asignar un nuevo nodo NodoCola <TIPONODO> * getNuevoNodo (const TIPONODO &); }; // constructor predeterminado template <class TIPONODO> Cola <TIPONODO> :: Cola (): primero(0), ultimo(0) { } // destructor template <class TIPONODO> Cola <TIPONODO> :: ~Cola () { if( !estaVacia() ) { // ingresa si la cola no esta vacia cout<<"Eliminando nodos ..." << endl; NodoCola <TIPONODO> * actual = primero, *temporal; while (actual != 0) { // borra los nodos restantes temporal = actual; cout<< temporal->dato << endl; actual = actual->sig; delete temporal; } } cout << "Todos los nodos han sido eliminados" << endl << endl; } // inserta un nodo template <class TIPONODO> void Cola <TIPONODO> :: encolar (const TIPONODO & valor) { NodoCola <TIPONODO> * nuevo = getNuevoNodo (valor); if ( estaVacia() ) primero=ultimo=nuevo; // si la cola esta vacia

else { // si la cola no esta vacia ultimo->sig=nuevo; ultimo=nuevo; } } // elimina un nodo template <class TIPONODO> bool Cola <TIPONODO> :: decolar (TIPONODO & valor) {

if( estaVacia() ) return false;

// la cola esta vacia // eliminacion no satisfactoria

NodoCola <TIPONODO> *temporal = primero; if(primero==ultimo) primero=ultimo=0; else primero=temporal->sig; valor=temporal->dato; // dato que se esta eliminando delete temporal; return true; // eliminacion satisfactoria } // verifica si la cola esta vacia template <class TIPONODO> bool Cola <TIPONODO> :: estaVacia () const { if (primero==0) return true; return false; } // imprime el contenido de la cola template <class TIPONODO> void Cola <TIPONODO> :: imprimir() const { if ( estaVacia() ) { cout<<"La lista esta vacia" << endl << endl; return; } NodoCola <TIPONODO> *actual = primero; cout<<"La cola es: "; while (actual!=0) { cout<< actual->dato <<" "; actual=actual->sig; } cout << endl << endl; } // funcion de utileria: devuelve un apuntador a un nodo recientemente asignado template <class TIPONODO> NodoCola <TIPONODO> * Cola <TIPONODO> :: getNuevoNodo (const TIPONODO & valor) { NodoCola <TIPONODO> * nuevo = new NodoCola <TIPONODO> (valor); assert(nuevo!=0); return nuevo;

} // funcion que prueba una cola template <class T> void probarCola ( Cola <T> & ObjetoCola) { T valor; int opcion; for (;;){ cout<<endl<<"(1) Insertar, (2) Eliminar, (3) Imprimir, (4) Salir"<<endl; cout<<"Seleccion: "; cin>>opcion; switch( opcion ){ case 1: cout<<"Ingrese dato: "; cin>> valor; ObjetoCola.encolar(valor); break; case 2: if(ObjetoCola.decolar(valor)) cout<<"Dato " << valor <<" eliminado" << endl << endl; else cout<<"No puede eliminar : la cola esta vacia" << endl << endl; break; case 3: ObjetoCola.imprimir(); break; } if(opcion==4) break; } } // funcion principal void main(){ clrscr(); Cola <int> ColaEnteros; probarCola (ColaEnteros); }

Ejemplos.-Se introducir un nombre, telfono,direccin de mail, hasta que el usuario ponga fin en nombre, despus se dezplegara una lista con los nombres y datos insertados. #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <string.h> struct agenda { char nombre[50]; char telefono[25]; char mail[50]; }; struct nodo { struct agenda dato; struct nodo *proximo; }; struct nodo *nuevonodo(); int colavacia(struct nodo *); struct nodo *creacola(struct nodo *, struct agenda); void mostrar(struct nodo *); void main() { struct nodo *pri=NULL, *ult=NULL; struct agenda x; printf("Ingrese nombre: "); gets(x.nombre); while(strcmpi(x.nombre,"fin")) { printf("Ingrese telefono: "); gets(x.telefono); printf("Ingrese mail: "); gets(x.mail);

ult=creacola(ult,x); if(pri==NULL) pri=ult; // Si es la 1 pasada pongo en pri el valor del primer nodo printf("Ingrese nombre: "); gets(x.nombre); } if(colavacia(pri)==1) { printf("No se ingresaron registros"); getch(); } else mostrar(pri); } struct nodo *nuevonodo() { struct nodo *p; p=(struct nodo *)malloc(sizeof(struct nodo)); if(p==NULL) { printf("Memoria RAM Llena"); getch(); exit(0); } return p; } struct nodo *creacola(struct nodo *ult, struct agenda x) { struct nodo *p; p=nuevonodo(); (*p).dato=x; (*p).proximo=NULL; if(ult!=NULL) (*ult).proximo=p; // Si hay nodo anterior en prox pongo la direccion del nodo actual return p; } int colavacia(struct nodo *pri) { if(pri==NULL) return 1; else return 0; } void mostrar(struct nodo *pri)

{ struct nodo *aux; while(pri!=NULL) { printf("Nombre: %s - Telefono: %s - Mail: %s \n",pri->dato.nombre,pri->dato.telefono,pri>dato.mail); aux=pri; pri=(*pri).proximo; free(aux); } getch(); }

BIBLIOGRAFIA.http://computacion.cs.cinvestav.mx/~acaceres/courses/estDatosCPP/node35.html www.formatoweb.com.ar/.../pila-y-cola-en-c-c-mas-mas www.como-programar.com/.../como-programar-una-cola-circular.html www.lawebdelprogramador.com/