Ejemplos Pila y Cola Con Poo

Programación en C++/Estructuras II 1

Programación en C++/Estructuras IIEditores:Oscar E. Palacios [1]

← Punteros Plantillas →

IntroducciónMuchos autores comienzan por definir los conceptos de estructura de datos a raiz de estructuras conocidas comolistas. En el mismo contexto, suele suceder que a dichas listas también se les conoce como secuencias y/ocolecciones de datos. Hay que decir que dichos autores están (en parte) en lo correcto, ya que una lista (de cualquiertipo) es una estructura ideada con el propósito de albergar datos agrupados bajo un mismo nombre. Al respecto,podemos pensar que las listas son como arreglos de datos, es decir, para hacer una introducción al manejo yprogramación de listas encadenadas podemos tomar como punto de partida a los arreglos estáticos. Es así como enesta seccción se descubrirá la forma de operación de tres tipos comúnes de listas conocidas como: PILAS, COLASY DOBLE COLA (STACK, QUEUE, DQUEUE). En programación, el uso de listas es una práctica tan extendidaque lenguajes tales como (por ejemplo) Java, Python y C++ soportan los mecanismos necesarios para trabajar conestructuras de: Vectores, Pilas, Colas, Listas, etc. En C++, los programadores que usen Dev-Cpp (Bloodshed.software -Dev-C++ [2] ) pueden aprovechar las ventajas que ofrecen las STL (Standard TemplatesLibraries) dentro de la cual se pueden encontrar plantillas para la manipulación de listas tales como: Vectores, Listas,Sets, Maps, etc. Por otro lado, los usuarios de Borland C++ ( Turbo C++ version 1.01 [3] ) pueden hacer uso de laCLASSLIB, misma que posee las librerias para los propósitos mencionados.Nota: En las siguientes secciones se presentarán seis programas, tres para simular listas basadas en arreglos estáticosy tres para simular listas por medio de enlaces dinámicos (punteros). En cuanto al material incluido se debe hacer lassiguientes declaraciones:1.1. Puesto que el material es puramente didáctico, cada programa se escribe en un mismo archivo. La idea es no

perder de vista el objetivo. Los entendidos sabrán que normalmente se deben escribir archivos de cabecera,archivos de implementacion y archivos de prueba por separado.

2.2. Para cada una de las clases creadas en los programas se han elegido nombres en ingles. La idea es que gran partede la documentación e implementación referente a listas está en dicho idioma, así, se le da al estudiante la ideabásica de como operar con las librerías soportadas por los compiladores Dev-Cpp, Borlan C++, y otros.

3.3. Igual, se debe observar que los métodos de las clases tienen nombres en ingles, y que con el objetivo deestablecer cierta estandarización todas las clases poseen los mismos métodos, aunque cada una de ellasimplementa los mismos a su manera.

Pilas o StacksUna PILA es una estructuras en donde cada elemento es insertado y retirado

del tope de la misma, y debido a esto el comportamiento de un una pila se

conoce como LIFO (último en entrar, primero en salir ).

Un ejemplo de pila o stack se puede observar en el mismo procesador, es decir, cada vez que en los programasaparece una llamada a una función el microprocesador guarda el estado de ciertos registros en un segmento dememoria conocido como Stack Segment, mismos que serán recuperados al regreso de la función.

mailto:[email protected]

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_C%2B%2B/Punteros

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_C%2B%2B/Plantillas

http://www.bloodshed.net/devcpp.html

http://dn.codegear.com/article/21751


Pila en arreglo estáticoEn el programa que se verá en seguida, se simula el comportamiento de una estructura de pila. Aunque en el mismose usa un arreglo estático de tamaño fijo se debe mencionar que normalmente las implementaciones hechas porfabricantes y/o terceras personas se basan en listas dinámicas o enlazadas.Para la implementación de la clase Stack se han elegido los métodos:

put(), poner un elemento en la pila

