ESCUELA POLITECNICA NACIONAL FACULTAD DE INGENIERIA EN SISTEMAS Estructura de datos Nombre: Alexander Pinchao Tema: Pilas y Colas PILAS

Las pilas son otro tipo de estructura de datos lineales, las cuales presentan restricciones en cuanto a la posicin en la cual pueden realizarse las inserciones y las extracciones de elementos. Una pila es una lista de elementos en la que se pueden insertar y eliminar elementos slo por uno de los extremos. Como consecuencia, los elementos de una pila sern eliminados en orden inverso al que se insertaron. Es decir, el ltimo elemento que se meti a la pila ser el primero en salir de ella. En la vida cotidiana existen muchos ejemplos de pilas, una pila de platos en una alacena, una pila de latas en un supermercado, una pila de papeles sobre un escritorio, etc. Debido al orden en que se insertan y eliminan los elementos en una pila, tambin se le conoce como estructura LIFO (Last In, First Out: ltimo en entrar, primero en salir). Representacin en Memoria Las pilas no son estructuras de datos fundamentales, es decir, no estn definidas como tales en los lenguajes de programacin. Las pilas pueden representarse mediante el uso de : Arreglos. Listas enlazadas. Cuando usamos pilas con arreglos, debemos definir el tamao mximo de la pila, adems de un apuntador al ltimo elemento insertado en la pila el cual denominaremos SP(stack pointer ). Cuando utilizamos arreglos para implementar pilas, tenemos la limitante de espacio de memoria reservada. Una vez establecido un mximo de capacidad para la pila, ya no es posible insertar ms elementos esto se puede solucionar mediante el uso de espacios compartidos de memoria . La representacin grfica de una pila con arreglo es la siguiente:

Pila utilizando arreglos Mientras que usando listas enlazadas el limite de la extensin de nuestra pila esta dado por la cantidad de memoria, es decir nuestra pila va creciendo o decreciendo a medida que se agregan o se retiran elementos de la misma.

Pila utilizando listas enlazadas

Operaciones en Pilas Las pilas tienen un conjunto de operaciones muy limitado, slo permiten las operaciones de "push" y "pop": Push: Aadir un elemento al final de la pila. Pop: Leer y eliminar un elemento del final de la pila. En cada momento slo se tiene acceso a la parte superior de la pila, es decir, al ltimo objeto apilado (denominado TOS, Top of Stack en ingls). La operacin retirar permite la obtencin de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS. Las operaciones con pilas son muy simples, no hay casos especiales, salvo que la pila est vaca. Push en una pila vaca..Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a l, adems el puntero a la pila valdr NULL.

El proceso es muy simple, bastar con que: 1. nodo->siguiente apunte a NULL. 2. Pila apunte a nodo.

Push en una pila no vaca.Podemos considerar el caso anterior como un caso particular de ste, la nica diferencia es que podemos y debemos trabajar con una pila vaca como con una pila normal. De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de una pila, en este caso no vaca.

El proceso sigue siendo muy sencillo: 1. Hacemos que nodo->siguiente apunte a Pila. 2. Hacemos que Pila apunte a nodo.

Pop, leer y eliminar un elemento Ahora slo existe un caso posible, ya que slo podemos leer desde un extremo de la pila. Partiremos de una pila con uno o ms nodos, y usaremos un puntero auxiliar, nodo.

1. Hacemos que nodo apunte al primer elemento de la pila, es decir a Pila. 2. Asignamos a Pila la direccin del segundo nodo de la pila: Pila->siguiente. 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operacin pop equivale a leer y borrar.

4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.

