Pilas y Colas Proyecto PDF

PILAS Y COLAS
PROGRAMACION EN LENGUAJE C
Autor: DIEGO ALEJANDRO PULIDO MORENO

2014
PILAS Y COLAS
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
Autor: DIEGO ALEJANDRO 2

PULIDO MORENO
PILAS Y COLAS
PILAS Y COLAS
Pag.
INTRODUCCIÓN………………………………..…..…………………..4
OBJETIVOS……………………………………………………………...5
PILAS.…………………………………………………………………….6
Definición…………………………………….…………………………...........6
Funciones de las pilas……………....…….…………………………………..6
Operaciones básicas de pilas…………….………………………..………...7
Push, insertar elemento…………..……….…...……………………………..7
Push, en una pila vacía………………….…………………………………....7
pop, leer y eliminar un elemento………..…………………………………...8
Explicación de pilas desde el código………………………………………..8
Algoritmo de la función ”Push”……………………………………………….9
Algoritmo de la función ”Pop”………………………………………………...9
Ejemplo de pilas……………………………………………………………...10
COLAS………………………………………………………………….12
Definición…………………….………………………………………………………12
Funciones de las colas……………………………………………………………..12
Manejo de colas…………….……………………………………………………….12
Operaciones básicas con colas……………….………………………….............13
Añadir un elemento………………………….…………….………………...13
Añadir elemento en una cola vacía………………………………………..13
Añadir elemento en una cola no vacía…………………………………….14
Añadir elemento en una cola, caso general……………………………....14
Leer un elemento de una cola, implica eliminarlo………………………..14
Leer un elemento en una cola con más de un elemento………………..14
Leer un elemento en una cola con un solo elemento……………………15
Leer un elemento en una cola caso general…………………………...…15
Explicación de colas desde el código:……………………………………..16
Algoritmo de la función "añadir"…………………………………………….16
Algoritmo de la función "leer":………………………………………………16
Ejemplo de colas……………………………………………………………..18
CONCLUSION………………………………………………………….20
BIBLIOGRAFIA……………………..………………………………….21

PULIDO MORENO
PILAS Y COLAS
Estudiaremos en detalle las estructuras de datos pilas y colas que son

probablemente las utilizadas y más frecuentemente en los programas más
usuales. Son estructuras de datos que almacenan y recuperan sus elementos
atendiendo a un estricto orden. Las pilas se conocen también 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).

PULIDO MORENO
PILAS Y COLAS
1. Comprende y entiende la definición de pilas y colas en el lenguaje C
2. Entiende y maneja la creación de pilas y colas, en lenguaje C
3. Conoce la estructura de pilas y colas, ingreso de datos y eliminación de

ellos mismos, en lenguaje C

PULIDO MORENO
PILAS Y COLAS
DEFINICION:
Una pila es un tipo especial de lista abierta en la que sólo 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". Además,
las escrituras de datos siempre son inserciones de nodos, y las lecturas
siempre eliminan el nodo leído.
Estas características implican un comportamiento de lista LIFO (Last In First

Out), el último en entrar es el primero en salir.
El símil del que deriva el nombre de la estructura es una pila de platos. Sólo es
posible añadir platos en la parte superior de la pila, y sólo 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 gestión de ventanas en Windows (cuando cerramos
una ventana siempre recuperamos la que teníamos detrás). Otro ejemplo es la
evaluación general de cualquier expresión matemática para evitar tener
que calcular el número de variables temporales que hacen falta.
Por ejemplo:
-4
3 3
7 7 7
-7 -7 -7 -7
2 2 2 2 2

PULIDO MORENO
PILAS Y COLAS
OPERACIONES BASICAS DE PILAS:
Las 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.
PUSH, INSERTAR ELEMENTO:

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:
Pila NULL
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 VACÍA:

Podemos considerar el caso anterior como un caso particular de éste, la única
diferencia es que podemos 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 este caso no vacía:

PULIDO MORENO
PILAS Y COLAS
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 sólo existe un caso posible, ya que sólo podemos leer desde un extremo
dela pila. Partiremos de una pila con uno o más 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 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 pop equivale a leer y borrar.
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 es NULL, y después de eliminar el último nodo la pila quedará
vacía, y el valor de Pila será NULL.
EXPLICACIÓN DE PILAS DESDE EL CÓDIGO

Supongamos que queremos construir una pila para almacenar números
enteros. Haremos pruebas intercalando varios "push" y "pop", y comprobando
el resultado.

PULIDO MORENO
PILAS Y COLAS
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.
void Push(Pila *pila, int v){

pNodo nuevo;
/* Crear un nodo nuevo */
nuevo = (pNodo)malloc(sizeof(tipoNodo));nuevo->valor = v;
/* Añadimos la pila a continuación del nuevo nodo */
nuevo->siguiente = *pila;
/* Ahora, el comienzo de nuestra pila es en nuevo nodo */
*pila = nuevo;
}
ALGORITMO DE LA FUNCIÓN "POP":

Pila.
2. Asignamos a Pila la dirección del segundo nodo de la pila:
Pila->siguiente.
recuerda que la operación pop equivale a leer y borrar.
queremos eliminar.
int Pop(Pila *pila){

pNodo nodo; /* variable auxiliar para manipular nodo */
int v; /* variable auxiliar para retorno */
/* Nodo apunta al primer elemento de la pila */

nodo = *pila;
if(!nodo) return 0; /* Si no hay nodos en pila retornamos 0 */
/* 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;

PULIDO MORENO
PILAS Y COLAS
1. Veremos el funcionamiento de la pila: ingreso ubicación y eliminación 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) /*creación 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 vacía";
return 0;

PULIDO MORENO
PILAS Y COLAS
}
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 ;

PULIDO MORENO
PILAS Y COLAS
DEFINICION:
Una cola es un tipo especial de lista abierta en la que sólo se puede insertar
nodos en uno de los extremos de la lista y sólo se pueden eliminar nodos en el
otro. Además, como sucede con las pilas, las escrituras de datos siempre son inserciones
de nodos, y las lecturas siempre eliminan el nodo leído.
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 símil cotidiano es una cola para comprar, por ejemplo, las entradas del cine.
Los nuevos compradores sólo pueden colocarse al final de la cola, y sólo 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 serán casi
los mismos que para manejar listas y pilas.
Es evidente, a la vista del gráfico, 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. Además,

PULIDO MORENO
PILAS Y COLAS
debido al funcionamiento de las colas, también 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 más fácil será insertar nodos por el final,
a continuación 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 BÁSICAS CON COLAS:

De nuevo nos encontramos ante una estructura con muy pocas operaciones
disponibles. Las colas sólo permiten 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.
AÑADIR UN ELEMENTO:
Las operaciones con colas son muy sencillas, prácticamente no hay casosespeciales, salvo
que la cola 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 último que
valdrán NULL:
PrimeroNULL UltimoNULL
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.

PULIDO MORENO
PILAS Y COLAS
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 este caso, al no estar vacía, los punteros primero y último no
serán nulos:
El proceso sigue siendo muy sencillo:

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:

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 apunte tambié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.
recuerda que la operación de lectura en colas implican también borrar.
queremos eliminar.

PULIDO MORENO
PILAS Y COLAS
LEER UN ELEMENTO EN UNA COLA CON UN SOLO ELEMENTO:

También necesitamos un puntero a un nodo auxiliar:

primero
2. Asignamos NULL a primero, que es la dirección del segundo
nodo teórico de la cola: primero->siguiente.
queremos eliminar.
5. Hacemos que último apunte a NULL, ya que la lectura ha dejado
la cola vacía.
LEER UN ELEMENTO EN UNA COLA CASO GENERAL:

primero.
pila: primero->siguiente.
queremos eliminar.
Si primero es NULL, hacemos que ultimo también apunte a NULL, ya que la lectura ha
dejado la cola vacía.

PULIDO MORENO
PILAS Y COLAS
EXPLICACIÓN DE COLAS DESDE EL CÓDIGO:
Construiremos una cola para almacenar números enteros. Haremos pruebas
insertando varios valores y leyéndolos alternativamente para comprobar el
resultado.
ALGORITMO DE LA FUNCIÓN "ANADIR":

1. Creamos un nodo para el valor que colocaremos en la cola.
3. Si "ultimo" no es NULL, hacemos que ultimo->>siguiente apunte a
nodo.
4. Actualizamos "ultimo" haciendo que apunte a nodo.5. Si "primero" es
NULL, hacemos que apunte a nodo.
void Anadir(pNodo *primero, pNodo *ultimo, int v){

pNodo nuevo;
/* Crear un nodo nuevo */

nuevo = (pNodo)malloc(sizeof(tipoNodo));
nuevo->valor = v;
/* Este será el último nodo, no debe tener siguiente */
nuevo->siguiente = NULL;
/* 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;
/* Si primero es NULL, la cola estaba vacía, ahora primero apuntará también al
nuevo nodo */
If (!*primero) *primero = nuevo;
}
ALGORITMO DE LA FUNCIÓN "LEER":