get(), retirar un elemento de la pila

empty(), regresa 1 (TRUE) si la pila esta vacia

size(), número de elementos en la pila

El atributo SP de la clase Stack es el puntero de lectura/escritura, es decir, el SP

indica la posición dentro de la pila en donde la función put() insertará el siguiente

dato, y la posición dentro de la pila de donde la función get() leerá el siguiente dato.

Cada vez que put() inserta un elemento el SP se decrementa.

Cada vez que get() retira un elemento el SP se incrementa.

En el siguente ejemplo se analiza lo que sucede con el SP (puntero de pila) cuando se guardan en la pila uno por unolos caracteres 'A', 'B', 'C' y 'D'. Observe que al principio el SP es igual al tamaño de la pila.Llenando la pila.

SP

|

+---+---+---+---+---+

| | | | | | al principio (lista vacia)

+---+---+---+---+---+

SP

|

+---+---+---+---+---+ push('A');

| | | | | A | después de haber agregado el primer elemento

+---+---+---+---+---+

...

SP

|

+---+---+---+---+---+

| | D | C | B | A | después de haber agregado cuatro elementos

+---+---+---+---+---+

Vaciando la pila.

SP

|

+---+---+---+---+---+ pop();

| | D | C | B | A | después de haber retirado un elemento

+---+---+---+---+---+

...


SP

|

+---+---+---+---+---+

| | D | C | B | A | después de haber retirado todos los elementos

+---+---+---+---+---+

Nota: observe que al final la lista está vacia, y que dicho estado se debe a que

el puntero está al final de la pila y no al hecho de borrar físicamente cada elemento

de la pila.

Ejemplo: Pila basada en un arreglo estático

#include <iostream>

using namespace std;

#define STACK_SIZE 256 /* capacidad máxima */

typedef char arreglo[STACK_SIZE];

class Stack {

int sp; /* puntero de lectura/escritura */

int items; /* número de elementos en lista */

int itemsize; /* tamaño del elemento */

arreglo pila; /* el arreglo */

public:

// constructor

Stack() {

sp = STACK_SIZE-1;

items = 0;

itemsize = 1;

}

// destructor

~Stack() {};

/* regresa el número de elementos en lista */

int size() { return items; }

/* regresa 1 si no hay elementos en la lista, o sea, si la lista

está vacia */

int empty() { return items == 0; }

/* insertar elemento a la lista */

int put(char d)

{

if ( sp >= 0) {

pila[sp] = d;

sp --;


items ++;

}

return d;

}

/* retirar elemento de la lista */

int get()

{

if ( ! empty() ) {

sp ++;

items --;

}

return pila[sp];

}

}; // fin de clase Stack

// probando la pila.

// Nota: obseve cómo los elementos se ingresan en orden desde la A

hasta la Z,

// y como los mismos se recuperán en orden inverso.

int main()

{

int d;

Stack s; // s es un objeto (instancia) de la clase Stack

// llenando la pila

for (d='A'; d<='Z'; d++) s.put(d);

cout << "Items =" << s.size() << endl;

// vaciando la pila

while ( s.size() ) cout << (char)s.get() << " ";

cout << "\nPara terminar oprima <Enter>...";

cin.get();

return 0;

}

}

Pila dinámicaEn el siguiente programa se presenta una implementación de una estructura dinámica tipo pila o stack. Es importantehacer notar que, a diferencia de una pila basada en un arreglo estático, una pila enlazadada dinámicamente no poseede forma natural el mecanismo de acceso por índices, en ese sentido, el programador puede crear los algoritmosnecesarios para permitir tal comportamiento. En la clase que presentaremos en el ejemplo no se ha implementado el