Si la pila slo tiene un nodo, el proceso sigue siendo vlido, ya que el valor de Pila->siguiente es NULL, y despus de eliminar el ltimo nodo la pila quedar vaca, y el valor de Pila ser NULL. Algoritmo de la funcin "push": 1. Creamos un nodo para el valor que colocaremos en la pila. 2. Hacemos que nodo->siguiente apunte a Pila. 3. Hacemos que Pila apunte a nodo. Algoritmo de la funcin "pop": 1. Hacemos que nodo apunte al primer elemento de la pila, es decir a Pila. 2. Asignamos a Pila la direccin del segundo nodo de la pila: Pila->siguiente. 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operacin pop equivale a leer y borrar. 4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar. Las clases para pilas son versiones simplificadas de las mismas clases que usamos para listas. Para empezar, necesitaremos dos clases, una para nodo y otra para pila. Adems la clase para nodo debe ser amiga de la clase pila, ya que sta debe acceder a los miembros privados de nodo. Los algoritmos para Push y Pop son los mismos que en C, tan slo cambia el modo de crear y destruir nodos. Cabecera para pilas <stack> Provee la clase adaptadora contenedora std::stack, una pila de datos. El contenedor subyacente puede ser cualquiera de las plantillas de clase de contenedores estndar o alguna otra clase diseado especficamente contenedor. El nico requisito es que soporta las operaciones siguientes: back() push_back() pop_back() Por lo tanto se pueden usar las clases contenedoras de plantillas para vectores, listas y colas En caso de no definirse un modelo a seguir el contenedor usado ser deque.
template < class T, class Container = vector<T> > class stack;

T: Tipo de element Container :Tipo de contenedor que se esta ocupando para el ingreso y almacenamiento de los datos. Funciones miembro de la librera <stack>, Las funciones miembro de la librera <stack> son: Crear: se crea la pila vaca. (Construct) Construct es una copia del argumento del numero de elementos pasado al constructor, de lo contrario es un recipiente vaco. para el numero de elementos, en caso de no ser dados los elementos, se devuelve como size cero
Forma estndar explicit stack ( const Container& ctnr = Container() );

Ejemplo del uso

#include <iostream> #include <vector> #include <deque> #include <stack> using namespace std;

int main () { deque<int> mydeque (3,100); vector<int> myvector (2,200); stack<int> first; stack<int> second (mydeque);

// deque con 3 elementos // vector con 2 elementos // pila vacia // stack copia de deque

stack<int,vector<int> > third; // stack vacia usando vector stack<int,vector<int> > fourth (myvector); cout cout cout cout } << << << << "size "size "size "size of of of of first: " << (int) first.size() << endl; second: " << (int) second.size() << endl; third: " << (int) third.size() << endl; fourth: " << (int) fourth.size() << endl;

return 0;

Vaca: devuelve cierto si la pila est vaca o falso en caso contrario (empty).
Forma estndar bool empty () const; Ejemplo del uso #include <iostream> #include <stack> using namespace std; int main () { stack<int> mystack; int sum (0); for (int i=1;i<=10;i++) mystack.push(i); while (!mystack.empty()) { sum += mystack.top(); mystack.pop(); } cout << "total: " << sum << endl; return 0; }

Tamao: regresa el nmero de elementos de la pila. (size)

Forma estndar tamao size_type () const;

ejemplo de uso
#include <iostream> #include <stack> using namespace std; int main () { stack<int> myints; cout << "0. size: " << (int) myints.size() << endl; for (int i=0; i<5; i++) myints.push(i); cout << "1. size: " << (int) myints.size() << endl; myints.pop(); cout << "2. size: " << (int) myints.size() << endl; return 0; }

Apilar: se aade un elemento a la pila.(push)

Forma estndar void push ( const T& x ); Ejemplo de uso #include <iostream> #include <stack> using namespace std; int main () { stack<int> mystack; for (int i=0; i<5; ++i) mystack.push(i); cout << "Popping out elements..."; while (!mystack.empty()) { cout << " " << mystack.top(); mystack.pop(); } cout << endl; return 0; }

Desapilar: se elimina el elemento frontal de la pila.(pop)

Forma estndar void pop ( ); Ejemplo de uso #include <iostream> #include <stack> using namespace std; int main () { stack<int> mystack; for (int i=0; i<5; ++i) mystack.push(i); cout << " saltando elementos ..; while (!mystack.empty()) { cout << " " << mystack.top(); mystack.pop(); } cout << endl; return 0; }

Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)

Forma estndar value_type & top ();
const value_type & top () const;

Ejemplo de uso.#include <iostream> #include <stack> using namespace std; int main () { stack<int> mystack; mystack.push(10); mystack.push(20);

mystack.top() -= 5; cout << "mystack.top() ahora es " << mystack.top() << endl; return 0; }

Llena: devuelve cierto si la pila est llena o falso en caso contrario (full).
Forma estndar bool full() const; Ejemplo del uso #include <iostream> #include <stack> using namespace std; int main () { stack<int> mystack; int sum (0); for (int i=1;i<=10;i++) mystack.push(i); do { sum += mystack.top(); mystack.pop(); } while (mystack.full()==0); cout << "total: " << sum << endl; return 0; }