1. Hacemos que nodo apunte al primer elemento de la cola, es decir a
primero.
cola: primero->siguiente.
recuerda que la operación de lectura equivale a leer y borrar.
queremos eliminar.
5. Si primero es NULL, haremos que último también apunte a NULL, ya que la cola
habrá quedado vacía.

PULIDO MORENO
PILAS Y COLAS
int Leer(pNodo *primero, pNodo *ultimo){

pNodo nodo; /* variable auxiliar para manipula nodo*/
int v; /* variable auxiliar para retorno */
/* Nodo apunta al primer elemento de la pila */

nodo = *primero;
if(!nodo) return 0; /* Si no hay nodos en la pila retornamos 0*/
/* Asignamos a primero la dirección del segundo nodo */

*primero = nodo->siguiente;
/* Guardamos el valor de retorno */
v = nodo->valor;
/* Borrar el nodo */
free(nodo);
/* Si la cola quedó vacía, ultimo debe ser NULL también*/
If(!*primero) *ultimo = NULL;
return v;
}

PULIDO MORENO
PILAS Y COLAS
1. Veremos el funcionamiento de una cola: ingreso ubicación y eliminación

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) /*función cargar*/

{
if(fin==tam)
cout<<"Cola llena";
else
{
p[fin]=info;
fin++;
}
}
int Cola::Sacar( ) /*función eliminar*/

PULIDO MORENO
PILAS Y COLAS
{
if(pcio== fin)
{
cout<<"Cola vacía";
return 0;
}
else
return p[pcio++];
}
void Cola::Mostrar( ) /*función 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 ;
}

PULIDO MORENO
PILAS Y COLAS
En cierto modo y en la búsqueda de la verdad, de la lógica y de la razón hemos

analizado profundamente los aspectos técnicos acerca de las diferentes
estructuras dinámicas y no dinámicas que se encuentran en el lenguaje,
centrándonos especialmente y con particular énfasis en las funciones todas
ellas muy importantes para la programación estructurada, las colas ,las pilas
herramientas indispensables para el ahorro del tiempo a nosotros los
programadores solo la tecnología futura y los nuevos avances tecnológicos nos
darán la luz y nos enseñaran el camino por el cual debe pasar la humanidad
llevada de la mano por la informática.

PULIDO MORENO
PILAS Y COLAS
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. Diseño: valorcreativo.blogspot.com/2011/11/portadas-
word.html

PULIDO MORENO

Pilas y Colas Proyecto PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Pilas y Colas Proyecto PDF

Cargado por

Copyright:

Formatos disponibles

PILAS Y COLAS

Autor: DIEGO ALEJANDRO PULIDO MORENO

DIEGO ALEJANDRO PULIDO MORENO

Autor: DIEGO ALEJANDRO 2

Autor: DIEGO ALEJANDRO 3

Estudiaremos en detalle las estructuras de datos pilas y colas que son

Autor: DIEGO ALEJANDRO 4

1. Comprende y entiende la definición de pilas y colas en el lenguaje C

2. Entiende y maneja la creación de pilas y colas, en lenguaje C

3. Conoce la estructura de pilas y colas, ingreso de datos y eliminación de

Autor: DIEGO ALEJANDRO 5

Estas características implican un comportamiento de lista LIFO (Last In First

“El primero que entra,

FUNCIONES DE LAS PILAS:

Autor: DIEGO ALEJANDRO 6

Push: Añadir un elemento al final de la pila.

PUSH, INSERTAR ELEMENTO:

PUSH EN UNA PILA VACÍA:

El proceso es muy simple, bastará con que:

1. nodo->siguiente apunte a NULL

PUSH EN UNA PILA NO VACÍA:

De nuevo partiremos de un nodo a insertar, con un puntero que apunte a él, y

Autor: DIEGO ALEJANDRO 7

1. Hacemos que nodo->siguiente apunte a Pila

POP, LEER Y ELIMINAR UN ELEMENTO:

1. Hacemos que nodo apunte al primer elemento de la pila, es decir a

2. Asignamos a Pila la dirección del segundo nodo de la pila: Pila-

3. Guardamos el contenido del nodo para devolverlo como retorno,

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

EXPLICACIÓN DE PILAS DESDE EL CÓDIGO

Autor: DIEGO ALEJANDRO 8

void Push(Pila *pila, int v){

ALGORITMO DE LA FUNCIÓN "POP":

int Pop(Pila *pila){

/* Nodo apunta al primer elemento de la pila */