mecanismo de acceso por índices, ya que la misma se presenta como una alternativa para la simulación de una pila ostack.Uno de los puntos más destacables en cuando al uso de listas enlazadas dinámicamente es el hecho de crearestructuras conocidas como nodos. Un nodo es una especie de eslabón ( similar al de una cadena de bicicleta ), esdecir, cada nodo se enlaza con otro a través de un puntero que apunta a una estructura del mismo tipo que el nodo.Por ejemplo, para crear una estructura de nodo para almacenar enteros y a la vez para apuntar a otro posible nodopodemos emplear la sintaxis:

struct nodo {

int data;

nodo *siguiente;

};

observe que con la declaración anterior estamos creando el tipo estructurado nodo, mismo que posee a los miembros:data para guardar valores enteros, y siguiente para apuntar o enlazar a un supuesto siguiente nodo.Ya que las listas dinámicas inicialmente se encuentran vacias, y más aún, una lista dinámica no posee una direcciónestablecida en tiempo de compilación ya que las dirección de memoria que ocupará cada uno de los elementos seestablecerá en tiempo de ejecución, entonces cómo determinar la condición de vacio ?. En nuestro ejemplo usaremosun contador ( ITEMS ) que dicho sea de paso, si ITEMS = 0, entonces la lista está vacia. ( la condición de vaciotambién podría determinarse al verificar el SP, es decir, si el SP = NULL, significa que la lista no posee elementos ).Al hacer un análisis previo de los eventos que acontecerán en la pila y su puntero de lectura y escritura (SP, que enesta ocasión es una estructura tipo nodo), se tiene lo siguiente:

1) Al principio la lista está vacia, en ese caso el SP es igual a NULL y, en consecuencia, el puntero nexttambién es NULL.

SP = NULL

+------+------+

| ???? | next |--> NULL

+------+------+

2) Después de agregar el primer elemento la situación se vería así:

SP = asignado

1

+------+------+

| data | next |--> NULL

+------+------+

3) Después de agregar otro elemento la situación se vería así:

SP = asignado

2 1

+------+------+ +------+------+

| data | next |--> | data | next |--> NULL

+------+------+ +------+------+

Ejemplo: Pila basada en un arreglo dinámico

/*---------------------------------------------------------------+

+ ejemplo de una pila ( STACK ) enlazada dinámicamente +


+ +

+ Autor: Oscar E. Palacios +

+ email: [email protected] +

+ +

+ Manifiesto: +

+ Este programa puede distribuirse, copiarse y modificarse de +

+ forma libre. +

+---------------------------------------------------------------*/

#include <iostream>

//#include <conio.h>


/* tipo de dato que contendrá la lista */

typedef char DATA_TYPE;

// declaraci¢n de estructura nodo

struct nodo {

DATA_TYPE data;

nodo *next;

};

class StackDin {

// atributos

int ITEMS; /* número de elementos en la lista */

int ITEMSIZE; /* tamaño de cada elemento */

nodo *SP; /* puntero de lectura/escritura */

public:

// constructor

StackDin() : SP(NULL), ITEMS(0), ITEMSIZE(sizeof(DATA_TYPE)) {}

// destructor

~StackDin() {}

/* agregar componente a la lista */

DATA_TYPE put(DATA_TYPE valor)

{

nodo *temp;

temp = new nodo;

if (temp == NULL) return -1;

temp->data = valor;

temp->next = SP;

SP = temp;


ITEMS ++;

return valor;

}

int empty() { return ITEMS == 0; }


DATA_TYPE get()

{

nodo *temp;

DATA_TYPE d;

if ( empty() ) return -1;

d = SP->data;

temp = SP->next;

if (SP) delete SP;

SP = temp;

ITEMS --;

return d;

}

}; // fin de la clase StackDin

/* punto de prueba para la clase StackDin */

int main()

{

//clrscr();

StackDin s;

DATA_TYPE d;

for (d='A'; d<='Z'; d++) s.put(d);

while ( ! s.empty() )

cout << (DATA_TYPE)s.get() << " ";

cout << "\nPara terminar presione <Enter>...";

cin.get();

return 0;

}


