Pila

Es una estructura de datos homognea (elementos del mismo tipo), secuencial y de tamao variable. Slo es posible un modo de acceso a esta estructura: a travs de la cabeza de la pila. De este modo podemos aadir un elemento a la cabeza de la pila o extraer un elemento de la cabeza de la pila. Debido a que las operaciones de extraccin e insercin se realizan por el mismo extremo, el ltimo elemento en ser aadido ser el primero en ser extrado; por ello a estas estructuras se las conoce con el nombre de LIFO (last-in, first-out; ltimo en entrar, primero en salir). El nodo tpico para construir pilas es el mismo que vimos en el captulo anterior para la construccin de listas: struct nodo { int dato; struct nodo *siguiente; };

Para manejar pilas sern casi los mismos que para manejar listas, tan slo cambiaremos algunos nombres: typedef struct _nodo { int dato; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Pila; TipoNodo es el tipo para declarar nodos, evidentemente. pNodo es el tipo para declarar punteros a un nodo. Pila es el tipo para declarar pilas.

Declaracin
Otras operaciones posibles sobre la pila son la creacin de una pila vaca, la interrogacin de la misma para determinar si contiene o no algn elemento y la destruccin de la pila. Para implementar una pila como una estructura dinmica de datos se usan listas enlazadas, las operaciones de extraccin e insercin en la lista (pila) se hacen siempre sobre la cabeza de la misma.

Operaciones
Asociadas con la estructura pila existen una serie de operaciones necesarias para su manipulacin. stas son:

Iniciacin de la estructura
Crear la pila (CrearPila): La operacin de creacin de la pila inicia la pila como vaca. class Pila { public: ... private: Vector vect; int cima; }; Donde Vector ser: typedef Valor Vector[MAX]; Suponiendo Valor, el tipo de dato que se puede almacenar en la pila, y MAX una constante que me limita el tamao mximo de la pila. La creacin de la pila se realizar mediante el constructor por defecto. La tarea que deber realizar ser decir que no existen elementos en la pila: Pila::Pila (void) { cima = 0; } Operaciones para aadir y eliminar informacin: Aadir elementos en la cima (Apilar): pondr un nuevo elemento en la parte superior de la pila. Algoritmos Entradas x: Valor {* elemento que se desea insertar *} stack: Pila de Valor Salidas stack Inicio {* comprobar si en la pila se pueden insertar ms elementos *} {* esto es necesario por el tipo de representacin de la estructura *} Si (stack.Cima = MAX) entonces Error "pila llena"

Sino stack.Cima stack.Cima + 1 stack.Info [stack.Cima] x Fin_sino Fin

Eliminar elementos de la cima (Desapilar): lo que har ser devolver el elemento superior de la cima y eliminarlo de la pila. Algoritmos Entradas stack: Pila de Valor Salidas stack x: Valor Inicio {* comprobar si se pueden eliminar elementos de la pila *} {* esta operacin no depende de la representacin, siempre es necesaria *} Si ( Pila_Vacia ( stack ) ) entonces Error pila vacia sino stack.Cima stack.Cima - 1 Fin_si Fin

Operaciones para comprobar tanto la informacin contenida en la pila, como el propio estado de la cima: Comprobar si la pila est vaca (PilaVacia): Esta operacin es necesaria para poder decidir si es posible eliminar elementos de la pila. Algoritmo Pila_Vacia Entrada stack: Pila Salida (CIERTO, FALSO) Inicio Si ( stack.Cima = 0 ) entonces Devolver ( CIERTO ) Sino Devolver ( FALSO ) Fin_si Fin

bool Pila::PilaVacia (void) { return cima == 0; } Acceder al elemento situado en la cima (CimaPila): Nos indica el valor del elemento situado en la parte superior de la pila. Algoritmo Cima_Pila Entradas stack: Pila de Valor

Salidas Valor Inicio {* comprobar si existe informacin en la pila *} {* esta operacin no depende de la representacin, siempre es necesaria *} Si ( Pila_Vacia ( stack ) ) entonces Error pila vacia sino Devolver ( stack.Info [stack.Cima] ) Fin_si Fin

La especificacin correcta de todas estas operaciones permitir definir adecuadamente una pila. Una declaracin ms formal de las operaciones definidas sobre la estructura de datos pila, y los axiomas que las relacionan podran ser las siguientes: Estructura Pila (Valor) /* Valor ser el tipo de datos que podremos guardar en la pila */ Operaciones CREAR_PILA ( ) Pila APILAR (Pila, Valor) Pila DESAPILAR (Pila) Pila CIMA_PILA (Pila) Valor PILA_VACIA (Pila) Lgico Axiomas stack Pila, x Valor se cumple que: PILA_VACIA (CREAR_PILA ( )) cierto PILA_VACIA (APILAR (stack, x)) falso DESAPILAR (CREAR_PILA ( )) error DESAPILAR (APILAR (stack, x)) stack

CIMA_PILA (CREAR_PILA ( )) error CIMA_PILA (APILAR (stack, x)) x La forma ms simple, y habitual, de representar una pila es mediante un vector unidimensional. Este tipo de datos permite definir una secuencia de elementos (de cualquier tipo) y posee un eficiente mecanismo de acceso a la informacin contenida en ella. Al definir un array hay que determinar el nmero de ndices vlidos y, por lo tanto, el nmero de componentes definidos. Entonces, la estructura pila representada por un array tendr limitado el nmero de posibles elementos. La parte privada de la clase, ser pues un vector donde guardaremos la informacin. El primer elemento de la pila se almacenar en info [0], ser el fondo de la pila, el segundo elemento en info [1] y as sucesivamente. En general, el elemento i-simo estar almacenado en info [i - 1]. Como todas las operaciones se realizan sobre la cima de la pila, es necesario tener correctamente localizada en todo instante esta posicin. Es necesaria una variable adicional, cima, que apunte al ltimo elemento de la pila o nos diga cuantos elementos tenemos en ella.

Cola
En muchas aplicaciones se cumple el hecho de que el primer proceso que solicita un servicio o recurso es el primero en ser servido. Para retirar elementos (servicios, recursos) en el mismo orden en que fueron solicitados, se necesitan unas estructuras de datos abstractas que mantengan una secuencia de valores y permitan aadir nuevos elementos por un extremo y retirarlos por el otro. Esta estructura recibe el nombre de cola. En las colas el elemento que entr el primero sale tambin el primero, por ello se le conoce tambin como listas FIFO (first-in, first-out; primero en entrar, primero en salir.) Se define la cola, como una estructura de datos homognea de tamao variable que soporta el siguiente modo de acceso: insercin por un extremo y extraccin por el opuesto. Operaciones posibles sobre la cola son la creacin de una cola vaca, la determinacin de s la cola est o no vaca y la destruccin de la cola. De igual modo que se ha visto para la pila, una cola se puede implementar haciendo uso de las estructuras dinmicas de datos. En este caso, se simula mediante una lista enlazada que mantiene dos punteros, uno llamado frente por donde se van extrayendo los elementos ms antiguos de la cola, y otro llamado final, que seala al extremo por el cual se irn aadiendo elementos a la cola. De esta forma, el puntero final nos garantiza que cada vez que se tenga que extraer un elemento de la cola, no sea necesario recorrer sta desde el principio, lo cual sera altamente ineficiente para colas largas. Las operaciones de insertar y extraer de la cola tienen acceso directo a los nodos de la cola en los que se van a realizar estas operaciones. 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.

#ifndef COLA #define COLA // Define la cola template <class T> class Cola{ private: struct Nodo{ T elemento; struct Nodo* siguiente; posicin }* primero; struct Nodo* ultimo; unsigned int elementos; public: Cola(){ elementos = 0; }

// coloca el nodo en la segunda

~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

Operaciones
Las colas slo permiten aadir y leer elementos: Aadir: Inserta un elemento al final de la cola. Leer: Lee y elimina un elemento del principio de la cola.

Cola Circular
Las colas lineales tienen un grave problema, como las extracciones slo pueden realizarse por un extremo, puede llegar un momento en que el apuntador A sea igual al mximo nmero de elementos en la cola, siendo que al frente de la misma existan lugares vacos, y al insertar un nuevo elemento nos mandar un error de overflow (cola llena).

Para solucionar el problema de desperdicio de memoria se implementaron las colas circulares, en las cuales existe un apuntador desde el ltimo elemento al primero de la cola. La representacin grfica de esta estructura es la siguiente:

La condicin de vaco en este tipo de cola es que el apuntador F sea igual a cero. Las condiciones que debemos tener presentes al trabajar con este tipo de estructura son las siguientes: Over flow, cuando se realice una insercin. Under flow, cuando se requiera de una extraccin en la cola. Vacio
Algoritmo de inicializacin F < -- 0 A<-- 0 Algoritmo para insertar Si (F+1=A) (F=1 y A=mximo) entonces mensaje (overflow) en caso contrario inicio si A=mximo entonces A<--1 cola[A]<-- valor en caso contrario A <--A+1 cola[A]<-- valor si F=0 entonces F <-- 1 fin Algoritmo para extraer Si F=0 entonces mensaje (underflow) en caso contrario x <-- cola[F] si F=A entonces F <-- 0 A<-- 0 en caso contrario si F=mximo entonces F <--1 en caso contrario F <-- F+1

Doble Cola Esta estructura es una cola bidimensional en que las inserciones y eliminaciones se pueden realizar en cualquiera de los dos extremos de la bicola. Grficamente representamos una bicola de la siguiente manera:

Existen dos variantes de la doble cola: Doble cola de entrada restringida. Doble cola de salida restringida. La primer variante slo acepta inserciones al final de la cola, y la segunda acepta eliminaciones slo al frente de la cola Algoritmos de entrada restringida Algoritmo de Inicializacin F < -- 1 A <-- 0 Algoritmo para Insertar Si A=mximo entonces Mensaje (overflow) En caso contrario A <--A+1 Cola[A]<-- valor Algoritmo para Extraer Si F&gta entonces Mensaje (underflow) En caso contrario Mensaje (frente/atrs) Si frente entonces X <-- cola[F] F <-- F+1 En caso contrario X <-- cola[A] A <-- A-1 Algoritmos de salida restringida Algoritmo de Inicializacin F <--1 A <-- 0

Algoritmo para Insertar Si F&gta entonces Mensaje (overflow) En caso contrario Mensaje (Frente/Atrs) Si Frente entonces Cola[F] <--valor En caso contrario A <-- A+1 Cola[A] <--valor Algoritmo para Extraer Si F=0 entonces Mensaje (underflow) En caso contrario X <--cola[F] F <-- F+1