Autor: DIEGO ALEJANDRO 9

1. Veremos el funcionamiento de la pila: ingreso ubicación y eliminación de

class Pila{ /*creamos la clase pila*/

Pila::Pila (int cant=1) /*creación de la pila */

void Pila::push(int aux) /*cargamos pila*/

int Pila::pop( ) /*eliminamos elemento de la pila*/

Autor: DIEGO ALEJANDRO 10

void Pila::Mostrar( ) /*mostramos la pila */

Pila::~Pila( ) {delete p;}; /*al mostrar la pila eliminamos un elemento*/

int main( ) /*inico */

Autor: DIEGO ALEJANDRO 11

FUINCIONES DE LAS COLAS:

“El primero en entrar es el

Autor: DIEGO ALEJANDRO 12

OPERACIONES BÁSICAS CON COLAS:

Añadir: Inserta un elemento al final de la cola.

AÑADIR ELEMENTO EN UNA COLA VACÍA:

El proceso es muy simple, bastará con que:

Autor: DIEGO ALEJANDRO 13

El proceso sigue siendo muy sencillo:

AÑADIR ELEMENTO EN UNA COLA, CASO GENERAL:

1. Hacemos que nodo->siguiente apunte a NULL.

LEER UN ELEMENTO DE UNA COLA, IMPLICA ELIMINARLO:

LEER UN ELEMENTO EN UNA COLA CON MÁS DE UN ELEMENTO:

1. Hacemos que nodo apunte al primer elemento de la cola, es decir a

Autor: DIEGO ALEJANDRO 14

LEER UN ELEMENTO EN UNA COLA CON UN SOLO ELEMENTO:

1. Hacemos que nodo apunte al primer elemento de la pila, es decir a

class Pila{ /creamos la clase pila/

Pila::Pila (int cant=1) /creación de la pila /

void Pila::push(int aux) /cargamos pila/

int Pila::pop( ) /eliminamos elemento de la pila/

void Pila::Mostrar( ) /mostramos la pila /

Pila::~Pila( ) {delete p;}; /al mostrar la pila eliminamos un elemento/

int main( ) /inico /

void Anadir(pNodo primero, pNodo ultimo, int v){

int Leer(pNodo primero, pNodo ultimo){

class Cola /creamos clase cola/

Cola::Cola (int cant=1) /creamos de la cola/

void Cola::Agregar(int info) /función cargar/

int Cola::Sacar( ) /función eliminar/

void Cola::Mostrar( ) /función mostrar/

Cola::~Cola( ) {delete p;}; /al mostrar la cola eliminamos un elemento/

int main( ) /inicio/