COLAS Una cola (tambin llamada fila) es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operacin de insercin push se realiza por un extremo y la operacin de extraccin pop por el otro. Tambin se le llama estructura FIFO (del ingls First In First Out), debido a que el primer elemento en entrar ser tambin el primero en salir. Las colas se utilizan en sistemas informticos, transportes y operaciones de investigacin (entre otros), dnde 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.

A diferencia de las pilas , las colas son una especie de lista enlazada simple que en cada lectura elimina el valor de la salida, que posee dos puntero que apuntal al inicio y al final de la lista por lo tanto, las funciones se programan a mano, es decir no tenemos plantillas de uso Nos encontramos ante una estructura con muy pocas operaciones disponibles. 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.

Estructura de los nodo de la cola

struct nodo { int nro; struct nodo *sgte; };

Estructura de la cola
struct cola { nodo *delante; nodo *atras }; ;

Agregar un elemento a la cola Las operaciones con colas son muy sencillas, prcticamente no hay casos especiales, salvo que la cola est vaca. Aadir elemento en una cola vaca: Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a l, adems los punteros que definen la cola, primero y ultimo que valdrn NULL:

El proceso es muy simple, bastar con que: 1. nodo->siguiente apunte a NULL. 2. Y que los punteros primero y ultimo apunten a nodo.

Aadir elemento en una cola no vaca: De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de una cola, en este caso, al no estar vaca, los punteros primero y ultimo no sern nulos:

El proceso sigue siendo muy sencillo:

1. Hacemos que nodo->siguiente apunte a NULL. 2. Despus que ultimo->siguiente apunte a nodo. 3. Y actualizamos ultimo, haciendo que apunte a nodo.

Aadir elemento en una cola, caso general: Para generalizar el caso anterior, slo necesitamos aadir una operacin: 1. Hacemos que nodo->siguiente apunte a NULL. 2. Si ultimo no es NULL, hacemos que ultimo->siguiente apunte a nodo. 3. Y actualizamos ultimo, haciendo que apunte a nodo. 4. Si primero es NULL, significa que la cola estaba vaca, as que haremos que primero apunte tambin a nodo. Leer un elemento de una cola(implica eliminarlo): Ahora tambin existen dos casos, que la cola tenga un solo elemento o que tenga ms de uno. Leer un elemento en una cola con ms de un elemento: Usaremos un puntero a un nodo auxiliar:

1. Hacemos que nodo apunte al primer elemento de la cola, es decir a primero. 2. Asignamos a primero la direccin del segundo nodo de la pila: primero->siguiente. 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operacin de lectura en colas implican tambin borrar. 4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.

Leer un elemento en una cola con un solo elemento: Tambin necesitamos un puntero a un nodo auxiliar:

1. Hacemos que nodo apunte al primer elemento de la pila, es decir a primero. 2. Asignamos NULL a primero, que es la direccin del segundo nodo terico de la cola: primero>siguiente. 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operacin de lectura en colas implican tambin borrar. 4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar. 5. Hacemos que ultimo apunte a NULL, ya que la lectura ha dejado la cola vaca.

Leer un elemento en una cola caso general: 1. Hacemos que nodo apunte al primer elemento de la pila, es decir a primero. 2. Asignamos a primero la direccin del segundo nodo de la pila: primero->siguiente. 3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operacin de lectura en colas implican tambin borrar. 4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar. Si primero es NULL, hacemos que ultimo tambin apunte a NULL, ya que la lectura ha dejado la cola vaca. Cabecera para colas <queue> cola son un tipo de adaptador del recipiente, especficamente diseado para operar en un contexto FIFO (primero en entrar, primero en salir), donde los elementos se insertan en un extremo del recipiente y se extrae de la otra. La cola se implementan como adaptadores de contenedores , que son clases que utilizan un objeto encapsulado de una clase de contenedor especfico como su contenedor subyacente , proporcionando un conjunto especfico de funciones miembro para acceder a sus elementos. Los elementos se empuja en el "back" del contenedor especfico y surgi a partir de su "frente". El contenedor subyacente puede ser un contenedor de la plantilla de clase estndar o alguna otra clase diseada especficamente contenedor. El nico requisito es que soporta las operaciones siguientes:
front() back() push_back() pop_front()