Colas o QueuesUna cola sencilla es una estructura en donde cada elemento es insertado

inmediatamente después del último elemento insertado; y donde los elementos

se retiran siempre por el frente de la misma, debido a esto el comportamiento

de un una cola se conoce como FIFO (primero en entrar, primero en salir).

Un ejemplo a citar de cola es el comportamiento del buffer del teclado.Cuando en el teclado se oprime una tecla, el código del carácter ingresado es trasladado y depositado en una área dememoria intermedia conocida como "el buffer del teclado", para esto el microprocedador llama a una rutinaespecífica. Luego, para leer el carácter depositado en el buffer existe otra función, es decir, hay una rutina paraescribir y otra para leer los caracteres del buffer cada una de las cuales posee un puntero; uno para saber en dondedentro del buffer se escribirá el siguiente código y otro para saber de donde dentro del buffer se leerá el siguientecódigo.

Cola en un arreglo estáticoEn el programa que se ve en seguida, se simula el comportamiento de una estructura de cola simple. Aunque en elmismo se usa un arreglo estático de tamañoo fijo se debe mencionar que normalmente las implementaciones hechaspor fabricantes y/o terceras personas se basan en listas dinámicas o dinamicamente enlazadas.Para la implementación de la clase Queue se han elegido los métodos:

put(), poner un elemento en la cola

get(), retirar un elemento de la cola

empty(), regresa 1 (TRUE) si la cola est vacia

size(), número de elementos en la cola

El atributo cabeza de la clase Queue es el puntero de lectura.

El atributo cola de la clase Queue es el puntero de escritura.

Es decir, la cola indica la posición dentro de la lista en donde la función put() insertará el siguiente dato, y la cabezaindica la posición dentro de la lista de donde la función get() leerá el siguiente dato.

Cada vez que put() inserta un elemento la cola se incrementa.

Cada vez que get() retira un elemento la cabeza se incrementa.

En el siguente ejemplo se analiza lo que sucede con la cola y la cabeza (punteros de escritura y de lectura de la Lista)cuando se guardan en la cola uno por uno los caracteres 'A', 'B', 'C' y 'D'. Observe que al principio: cola = cabeza =cero.Llenando la cola.

cola

|

+---+---+---+---+---+

| | | | | | al principio

+---+---+---+---+---+

|

cabeza

cola

|

+---+---+---+---+---+ put('A');


| A | | | | | después de haber agregado el primer elemento

+---+---+---+---+---+

|

cabeza

...

cola

|

+---+---+---+---+---+

| A | B | C | D | | después de haber agregado cuatro elementos

+---+---+---+---+---+

|

cabeza

Vaciando la cola.

cabeza

|

+---+---+---+---+---+

| A | B | C | D | | antes de haber retirado elementos

+---+---+---+---+---+

cabeza

|

+---+---+---+---+---+ get();

| A | B | C | D | | después de haber retirado un elemento

+---+---+---+---+---+

...

cabeza

|

+---+---+---+---+---+ al final

| A | B | C | D | | después de haber retirado todos los elementos

+---+---+---+---+---+

|

cola

Observese que al final el cabeza apunta hacia el mismo elemento que la cola, es decir, la cola vuelve a estar vacia.Puesto que la cola que estamos proyectando reside en un arreglo estático los componentes del arreglo aún estándentro de la misma, salvo que para su recuperación se debería escribir otro método. En una cola dinámica (como sedemostrará más adelante) los elementos retirados de la misma se eliminan de la memoria y podría no ser posible surecuperación posterior.Nota: En el programa que aparece en seguida, al tipo de lista implementado por la clase Queue se le conoce como"lista circular" debido al comportamiento de sus punteros. Es decir si los métodos para escribir o leer detectan que elpuntero correspondiente ha sobrepasado el tamaño máximo de elementos permitidos dentro de la cola, éste es puestoa cero.Ejemplo: cola en un arreglo estático


