Pilas Laboratorio de Programación II

Definición de pila Consideremos una pila de platos: Si se añade un plato a la pila, los que están más abajo son empujados y no son accesibles Si se retira un plato de la pila, aquellos que están debajo ascienden una posición La pila está vacía cuando no hay más platos en ella La pila está llena si no hay lugar para más platos.

TAD pila Conjunto de elementos que sólo son accesibles por un extermo, llamado el tope de la pila Operaciones básicas: Construcción (crear pila vacía) Vacía (comprobar si la pila está vacía) Apilar (agregar un nuevo elemento al tope de la pila) Tope (recuperar el elemento superior de la pila) Desapilar (eliminar el elemento superior de la pila)

Diseño y construcción de la pila Construcción 1) Diseño 2) Implementación

Diseño 1. constructor (construye una pila vacía) 2. vacía(): examinar la pila y devolver V o F 3. apilar(): modificar la pila, agregando un valor en el tope 4. tope(): recupera el valor de la parte superior de la pila 5. desapilar(): modifica una pila eliminando el valor en la cima. Nota: en inglés, la operación apilar se llama push y la operación desapilar se llama pop y así se las conoce habitualmente.

Implementación Distinguimos dos pasos : 1. definir los atributos para guardar los valores de la pila 2. definir los métodos identificados en la fase de diseño.

Implementación 1 Basada en un vector, con la posición 0 como el tope de la pila ?? ?? ?? Apilar 95 Apilar 80 Desapilar ??

Un método mejor El desplazamiento de los elementos del vector de la implementación anterior es innecesario. Pensemos en una pila de libros sobre una mesa. ¿podemos añadir un libro sin tocar el resto? Podemos dar vuelta el vector, fijando la posición 0 en la base de la pila y el último elemento en el tope. Asi no necesitaríamos desplazar los elementos del vector.

Demos vuelta el vector Nuestra clase de pilas será: Un vector para guardar los elementos de la pila Un entero que señale el tope de la pila.

Implementación de operaciones Constructor : El compilador pide la memoria para los atributos miVector y miTope, con lo que el constructor pila sólo necesita encargarse de la inicialización necesaria para crear una pila vacía. Como miTope siempre apunta al tope de la pila, es natural asignar a miTope el valor -1 para señalar una pila vacía. Vacía : Sólo comprobar miTope es -1

Apilar Si miVector no está lleno (es decir miTope < CAPACIDAD_PILA -1) 1. Incrementar miTope en 1 2. Guardar el valor en miVector[miTope] Sino señalar que no hay espacio disponible para el valor, terminar la operación.

Tope Si la pila no está vacía devolver el valor en miVector[miTope] Sino señalar que la pila está vacía y devolver valor basura Hay que encontrar el valor basura para devolverlo en caso que la pila esté vacía.

Desapilar Si la pila no está vacía decrementar miTope en 1 Sino señalar que la pila está vacía

Implementación de la clase pila Veamos el archivo pila.h

Implementación basada en vectores dinámicos La implementación anterior usa pilas del mismo tamaño que los vectores que guardan los elementos Una capacidad suficientemente grande para manejar todas las pilas que se van a usar da lugar a una gran cantidad de espacio malgastado Una capacidad pequeña es inconveniente y molesto porque no van a caber. Usar un vector dinámico es una alternativa, permite al usuario especificar el tamaño de la pila en su declaración.

Los cambios Ahora el constructor realmente tendrá que construir algo: el vector que guardará los elementos de la pila Queremos permitir declaraciones del tipo Pila p1; // capacidad por defecto Pila p2(cap); // capacidad definida por el int cap

Algoritmo para el constructor 1. Comprobar que la capacidad numElem especificada para la pila es positiva. Terminar si no lo es 2. Hacer que miCapacidad sea igual a numElem 3. Reservar espacio para un vector al que apunte miVector y con capacidad miCapacidad 4. Si se consigue reservar memoria para este vector Poner miTope a -1 Sino mostrar un mensaje de error y terminar la ejecución

Definición del constructor en el cpp Pila::Pila (int numElem) { assert (numElem>0); miCapacidad = numElem; miVector = new () ElementoPila[miCapacidad]; if (miVector != 0) miTope = -1; else { cerr << memoria inadecuada para crear la pila ; exit (1); }

Las otras operaciones Las operaciones vacía, apilar, tope, desapilar y mostrar son las mismas que en la declaración del vector estático.

Destructor Necesitaremos un destructor de la clase Pila por la misma razón por la que se necesitaba el constructor. La llamada al destructor liberará la memoria reservada para el vector al que apunta miVector En pila.h: ~Pila(); En pila.cpp: Pila::~Pila() { delete [] miVector; }

Pilas enlazadas Otra alternativa es usar una lista enlazada, lo que le permitirá crecer sin límite (excepto la memoria disponible) y achicarse para no malgastar el espacio sin usar. Sólo el primer nodo de una lista enlazada es directamente accesible y los elementos de la pila sólo son accesibles desde el tope.

Declaración como lista enlazada Class Pila { public: // igual que antes private: Class Nodo: { public: ElementoPila dato; Nodo * siguiente; //constructor de Nodo Nodo (ElementoPila valor, Nodo * enlace =0) : dato (valor), siguiente (enlace) {} }; typedef Nodo * PunteroNodo; PunteroNodo miTope; // puntero al tope de la pila } ; // fin declaración de la clase

Implementación de operaciones Constructor y vacia() Simplemente hacemos que miTope sea un puntero nulo para mostrar que no se refiere a ningún nodo miTope = 0; Comprobar que esté vacío es preguntar si es 0 return miTope ==0;

Implementación de operaciones apilar Una inserción al comienzo de la lista miTope = new Pila :: Nodo (valor, miTope); tope return miTope-> dato; desapilar Borrar el primer elemento punt = miTope; miTope = miTope-> siguiente; delete punt;

Recuperar el primer elemento de la pila miTope

desapilar miTope2 3 4 punt Repositorio de memoria

Ejercicios Escribir un programa que lea un string, carácter a carácter, y determinar si el string contiene paréntesis equilibrados, es decir, si cada paréntesis izquierdo se corresponde con uno derecho más adelante en la cadena. Escribir un programa que convierta notación postfija en notación infija, con los () puestos. Por ejemplo: a b + en a + b a b + c d - *en ( a + b ) * ( c – d )