Pilas y Colas

(1)

Pilas

(2)

Definición:



 LaLa pila pila es una estructura de datos que permitees una estructura de datos que permite

almacenar datos en el orden

almacenar datos en el orden LIFO LIFO ((LaLasstt IIn Fn Fiirrsstt OOuut t , en, en

español, "último en entrar, primero en salir").

La recuperación de los datos es realizada en

La recuperación de los datos es realizada en el ordenel orden

inverso de su inserción.

Par

Para el a el manejo de los manejo de los datos cuenta con dos operacionesdatos cuenta con dos operaciones

básicas:

básicas: apilar ( apilar ( push) push), que coloca un objeto en la pila,, que coloca un objeto en la pila,

y su operación inversa,

y su operación inversa, retirar retirar(o (o desapildesapilarar,, pop pop), que), que

retira el último elemento apilado.

(3)

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.

(4)

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 ( size): regresa el número de elementos de la pila.

 Apilar ( 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.

(5)

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.

(6)

 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.

(7)

(8)

(9)

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

(10)

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.

(11)

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

(12)

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á́

(13)

(14)

(15)

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) { valor = v; siguiente = sig; } private: int valor; nodo *siguiente; friend class cola; };

typedef nodo *pnodo;

typedef nodo *pnodo; class cola { public: cola() : ultimo(NULL), primero(NULL) {} ~cola(); void Anadir(int v); int Leer(); private:

pnodo primero, ultimo; }

(16)

#include <iostream> using namespace std;

class nodo { public:

nodo(int v, nodo *sig = NULL) { valor = v; siguiente = sig; } private: int valor; nodo *siguiente;

friend class cola; };

Ejemplo 2

typedef nodo *pnodo; class cola { public: cola() : ultimo(NULL), primero(NULL) {} ~cola(); void Push(int v); int Pop(); private: pnodo ultimo; };

(17)

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;

(18)

 /* 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;

(19)

/* 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;

(20)

 int main() {

 cola Cola;

 Cola.Anadir(20);

 cout << "Añadir(20)" << endl ;

 cout << "Leer: " << Cola.Leer() << endl ;

 return 0;