/*---------------------------------------------------------------+

+ ejemplo de una cola (QUEUE) basada en un arreglo estático +

+ +



+ +

+ Manifiesto: +


+ forma libre. +

+---------------------------------------------------------------*/

#include <iostream.h>

#define MAX_SIZE 256 /* capacidad máxima */

typedef char almacen[MAX_SIZE];

class Queue {

int cabeza; /* puntero de lectura */

int cola; /* puntero de escritura */

int ITEMS; /* número de elementos en la lista */

int ITEMSIZE; /* tamaño de cada elemento */

almacen alma; /* el almacen */

public:

// constructor

Queue() {

cabeza = 0;

cola = 0;

ITEMS = 0;

ITEMSIZE = 1;

}

// destructor

~Queue() {}

// regresa 1 (true) si la lista está vacia


// insertar elemento a la lista

int put(int d)

{

if ( ITEMS == MAX_SIZE) return -1;

if ( cola >= MAX_SIZE) { cola = 0; }

alma[cola] = d;

cola ++;

ITEMS ++;

return d;


}

// retirar elemento de la lista

int get()

{

char d;


if ( cabeza >= MAX_SIZE ) { cabeza = 0; }

d = alma[cabeza];

cabeza ++;

ITEMS --;

return d;

}

// regresa el n£mero de elementos en lista

int size() { return ITEMS; }

}; // fin de la clase Queue

// probando la cola

int main()

{

int d;

Queue q;

for (d='A'; d<='Z'; d++) q.put(d);

cout << "Items = " << q.size() << endl;

while ( q.size() ) {

cout << (char)q.get() << " ";

}

cout << "\nPara terminar oprima <Enter> ...";

cin .get();

return 0;

}

Ejemplo: cola en un arreglo dinámico

/*---------------------------------------------------------------+

+ ejemplo de una cola (QUEUE) basada en un arreglo dinámico +

+ +



+ +

+ Manifiesto: +



+ forma libre. +

+---------------------------------------------------------------*/

#include <iostream>



struct nodo {

DATA_TYPE data;

nodo *next;

};

class QueueDin {

// atributos

int ITEMS, ITEMSIZE;

nodo *cola, *cabeza;

public:

// constructor

QueueDin() : cola(NULL), cabeza(NULL), ITEMS(0),

ITEMSIZE(sizeof(DATA_TYPE)) {}

// destructor

~QueueDin() {}

/* agregar componente a la lista */

DATA_TYPE put(DATA_TYPE valor)

{

nodo *temp;

temp = new nodo;


ITEMS ++;

temp->data = valor;

temp->next = NULL;

if (cabeza == NULL)

{

cabeza = temp;

cola = temp;

} else

{

cola->next = temp;


cola = temp;

}

return valor;

}

// regresa 1 (true) si la lista está vacia



DATA_TYPE get()

{

nodo *temp;

DATA_TYPE d;


d = cabeza->data;

temp = cabeza->next;

if (cabeza) delete cabeza;

cabeza = temp;

ITEMS --;

return d;

}

}; // fin de la clase QueueDin

/* punto de prueba */

int main()

{

QueueDin s;

DATA_TYPE d;

// llenando la cola

for (d='A'; d<='Z'; d++) {

s.put(d);

cout << d << " ";

}

cout << endl;

// vaciando la cola


cout << (DATA_TYPE)s.get() << " ";


cin.get();

return 0;


}

Colas de doble enlaceUna cola doble es una estructuras en donde cada elemento puede ser insertado y

recuperado por la parte del frente (cabeza) o por la parte de atras (cola) de la

lista. A diferencia de una cola sencilla, en donde solo se necesitan un método para

leer y otro para escribir componentes en la lista, en una doble cola debe haber dos

métodos para leer ( uno para leer por el frente y uno para leer por atras ) y dos

métodos para escribir ( uno para escribir por el frente y uno para escribir por atras ).

