• Like
Pilas y Colas
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

Pilas y Colas

  • 516 views
Published

 

Published in Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
516
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
11
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. ESCUELA POLITECNICA NACIONAL FACULTAD DE INGENIERIA EN SISTEMAS Estructura de datosNombre: Alexander PinchaoTema: Pilas y ColasPILASLas pilas son otro tipo de estructura de datos lineales, las cuales presentan restricciones encuanto a la posición en la cual pueden realizarse las inserciones y las extracciones deelementos.Una pila es una lista de elementos en la que se pueden insertar y eliminar elementos sólo poruno de los extremos. Como consecuencia, los elementos de una pila serán eliminados enorden inverso al que se insertaron. Es decir, el último elemento que se metió a la pila será elprimero en salir de ella.En la vida cotidiana existen muchos ejemplos de pilas, una pila de platos en una alacena, unapila 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, también se le conocecomo estructura LIFO (Last In, FirstOut: último en entrar, primero en salir).Representación en MemoriaLas pilas no son estructuras de datos fundamentales, es decir, no están definidas como tales en loslenguajes de programación. Las pilas pueden representarse mediante el uso de :• Arreglos.• Listas enlazadas.Cuando usamos pilas con arreglos, debemos definir el tamaño máximo de la pila, además de unapuntador 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 memoriareservada. Una vez establecido un máximo de capacidad para la pila, ya no es posible insertar máselementos esto se puede solucionar mediante el uso de espacios compartidos de memoria .La representación gráfica de una pila con arreglo es la siguiente: Pila utilizando arreglosMientras que usando listas enlazadas el limite de la extensión de nuestra pila esta dado por lacantidad de memoria, es decir nuestra pila va creciendo o decreciendo a medida que se agregan ose retiran elementos de la misma. Pila utilizando listas enlazadas
  • 2. Operaciones en PilasLas pilas tienen un conjunto de operaciones muy limitado, sólo permiten las operaciones de"push" y "pop":• Push: Añadir un elemento al final de la pila.• Pop: Leer y eliminar un elemento del final de la pila.En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objetoapilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención deeste elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado conanterioridad), que pasa a ser el nuevo TOS.Las operaciones con pilas son muy simples, no hay casos especiales, salvo que la pila esté vacía.Push en una pila vacía..-Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a él,además 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 vacía.-Podemos considerar el caso anterior como un caso particular de éste, la única diferencia es quepodemos y debemos trabajar con una pila vacía 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 estecaso no vacía.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 elementoAhora sólo existe un caso posible, ya que sólo podemos leer desde un extremo de la pila.Partiremos de una pila con uno o más 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 dirección del segundo nodo de la pila: Pila->siguiente.3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operación popequivale a leer y borrar.
  • 3. 4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.Si la pila sólo tiene un nodo, el proceso sigue siendo válido, ya que el valor de Pila->siguiente esNULL, y después de eliminar el último nodo la pila quedará vacía, y el valor de Pila será NULL.Algoritmo de la función "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 función "pop":1. Hacemos que nodo apunte al primer elemento de la pila, es decir a Pila.2. Asignamos a Pila la dirección del segundo nodo de la pila: Pila->siguiente.3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operación popequivale 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. Además la clase paranodo 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 sólo cambia el modo de crear ydestruir 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 estándaro alguna otra clase diseñado específicamente contenedor. El único requisito es que soporta lasoperaciones siguientes: back() push_back() pop_back()Por lo tanto se pueden usar las clases contenedoras de plantillas para vectores, listas y colasEn 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 elementContainer :Tipo de contenedor que se esta ocupando para el ingreso y almacenamiento de losdatos.Funciones miembro de la librería <stack>,Las funciones miembro de la librería <stack> son:Crear: se crea la pila vacía. (Construct)Construct es una copia del argumento del numero deelementos pasado al constructor, de lo contrario es un recipiente vacío. para el numero deelementos, en caso de no ser dados los elementos, se devuelve como size ceroForma estándarexplicitstack( constContainer&ctnr = Container() );Ejemplo del uso#include <iostream>#include <vector>#include <deque>#include <stack>usingnamespacestd;
  • 4. int main (){deque<int>mydeque (3,100); // deque con 3 elementosvector<int>myvector (2,200); // vector con 2 elementosstack<int> first; // pilavaciastack<int> second (mydeque); // stack copia de dequestack<int,vector<int>> third; // stack vaciausando vectorstack<int,vector<int>> fourth (myvector);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;}Vacía: devuelve cierto si la pila está vacía o falso en caso contrario (empty).Forma estándarboolempty () const;Ejemplo del uso#include<iostream>#include <stack>usingnamespacestd;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;}Tamaño: regresa el número de elementos de la pila. (size)Forma estándartamaño size_type () const;ejemplo de uso#include <iostream>#include <stack>usingnamespacestd;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;}
  • 5. Apilar: se añade un elemento a la pila.(push)Forma estándarvoidpush( const T& x );Ejemplo de uso#include<iostream>#include <stack>usingnamespacestd;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 estándarvoid pop ( );Ejemplo de uso#include <iostream>#include <stack>usingnamespacestd;int main (){stack<int>mystack;for (int i=0; i<5; ++i) mystack.push(i);cout<<"saltandoelementos ..”;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 estándarvalue_type& top ();constvalue_type& top () const;Ejemplo de uso.-#include<iostream>#include <stack>usingnamespacestd;int main (){stack<int>mystack;mystack.push(10);mystack.push(20);
  • 6. mystack.top() -= 5;cout<<"mystack.top() ahoraes "<<mystack.top() <<endl;return 0;}Llena: devuelve cierto si la pila está llena o falso en caso contrario (full).Forma estándarboolfull() const;Ejemplo del uso#include<iostream>#include <stack>usingnamespacestd;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;}COLASUna cola (también llamada fila) es una estructura de datos, caracterizada por ser una secuencia deelementos en la que la operación de inserción push se realiza por un extremo y la operación deextracción pop por el otro. También se le llama estructura FIFO (del inglés First In FirstOut), debidoa que el primer elemento en entrar será también el primero en salir.Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entreotros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y seguardan mediante colas para su posterior procesamiento. Este tipo de estructura de datosabstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listasenlazadas.A diferencia de las pilas , las colas son una especie de lista enlazada simple que en cada lecturaelimina el valor de la salida, que posee dos puntero que apuntal al inicio y al final de la lista por lotanto, las funciones se programan a “mano”, es decir no tenemos plantillas de usoNos encontramos ante una estructura con muy pocas operaciones disponibles. Las colas sólopermiten añadir y leer elementos:• Añadir: Inserta un elemento al final de la cola.• Leer: Lee y elimina un elemento del principio de la cola.
  • 7. Estructura de los nodo de la colastructnodo{intnro;structnodo*sgte;};Estructura de la colastruct cola{nodo*delante;nodo*atras;};Agregar un elemento a la colaLas operaciones con colas son muy sencillas, prácticamente no hay casos especiales, salvo que lacola esté vacía.Añadir elemento en una cola vacía:Partiremos de que ya tenemos el nodo a insertar y, por supuesto un puntero que apunte a él,además los punteros que definen la cola, primero y ultimo que valdrán 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.Añadir elemento en una cola no vacía:De nuevo partiremos de un nodo a insertar, con un puntero que apunte a él, y de una cola, en estecaso, al no estar vacía, los punteros primero y ultimo no serán nulos:El proceso sigue siendo muy sencillo:
  • 8. 1. Hacemos que nodo->siguiente apunte a NULL.2. Después que ultimo->siguiente apunte a nodo.3. Y actualizamos ultimo, haciendo que apunte a nodo.Añadir elemento en una cola, caso general:Para generalizar el caso anterior, sólo necesitamos añadir una operación: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 vacía, así que haremos que primero apuntetambién a nodo.Leer un elemento de una cola(implica eliminarlo):Ahora también existen dos casos, que la cola tenga un solo elemento o que tenga más de uno.Leer un elemento en una cola con más 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 dirección del segundo nodo de la pila: primero->siguiente.3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operación delectura en colas implican también borrar.4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.Leer un elemento en una cola con un solo elemento:También necesitamos un puntero a un nodo auxiliar:
  • 9. 1. Hacemos que nodo apunte al primer elemento de la pila, es decir a primero.2. Asignamos NULL a primero, que es la dirección del segundo nodo teórico de la cola: primero->siguiente.3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operación delectura en colas implican también 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 vacía.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 dirección del segundo nodo de la pila: primero->siguiente.3. Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operación delectura en colas implican también borrar.4. Liberamos la memoria asignada al primer nodo, el que queremos eliminar.Si primero es NULL, hacemos que ultimo también apunte a NULL, ya que la lectura ha dejado lacola vacía.Cabecera para colas<queue>cola son un tipo de adaptador del recipiente, específicamente diseñado para operar en uncontexto FIFO (primero en entrar, primero en salir), donde los elementos se insertan en unextremo del recipiente y se extrae de la otra. La cola se implementan como adaptadores decontenedores , que son clases que utilizan un objeto encapsulado de una clase de contenedorespecífico como su contenedor subyacente , proporcionando un conjunto específico de funcionesmiembro para acceder a sus elementos. Los elementos se empuja en el "back" del contenedorespecífico y surgió a partir de su "frente". El contenedor subyacente puede ser un contenedor dela plantilla de clase estándar o alguna otra clase diseñada específicamente contenedor. El únicorequisito es que soporta las operaciones siguientes: front() back() push_back() pop_front()Estructura estandartemplate<class T, class Container = deque<T>>class queue;T: Tipo de elementContainer :Tipo de contenedor que se esta ocupando para el ingreso y almacenamiento de losdatos.Funciones miembro de la librería <deque>
  • 10. Las funciones miembro de la librería <deque> son:Construir.-Construir cola y pasar como parámetros el tamaño que va ha tener la cola en caso deno darse estos valores pasar la cola como vacia (construct)Estructura estándarexplicit queue ( const Container&ctnr = Container() );Ejemplo de manejo#include<iostream>#include <deque>#include <list>#include <queue>usingnamespacestd;int main (){deque<int>mydeck (3,100); // cola con 3 elementoslist<int>mylist (2,200); // listacon 2 elementosqueue<int>first; // cola vacíaqueue<int>second (mydeck); // cola copia de la primeraqueue<int,list<int>>third; // cola inicializada con la listaqueue<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;}Vacío.-Probar si contenedor está vacío en caso de estar vacia enviar un true caso contrario unfalse (empty).Estructura estándarboolempty () const;Ejemplo de manejo#include <iostream>#include <queue>usingnamespacestd;intmain (){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;}Tamaño.-Volver tamaño de la cola como un valor entero (size)Estructura estándarsize_type size ( ) const;
  • 11. Ejemplo de manejo#include <iostream>#include <queue>usingnamespacestd;int main (){queue<int>myints;cout<<"0. tamaño: "<< (int) myints.size() <<endl;for (int i=0; i<5; i++) myints.push(i);cout<<"1. tamaño: "<< (int) myints.size() <<endl;myints.pop();cout<<"2. tamaño: "<< (int) myints.size() <<endl;return 0;}Alfrente.- Devuelve una referencia al siguiente elemento en la cola . Este es el "más antiguo"elemento en la cola y el mismo elemento que se salió de la cola si es miembro cola (front)Estructura estándarconstvalue_type y delantero () const;value_type y delantero ();Ejemplo de manejo#include <iostream>#include <queue>usingnamespacestd;int main (){queue<int>myqueue;myqueue.push(77);myqueue.push(16);myqueue.front() -= myqueue.back(); // 77-16=61cout<<"la parte delantera de mi cola es "<<myqueue.front() <<endl;return 0;}Atrás.-Devuelve una referencia al último elemento de la cola . Este es el "nuevo" elemento de lacola es decir, el último elemento empujado en cola (back)Estructura estándarvalue_type& back ( );constvalue_type& back ( ) const;Ejemplo de manejo#include<iostream>#include <queue>usingnamespacestd;int main (){queue<int>myqueue;myqueue.push(12);myqueue.push(75); // este es el final ahoramyqueue.back() -= myqueue.front();cout<<"la parte final de mi cola es: "<<myqueue.back() <<endl;return 0;}
  • 12. Empuje.-Añade un nuevo elemento al final de la cola , después de su último elemento actual(push)Estructuraestándarvoid push ( const T& x );Ejemplo de manejo#include<iostream>#include <queue>usingnamespacestd;int main (){queue<int>myqueue;intmyint;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 reducción efectiva de su tamaño por uno. Elelemento eliminado es el "más antiguo" elemento en la cola (pop)Estructura estándarvoid pop ( );Ejemplo de manejo#include<iostream>#include <queue>usingnamespacestd;int main (){queue<int>myqueue;intmyint;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;
  • 13. }