Pilas y Colas

Pilas

Definición: 

La pila es una estructura de datos que permite La pila Las st In Fi First Out , en almacenar datos en el orden LIFO orden  LIFO (La español, "último en entrar, primero en salir"). La recuperación de los datos es realizada en el orden inverso de su inserción. Para el manejo de los datos cuenta con dos operaciones Para básicas: apilar básicas:  apilar ( push), que coloca un objeto en la pila, y su operación inversa, retirar inversa, retirar(o (o desapil desapilar ar,, pop), que retira el último elemento apilado.

Pila como tipo abstracto de datos 

La pila es un contenedor de nodos y tiene dos operaciones básicas: push (o apilar) y pop (o desapilar).



  Push: Añade un nodo a la parte superior de la pila, dejando por debajo el resto de los nodos ya presentes en la pila.



  Pop: Devuelve y elimina el actual nodo superior de la pila.



Una metáfora que se utiliza con frecuencia es la idea de una pila de platos dispuesta en una cafetería en un contenedor con un muelle que mantiene la pila a nivel. En esa serie, solo el primer plato es visible y accesible para el usuario, todos las demás permanecen ocultos. Como se añaden nuevos platos, cada nuevo plato se convierte en la parte superior de la pila, permaneciendo escondidos debajo los demás. A medida que el plato superior se extrae de la pila, el inmediatamente inferior pasa a ocupar la parte superior de la pila. Dos principios importantes son ilustrados por esta metáfora: únicamente se accede al plato que se encuentra en la parte superior (el último en depositarse), y el resto de platos de la pila permanecen ocultos. Para extraer un plato distinto al superior habrá que extraer antes los que se encuentran sobre él.

Operaciones



Habitualmente, junto a las dos operaciones básicas de apilar y desapilar (push, pop), las pilas puede implementar otra serie de funciones:

  Crear

(constructor): crea la pila vacía.

  Tamaño   Apilar

( size): regresa el número de elementos de la pila.

( push): añade un elemento a la pila.

   Desapilar (pop):

lee y retira el elemento superior de la pila.

  Leer

último (top o peek ): lee el elemento superior de la pila sin retirarlo.

  Vacía

(empty ): devuelve cierto si la pila está sin elementos o falso en caso de que contenga alguno.

La elaboración del modelo de un elemento de la pila 

Para definir un elemento de la pila será utilizado el tipo struct. El elemento de la pila contendrá un campo dato y un puntero siguiente. El puntero siguiente tiene que ser de la misma clase que el elemento, de lo contrario no va a poder apuntar hacia el elemento. El puntero siguiente permitirá el acceso al próximo elemento.



Para permitir las operaciones sobre la pila, vamos a guardar ciertos elementos: el primer elemento, el numero de elementos El primer elemento, que se encuentra en la cabeza de la pila, nos permitirá realizar la operación de recuperación de los datos situados en la parte superior de la pila. Para ello, se utilizará otra estructura (no es obligatorio, pueden ser utilizadas variables).

El puntero inicio indicará la dirección del primer elemento de la lista. La variable tamaño contiene el numero de elementos. 

Cualquiera que sea la posición en la lista, el puntero inicio apunta siempre hacia el primer elemento, que estará en la cabeza de la pila. El campo tamaño abarcará el numero de elementos de la pila, cualquiera que sea la operación efectuada sobre la pila.

Colas

Concepto



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.

Utilización



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.

Operaciones básicas 

  Crear: se crea la cola vacía.

   Encolar

(añadir, entrar, insertar): se añade un elemento a la cola. Se añade al final de esta.

   Desencolar

(sacar, salir, eliminar): 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 primer elemento que entró.

Tipos







Colas simples: Se inserta por un sitio y se saca por otro, en

el caso de la cola simple se inserta por el final y se saca por el principio. Para gestionar este tipo de cola hay que recordar siempre cual es el siguiente elemento que se va a leer y cual es el ultimo elemento que se ha introducido. Colas circulares: En las colas circulares se considera que después del ultimo elemento se accede de nuevo al primero. De esta forma se reutilizan las posiciones extrai das, el final de la cola es a su vez el principio, creándose un circuito cerrado. Colas con prioridad: Las colas con prioridad se implementan mediante listas o arrays ordenados. No nos interesa en este caso que salgan en el orden de entrada sino con una prioridad que le asignemos. Puede darse el caso que existan varios elementos con la misma prioridad, en este caso saldrá́ primero aquel que primero llego (FIFO).

Ejemplos

Ejemplo 1

Ya hemos visto que las colas son casos particulares de listas abiertas, pero más simples. Como en los casos anteriores, veremos ahora un ejemplo de cola usando clases. Para empezar, y como siempre, necesitaremos dos clases, una para nodo y otra para cola. Además la clase para nodo debe ser amiga de la clase cola, ya que ésta debe acceder a los miembros privados de nodo. class nodo { public: nodo(int v, nodo *sig = NULL)

typedef nodo *pnodo;

{ valor = v; siguiente = sig; }

class cola { public: cola() : ultimo(NULL), primero(NULL) {} ~cola(); void Anadir(int v); int Leer();

private: int valor;

private: pnodo primero, ultimo;

nodo *siguiente; friend class cola; };

typedef nodo *pnodo;

}

Ejemplo 2 #include using namespace std;

class nodo { public: nodo(int v, nodo *sig = NULL) { valor = v; siguiente = sig;

typedef nodo *pnodo; class cola { public: cola() : ultimo(NULL), primero(NULL) {} ~cola();

}

void Push(int v); int Pop();

private:

private: pnodo ultimo;

int valor; nodo *siguiente;

friend class cola; };

};

cola::~cola() { while(primero) Leer(); }

void cola::Anadir(int v) { pnodo nuevo;

 /* Crear un nodo nuevo */ nuevo = new nodo(v);  /* Si la cola no estaba vacía, añadimos el nuevo a continuación de ultimo */ if (ultimo) ultimo->siguiente = nuevo;  /* Ahora, el último elemento de la cola es el nuevo nodo */ ultimo = nuevo;



 /* Si primero es NULL, la cola estaba vacía, ahora primero apuntará también al nuevo nodo */ if(!primero) primero = nuevo;

 

}



int cola::Leer() {



pnodo nodo; /* variable auxiliar para manipular nodo */



int v;

/* variable auxiliar para retorno */

 

 /* Nodo apunta al primer elemento de la pila */



nodo = primero;



if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0 */

 /* Asignamos a primero la dirección del segundo nodo */ primero = nodo->siguiente;  /* Guardamos el valor de retorno */ v = nodo->valor;  /* Borrar el nodo */ delete nodo;  /* Si la cola quedó vacía, ultimo debe ser NULL también*/ if (!primero) ultimo = NULL; return v; }



int main() {



cola Cola;



Cola.Anadir(20); cout