En el programa que se verá en seguida, se simula el comportamiento de una estructura de cola doble con base en unarreglo estático. En dicho programa se declara e implementa la clase SDQueue con los siguientes métodos:

put_front(), poner un elemento en el frente de la cola

put_back(), poner un elemento en la parte tracera de la cola

get_front(), retirar un elemento de la parte frontal de la cola

get_back(), retirar un elemento de la parte tracera de la cola


size(), número de elementos en la cola

Nota: observe que para los métodos put_front() y get_front() se hace uso de la función memmove(), esto es necesariodebido al hecho de que put_front() tiene que mover una posición hacia atras todos los elementos en la lista antes deinsertar el componente indicado; por otro lado, la función get_front() tiene que mover una posición hacia adelante atodos los elementos que le siguen al primer elemento.Ejemplo: doble cola en un arreglo estático

/*------------------------------------------------------------------+

+ ejemplo de una cola doble (DQUEUE) basada en un arreglo est tico +

+ +



+ +

+ Manifiesto: +


+ forma libre. +

+------------------------------------------------------------------*/


#include <mem.h> // por memmove

// using namespace std;

#define MAX_SIZE 256

#define t_error -1;

typedef int DATA_TYPE; // máximo número de elementos

typedef int almacen[MAX_SIZE];

class SDQueue {

// atributos

int itemsize; // tamaño de cada elemento


int items; // número de elementos

int cola, cabeza; // punteros de lectura y escritura

almacen alma; // el almacen o arreglo

public:

// constructor

SDQueue() : cola(0), cabeza(0), items(0),

itemsize(sizeof(DATA_TYPE)) {}

// destructor

~SDQueue() {}


int size() { return items; }

/* agregar componente en la parte tracera de la lista */

DATA_TYPE put_back(DATA_TYPE valor)

{

if (items == MAX_SIZE) return t_error;

alma[cola] = valor;

items ++;

cola ++;

return valor;

}

/* agregar componente en la parte delantera de la lista */

DATA_TYPE put_front(DATA_TYPE valor)

{

if (items == MAX_SIZE) return t_error;

memmove((void *)&alma[cabeza+1], (void*)&alma[cabeza],

items*itemsize);

alma[cabeza] = valor;

items ++;

cola ++;

return valor;

}

/* retirar elemento de la parte frontal de la lista */

DATA_TYPE get_front()

{

DATA_TYPE d;

if ( empty() ) return t_error;

items --;

cola --;


d = alma[cabeza];

memmove((void*)&alma[cabeza], (void*)&alma[cabeza+1],

items*itemsize);

return d;

}

/* retirar elemento de la parte tracera de la lista */

DATA_TYPE get_back()

{

DATA_TYPE d;

if ( empty() ) return t_error;

items--;

cola --;

d = alma[cola];

return d;

}

}; // fin de la clase SDQueue


int main()

{

SDQueue s;

DATA_TYPE d;

for (d='A'; d<='Z'; d++) s.put_back(d);


cout << (char)s.get_front() << " ";


cin.get();

return 0;

}

Una cola doblemente encadenada es una estructuras en donde cada elemento puede ser insertado y recuperado por laparte del frente (cabeza) o por la parte de atras (cola) de la lista. A diferencia de una cola sencilla, en donde solo senecesita un puntero a un siguiente elemento, la estructura del nodo para una doble cola debe poseer un puntero a unposible siguiente elemento y un puntero a otro posible anterior elemento. Por ejemplo, para crear una estructura denodo con doble enlace para coleccionar números enteros podemos usar la sintaxis:

struct nodo {

int data;

nodo *next, *prev;

};

Gráficamente podemos imaginar la estructura anterior como:


+------+------+------+

<--| prev | data | next |-->

+------+------+------+

En el programa que se verá en seguida, se simula el comportamiento de una estructura de cola de doble enlace. Parala implementación de la clase DDqueue en el programa se han elegido los métodos:

put_front(), poner un elemento en el frente de la cola

put_back(), poner un elemento en la parte tracera de la cola

get_front(), retirar un elemento de la parte frontal de la cola

get_back(), retirar un elemento de la parte tracera de la cola


size(), n£mero de elementos en la cola

/*---------------------------------------------------------------+

+ ejemplo de una cola doblemente enlazada (Dqueue) basada en un +

+ arreglo dinámico +

+ +



+ +

+ Manifiesto: +


+ forma libre. +

+---------------------------------------------------------------*/


#include <conio.h>

// using namespace std;


struct nodo {

DATA_TYPE data;

nodo *next, *prev;

};

class DDqueue {

int itemsize, items;

nodo *cola, *cabeza;

public:

// constructor

DDqueue() : cola(NULL), cabeza(NULL), items(0),

itemsize(sizeof(DATA_TYPE)) {}


// destructor

~DDqueue() {}

/* agregar componente en la parte tracera de la lista */

DATA_TYPE put_back(DATA_TYPE valor)

{

nodo *temp;

temp = new nodo;


temp->data = valor;

items ++;

if (cabeza == NULL )

{

temp->next = NULL;

temp->prev = NULL;

cabeza = temp;

cola = temp;

} else

{

cola->next = temp;

temp->prev = cola;

cola = temp;

cola->next = NULL;

}

return valor;

}

/* agregar componente en la parte frontal de la lista */

DATA_TYPE put_front(DATA_TYPE valor)

{

nodo *temp;

temp = new nodo;


temp->data = valor;

items ++;

if (cabeza == NULL )

{

temp->next = NULL;

temp->prev = NULL;

cabeza = temp;


cola = temp;

} else

{

cabeza->prev = temp;

temp->next = cabeza;

cabeza = temp;

cabeza->prev = NULL;

}

return valor;

}

// regresa true si la lista está vacia


/* retirar elemento de la parte frontal lista */

DATA_TYPE get_front()

{

nodo *temp;

DATA_TYPE d;


items --;

d = cabeza->data;

temp = cabeza->next;

if (cabeza) delete cabeza;

cabeza = temp;

return d;

}

/* retirar elemento de la parte tracera de la lista */

DATA_TYPE get_back()

{

nodo *temp;

DATA_TYPE d;


items--;

d = cola->data;

temp = cola->prev;

if (cola) delete cola;

cola = temp;

return d;

}


}; // fin de la clase DDqueue


int main()

{

clrscr();

DDqueue s;

DATA_TYPE d;

// insertando elementos en la parte tracera

for (d='A'; d<='Z'; d++) s.put_back(d);

// insertando en la parte delantera

for (d=9; d>=0; d--)s.put_front(d+'0');

// vaciando la lista


cout << (DATA_TYPE)s.get_front() << " ";


cin.get();

return 0;

}

← Punteros Arriba Plantillas →

Referencias[1] mailto:oscarpalacios1@yahoo. com. mx[2] http:/ / www. bloodshed. net/ devcpp. html[3] http:/ / dn. codegear. com/ article/ 21751

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_C%2B%2B/Punteros

http://es.wikibooks.org/w/index.php?title=Programaci%C3%B3n_en_C%2B%2B/Plantillas

mailto:[email protected]

http://www.bloodshed.net/devcpp.html

http://dn.codegear.com/article/21751

Fuentes y contribuyentes del artículo 21

Fuentes y contribuyentes del artículoProgramación en C++/Estructuras II Fuente: http://es.wikibooks.org/w/index.php?oldid=202894 Contribuyentes: El lobo, MarcoAurelio, Morza, 9 ediciones anónimas

LicenciaCreative Commons Attribution-Share Alike 3.0//creativecommons.org/licenses/by-sa/3.0/

Ejemplos Pila y Cola Con Poo

Documents

Transcript of Ejemplos Pila y Cola Con Poo