Estructura estandar
template < class T, class Container = deque<T> > class queue;

T: Tipo de element Container :Tipo de contenedor que se esta ocupando para el ingreso y almacenamiento de los datos. Funciones miembro de la librera <deque>

Las funciones miembro de la librera <deque> son: Construir.-Construir cola y pasar como parmetros el tamao que va ha tener la cola en caso de no darse estos valores pasar la cola como vacia (construct) Estructura estndar
explicit queue ( const Container& ctnr = Container() );

Ejemplo de manejo
#include <iostream> #include <deque> #include <list> #include <queue> using namespace std; int main () { deque<int> mydeck (3,100); // cola con 3 elementos list<int> mylist (2,200); // lista con 2 elementos queue<int> first; // cola vaca queue<int> second (mydeck); // cola copia de la primera queue<int,list<int> > third; // cola inicializada con la lista queue<int,list<int> > fourth (mylist); cout << "size of first: " << (int) first.size() << endl; cout << "size of second: " << (int) second.size() << endl; cout << "size of third: " << (int) third.size() << endl; cout << "size of fourth: " << (int) fourth.size() << endl; return 0; }

Vaco.- Probar si contenedor est vaco en caso de estar vacia enviar un true caso contrario un false (empty). Estructura estndar
bool empty () const;

Ejemplo de manejo
#include <iostream> #include <queue> using namespace std; int main () { queue<int> myqueue; int sum (0); for (int i=1;i<=10;i++) myqueue.push(i); while (!myqueue.empty()) { sum += myqueue.front(); myqueue.pop(); } cout << "total: " << sum << endl; return 0; }

Tamao.- Volver tamao de la cola como un valor entero (size) Estructura estndar
size_type size ( ) const;

Ejemplo de manejo
#include <iostream> #include <queue> using namespace std; int main () { queue<int> myints; cout << "0. tamao: " << (int) myints.size() << endl; for (int i=0; i<5; i++) myints.push(i); cout << "1. tamao: " << (int) myints.size() << endl; myints.pop(); cout << "2. tamao: " << (int) myints.size() << endl; return 0; }

Alfrente.- Devuelve una referencia al siguiente elemento en la cola . Este es el "ms antiguo"
elemento en la cola y el mismo elemento que se sali de la cola si es miembro cola (front)

Estructura estndar
const value_type y delantero () const; value_type y delantero ();

Ejemplo de manejo
#include <iostream> #include <queue> using namespace std; int main () { queue<int> myqueue; myqueue.push(77); myqueue.push(16); myqueue.front() -= myqueue.back(); // 77-16=61 cout << "la parte delantera de mi cola es " << myqueue.front() << endl; return 0; }

Atrs.- Devuelve una referencia al ltimo elemento de la cola . Este es el "nuevo" elemento de la cola es decir, el ltimo elemento empujado en cola (back) Estructura estndar
value_type& back ( ); const value_type& back ( ) const;

Ejemplo de manejo
#include <iostream> #include <queue> using namespace std; int main () { queue<int> myqueue; myqueue.push(12); myqueue.push(75); // este es el final ahora myqueue.back() -= myqueue.front(); cout << "la parte final de mi cola es: " << myqueue.back() << endl; return 0; }

Empuje.- Aade un nuevo elemento al final de la cola , despus de su ltimo elemento actual (push) Estructura estndar
void push ( const T& x );

Ejemplo de manejo
#include <iostream> #include <queue> using namespace std; int main () { queue<int> myqueue; int myint; cout << "ingrese un numero entero:\n"; do { cin >> myint; myqueue.push (myint); } while (myint); cout << "mi cola tiene: "; while (!myqueue.empty()) { cout << " " << myqueue.front(); myqueue.pop(); } return 0; }

Saltar.- Elimina el siguiente elemento de la cola, la reduccin efectiva de su tamao por uno. El elemento eliminado es el "ms antiguo" elemento en la cola (pop) Estructura estndar
void pop ( );

Ejemplo de manejo
#include <iostream> #include <queue> using namespace std; int main () { queue<int> myqueue; int myint; cout << "Please enter some integers (enter 0 to end):\n"; do { cin >> myint; myqueue.push (myint); } while (myint); cout << "mi cola contiene: "; while (!myqueue.empty()) { cout << " " << myqueue.front(); myqueue.pop(); } return 0;