PILAS Y COLAS

2014
PROGRAMACION EN LENGUAJE C
Autor: DIEGO ALEJANDRO PULIDO MORENO
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
2
PILAS Y COLAS
EN LENGUAJE C
DIEGO ALEJANDRO PULIDO MORENO
TRABJADO DE PROGRAMACION
OSCAR MORERA
UNIVERSIDAD DE CUNDINAMARCA
INGENIERIA DE SISTEMAS
ESTRUCTURAS DE INFORMACION
FACATATIVA
2014
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
3
PILAS Y COLAS
Pag.
INTRODUCCIN......4
OBJETIVOS...5
PILAS..6
Definicin............6
Funciones de las pilas.......6
Operaciones bsicas de pilas......7
Push, insertar elemento........7
Push, en una pila vaca.....7
pop, leer y eliminar un elemento.....8
Explicacin de pilas desde el cdigo..8
Algoritmo de la funcin Push.9
Algoritmo de la funcin Pop...9
Ejemplo de pilas...10
COLAS.12
Definicin.12
Funciones de las colas..12
Manejo de colas..12
Operaciones bsicas con colas..............13
Aadir un elemento.....13
Aadir elemento en una cola vaca..13
Aadir elemento en una cola no vaca.14
Aadir elemento en una cola, caso general....14
Leer un elemento de una cola, implica eliminarlo..14
Leer un elemento en una cola con ms de un elemento..14
Leer un elemento en una cola con un solo elemento15
Leer un elemento en una cola caso general...15
Explicacin de colas desde el cdigo:..16
Algoritmo de la funcin "aadir".16
Algoritmo de la funcin "leer":16
Ejemplo de colas..18
CONCLUSION.20
BIBLIOGRAFIA...21
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
4
Estudiaremos en detalle las estructuras de datos pilas y colas que son
probablemente las utilizadas y ms frecuentemente en los programas ms
usuales. Son estructuras de datos que almacenan y recuperan sus elementos
atendiendo a un estricto orden. Las pilas se conocen tambin como estructuras
LIFO (Last-in, first-out, ltimo en entrar-primero en salir) y las colas como
estructuras FIFO (nirSt-in, First-out, primero en entrar-primero en salir).
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
5
1. Comprende y entiende la definicin de pilas y colas en el lenguaje C
2. Entiende y maneja la creacin de pilas y colas, en lenguaje C
3. Conoce la estructura de pilas y colas, ingreso de datos y eliminacin de
ellos mismos, en lenguaje C
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
6
DEFINICION:
Una pila es un tipo especial de lista abierta en la que slo se pueden insertar y
eliminar nodos en uno de los extremos de la lista. Estas operaciones se
conocen como "push" y "pop", respectivamente "empujar" y "tirar". Adems,
las escrituras de datos siempre son inserciones de nodos, y las lecturas
siempre eliminan el nodo ledo.
Estas caractersticas implican un comportamiento de lista LIFO (Last In First
Out), el ltimo en entrar es el primero en salir.
El smil del que deriva el nombre de la estructura es una pila de platos. Slo es
posible aadir platos en la parte superior de la pila, y slo pueden tomarse del
mismo extremo.
El primero que entra,
el ultimo que sale
FUNCIONES DE LAS PILAS:
Las pilas se utilizan en muchas aplicaciones que utilizamos con
frecuencia. Por ejemplo, la gestin de ventanas en Windows (cuando cerramos
una ventana siempre recuperamos la que tenamos detrs). Otro ejemplo es la
evaluacin general de cualquier expresin matemtica para evitar tener
que calcular el nmero de variables temporales que hacen falta.
Por ejemplo:
3
7
-7
2
-4
3
7
-7
2
-7
2
7
-7
2 2
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
7
OPERACIONES BASICAS DE PILAS:
Laspilas tienenunconjuntodeoperacionesmuylimitado, slopermitenlas operaciones
de "push" y "pop":
Push: Aadir un elemento al final de la pila.
Pop: Leer yeliminar unelementodel final delapila.
PUSH, INSERTAR ELEMENTO:
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:
PilaNULL
El proceso es muy simple, bastar con que:
1. nodo->siguiente apunte a NULL
2. Pila a 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:
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
8
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
dela pila. Partiremos de una pila con uno o ms nodos, y usaremos un puntero
auxiliar, nodo:
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.
EXPLICACIN DE PILAS DESDE EL CDIGO
Supongamos que queremos construir una pila para almacenar nmeros
enteros. Haremos pruebas intercalando varios "push" y "pop", y comprobando
el resultado.
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
9
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.
voidPush(Pila*pila, int v){
pNodonuevo;
/* Crear unnodonuevo*/
nuevo=(pNodo)malloc(sizeof(tipoNodo));nuevo->valor =v;
/* Aadimos la pila a continuacin del nuevo nodo */
nuevo->siguiente=*pila;
/* Ahora, el comienzodenuestrapilaesennuevonodo*/
*pila=nuevo;
}
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.
int Pop(Pila *pila){
pNodonodo; /* variableauxiliar paramanipular nodo*/
int v; /* variableauxiliar pararetorno*/
/* Nodoapuntaal primer elementodelapila*/
nodo = *pila;
if(!nodo) return0; /* Si nohaynodosenpilaretornamos0*/
/* Asignamos a pila toda la pila menos el primer elemento */
*pila=nodo->siguiente;
/* Guardamos el valor de retorno */
v=nodo->valor;
/* Borrar el nodo */
free(nodo);
return v;
}
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
10
1. Veremos el funcionamiento de la pila: ingreso ubicacin y eliminacin de
datos
#include<iostream>
using namespace std;
class Pila{ /*creamos la clase pila*/
private:
int *p /*creamos el puntero*/
int tope, tam; /*declaramos datos*/
public:
Pila (int);
void push(int);
int pop( );
void Mostrar( );
~Pila( );
};
Pila::Pila (int cant=1) /*creacin de la pila */
{
tam=cant;
tope=0;
p=new int [tam];
if (p==NULL) exit(1);
}
void Pila::push(int aux) /*cargamos pila*/
{
if(tope==tam)
cout<<"Pila llena";
else
{
p[tope]=aux;
tope++;
}
}
int Pila::pop( ) /*eliminamos elemento de la pila*/
{
if(tope== 0)
{
cout<<"Pila vaca";
return 0;
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
11
}
else
{
tope--;
return p[tope];
}
}
void Pila::Mostrar( ) /*mostramos la pila */
{
for(int i=tope-1;i>=0;i--)
cout<<p[i];
}
Pila::~Pila( ) {delete p;}; /*al mostrar la pila eliminamos un elemento*/
int main( ) /*inico */
{
Pila a(5);
int i, info;
cout<<"Ingrese 5 numeros enteros:\n";
for(i=0;i<5;i++) /*ciclo for para controlar la entrada de datos*/
{
cin>>info;
a.push(info);
}
for(i=0;i<5;i++) /*ciclo for para controlar la salida de datos*/
{
cout<<a.Sacar( ) ;
a.Mostrar( ) ;
system(" pause " );
}
return 0 ;
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
12
DEFINICION:
Una cola es un tipo especial de lista abierta en la que slo se puede insertar
nodos en uno de los extremos de la lista y slo se pueden eliminar nodos en el
otro. Adems, comosucedeconlaspilas, lasescriturasdedatossiempresoninserciones
de nodos, y las lecturas siempre eliminan el nodo ledo.
Este tipo de lista es conocido como lista FIFO (First In First Out), el primero en
entrar es el primero en salir.
FUINCIONES DE LAS COLAS:
El smil cotidiano es una cola para comprar, por ejemplo, las entradas del cine.
Los nuevos compradores slo pueden colocarse al final de la cola, y slo el
primero dela cola puede comprar la entrada.
El primero en entrar es el
primero en salir
Manejo de colas:
Los tipos que definiremos normalmente para manejar colas sern casi
los mismos que para manejar listas y pilas.
Es evidente, a la vista del grfico, que una cola es una lista abierta. As que
sigue siendo muy importante que nuestro programa nunca pierda el valor del
puntero al primer elemento, igual que pasa con las listas abiertas. Adems,
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
13
debido al funcionamiento de las colas, tambin deberemos mantener un
puntero para el ltimo elemento de la cola, que ser el punto donde insertemos
nuevos nodos.
Teniendo en cuenta que las lecturas y escrituras en una cola se hacen siempre
en extremos distintos, lo ms fcil ser insertar nodos por el final,
a continuacin del nodo que no tiene nodo siguiente, y leerlos desde el
principio, hay que recordar que leer un nodo implica eliminarlo de la cola
OPERACIONES BSICAS CON COLAS:
De nuevo 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: Leeyeliminaunelementodel principiodelacola.
AADIR UN ELEMENTO:
Lasoperacionesconcolas sonmuysencillas, prcticamentenohaycasosespeciales, salvo
quelacolaestvaca.
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 ltimo que
valdrn NULL:
PrimeroNULL UltimoNULL
El proceso es muy simple, bastar con que:
1. nodo->siguiente apunte a NULL.
2. Y que los punteros primero y ltimo apunten a nodo.
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
14
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 ltimo 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. Yactualizamosultimo, haciendoqueapunteanodo.
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 ultimonoesNULL, hacemosqueultimo->siguienteapunteanodo.
3. Yactualizamosultimo, haciendoqueapunteanodo.
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:
Ahoratambinexistendos casos, quelacolatengaunsoloelementooquetengamsde
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.
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
15
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 ltimo 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 primeroesNULL, hacemos queultimotambinapunteaNULL, yaquelalectura ha
dejado la cola vaca.
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
16
EXPLICACIN DE COLAS DESDE EL CDIGO:
Construiremos una cola para almacenar nmeros enteros. Haremos pruebas
insertando varios valores y leyndolos alternativamente para comprobar el
resultado.
ALGORITMO DE LA FUNCIN "ANADIR":
1. Creamos un nodo para el valor que colocaremos en la cola.
2. Hacemos que nodo->siguiente apunte a NULL.
3. Si "ultimo" no es NULL, hacemos que ultimo->>siguiente apunte a
nodo.
4. Actualizamos "ultimo" haciendoqueapunteanodo.5. Si "primero" es
NULL, hacemos que apunte a nodo.
voidAnadir(pNodo*primero, pNodo*ultimo, int v){
pNodonuevo;
/* Crear unnodonuevo*/
nuevo=(pNodo)malloc(sizeof(tipoNodo));
nuevo->valor =v;
/* Esteserel ltimonodo, nodebetener siguiente*/
nuevo->siguiente=NULL;
/* Si lacolanoestabavaca, aadimosel nuevoacontinuacinde ultimo */
if(*ultimo) (*ultimo)->siguiente=nuevo;
/* Ahora, el ltimoelementodelacolaesel nuevonodo*/
*ultimo=nuevo;
/* Si primeroesNULL, lacolaestabavaca, ahoraprimeroapuntartambinal
nuevonodo*/
If (!*primero) *primero=nuevo;
}
ALGORITMO DE LA FUNCIN "LEER":
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
cola: primero->siguiente.
3. Guardamos el contenido del nodo para devolverlo como retorno,
recuerda que la operacin de lectura equivale a leer y borrar.
4. Liberamos la memoria asignada al primer nodo, el que
queremos eliminar.
5. Si primeroes NULL, haremosqueltimotambinapunteaNULL, yaquela cola
habr quedado vaca.
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
17
int Leer(pNodo *primero, pNodo *ultimo){
pNodonodo; /* variableauxiliar paramanipulanodo*/
int v; /* variableauxiliar pararetorno*/
/* Nodoapuntaal primer elementodelapila*/
nodo = *primero;
if(!nodo) return0; /* Si nohaynodosenlapilaretornamos0*/
/* Asignamos aprimeroladireccindel segundonodo*/
*primero = nodo->siguiente;
/* Guardamos el valor de retorno */
v=nodo->valor;
/* Borrar el nodo */
free(nodo);
/* Si la cola qued vaca, ultimo debe ser NULL tambin*/
If(!*primero) *ultimo = NULL;
return v;
}
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
18
1. Veremos el funcionamiento de una cola: ingreso ubicacin y eliminacin
de datos.
#include<iostream>
using namespace std;
class Cola /*creamos clase cola*/
{
private:
int *p; /*creamos puntero*/
int pcio, fin, tam; /*declaramos datos*/
public:
Cola (int);
void Agregar(int);
int Sacar( );
void Mostrar( );
~Cola( );
};
Cola::Cola (int cant=1) /*creamos de la cola*/
{
tam=cant;
pcio=fin=0;
p=new int [tam];
if (p==NULL) exit(1);
}
void Cola::Agregar(int info) /*funcin cargar*/
{
if(fin==tam)
cout<<"Cola llena";
else
{
p[fin]=info;
fin++;
}
}
int Cola::Sacar( ) /*funcin eliminar*/
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
19
{
if(pcio== fin)
{
cout<<"Cola vaca";
return 0;
}
else
return p[pcio++];
}
void Cola::Mostrar( ) /*funcin mostrar*/
{
for(int i=pcio;i<fin;i++)
cout<<p[i];
}
Cola::~Cola( ) {delete p;}; /*al mostrar la cola eliminamos un elemento*/
int main( ) /*inicio*/
{
Cola a(5);
int i, info;
cout<<"Ingrese 5 numeros enteros:\n";
for(i=0;i<5;i++) /*ciclo for para controlar la entrada de datos*/
{
cin>>info;
a.Agregar(info);
}
for(i=0;i<5;i++) /*ciclo for para controlar la salida de datos*/
{
cout<<a.Sacar( ) ;
a.Mostrar( ) ;
system(" pause " );
}
return 0 ;
}
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
20
En cierto modo y en la bsqueda de la verdad, de la lgica y de la razn hemos
analizado profundamente los aspectos tcnicos acerca de las diferentes
estructuras dinmicas y no dinmicas que se encuentran en el lenguaje,
centrndonos especialmente y con particular nfasis en las funciones todas
ellas muy importantes para la programacin estructurada, las colas ,las pilas
herramientas indispensables para el ahorro del tiempo a nosotros los
programadores solo la tecnologa futura y los nuevos avances tecnolgicos nos
darn la luz y nos ensearan el camino por el cual debe pasar la humanidad
llevada de la mano por la informtica.
PILAS Y COLAS
Autor: DIEGO ALEJANDRO
PULIDO MORENO
21
1. Con Clase: http://www.conclase.net
Por: Salvador Pozo Coronado
2. Scribd: http://es.scribd.com/doc/52705482/Estructura-de-
Datos-c-Pilas-Colas-Listas-Arboles-3
3. Blog: http://colas-prog-relva-sevila.blogspot.com/
4. Diseo: valorcreativo.blogspot.com/2011/11/portadas-
word.html