ITEC “Fe y Alegría” Estructuras de Datos Lic.
Freddy Ruíz Ucumari
CAPÍTULO 6
ESTRUCTURA DINÁMICA DE DATOS PILA O STACK
1. INTRODUCCIÓN.
Hasta ahora hemos empleado diferentes tipos de datos como int, float, char, etc. y agrupaciones de
estos como struct, array de estructuras, etc. Sin embargo, pese a su utilidad presentan un problema,
deben ser declarados con anticipación y con un tamaño fijo.
Si declaramos un array como float sueldo[100]; estamos reservando 100 espacios de memoria de
100*4 = 400 bytes de memoria. Pero si solo utilizamos 10 elementos, estaríamos desaprovechando
90 elementos, esto es, 360 bytes.
Una de las aplicaciones más interesantes de la administración de memoria y los punteros son las
estructuras dinámicas de datos. Las estructuras básicas disponibles en C y C++ tienen una
limitación: no se pueden cambiar de tamaño durante la ejecución del programa; así, los arrays están
compuestos por un número determinado de elementos, que se decide en la fase de diseño, antes de
que el programa ejecutable sea creado.
En muchas ocasiones se necesitan estructuras que puedan cambiar de tamaño durante la ejecución
del programa, esto se logra a través de las estructuras dinámicas de datos.
2. ESTRUCTURAS DINÁMICAS DE DATOS.
Las estructuras dinámicas de datos permiten crear estructuras de datos flexibles que se adapten a las
necesidades de la vida real.
Las estructuras dinámicas de datos permiten implementar programas flexibles en la memoria del
ordenador durante la ejecución del programa, permitiendo que se puedan aumentar o disminuir,
eliminar o insertar nuevos elementos. Esto se constituye en una ventaja respecto a las estructuras
estáticas, como los arrays o registros, para los cuales se fija una memoria estática por anticipado;
entre tanto, en las estructuras dinámicas no se fija una cantidad de memoria por anticipado, sino lo
hacen progresivamente cuando es necesario.
Las estructuras dinámicas de datos están compuestas por otras pequeñas estructuras denominadas
nodos o elementos que agrupan los datos y además de uno o más punteros que tienen la finalidad
de apuntar a objetos del mismo tipo.
Entre las estructuras de datos dinámicas se puede mencionar a las siguientes: Listas, pilas, Colas,
Árboles y Grafos. Para el tratamiento de este tipo de estructuras es imprescindible manejar
correctamente el uso de los punteros.
3. PUNTEROS.
Un puntero es un identificador que contiene una dirección de memoria que corresponde a un dato o a
una variable que contiene al dato. Los punteros se fundamentan en las siguientes reglas:
Un puntero es una variable como cualquier otra.
Una variable puntero contiene una dirección que apunta a otra posición de memoria.
En ésa posición se almacenan los datos a los que apunta el puntero.
Un puntero apunta a una variable de memoria.
Carrera: Sistemas Informáticos Pá gina 1
ITEC “Fe y Alegría” Estructuras de Datos Lic.
Freddy Ruíz Ucumari
En C++ existen dos operadores punteros, & y *, cuya diferencia es:
El operador de dirección & devuelve como resultado la dirección de su operando.
El operador de indirección * toma su operando como una dirección y devuelve como
resultado su contenido.
Los punteros se utilizan en la transferencia de información por referencia entre funciones, también
para el tratamiento de estructuras de datos y para la creación dinámica de memoria. Un puntero se
crea declarando un identificador precedido por el operador * que significa “puntero a” que apunta a
un objeto de cualquier tipo. Su sintaxis es:
tipo_dato * Var_Puntero;
Donde:
tipo_dato Específica el tipo de dato del objeto apuntado, puede ser predefinido o definido por el
programador.
Var_Puntero Es un identificador elegido por el programador.
Ejemplo:
int * p; // p es un “puntero a” un objeto del tipo entero, int.
float * f: // f es un “puntero a “ un objeto del tipo float.
char * cad; // cad es un “puntero a” un objeto del tipo char.
En las estructuras dinámicas de datos es importante interpretar el concepto de puntero sobre
puntero, la relación con un array, puntero a una función y la creación de memoria dinámica.
En el lenguaje C y C++ es posible declarar variables punteros precedida por ** ó ***. Para
comprender la interpretación es necesario considerar el siguiente ejemplo:
Ejemplo:
float x, *y, **z;
int px, *py, ***pu;
Ejemplo: Programa C++ que muestra el uso de punteros.
void main(){
int n = 125;
int *p = &n; // p contiene la dirección de n
cout << “n = ” << n << endl; // imprime n = 125
cout << “&n = ” <<hex<< &n << endl; // imprime &n = 0x4fffd34
cout << “p = ” << hex<<p << endl; // imprime p = 0x4fffd34
cout << “&p = ” << hex<<&p << endl; // imprime &p = 0x4fffd30
cout << “*p = ” << *p << endl; // imprime *p = 125
getch();
}
Carrera: Sistemas Informáticos Pá gina 2
ITEC “Fe y Alegría” Estructuras de Datos Lic.
Freddy Ruíz Ucumari
La variable p se denomina puntero debido a que su valor “apunta” a la posición de otro valor. El valor
del puntero es una dirección.
4. LA ESTRUCTURA PILA O STACK.
Una pila es una colección ordenada de elementos en la que pueden insertarse y suprimirse por un
extremo, llamado tope, nuevos elementos. Una pila es una lista lineal, que tiene un comportamiento
especial durante la inserción y eliminación de los elementos. Gráficamente, una pila se puede
representar de la siguiente manera:
E tope de la pila
D
C
B
A
A diferencia del arreglo, la definición de pila incorpora la inserción y la supresión de elementos, de tal
manera que esta es un objeto dinámico, constantemente variable.
Le idea de organizar la información en forma de una pila es rescatada de los problemas donde el
hombre se enfrenta en su vida cotidiana; así por ejemplo, se tienen una pila de platos, pila de
monedas, pila de camisas, etc. En estos ejemplos, el añadir o quitar se hace siempre por la parte
superior de la pila llamada tope. Otro ejemplo de pila o stack se puede observar en el mismo
procesador, es decir, cada vez que en los programas aparece una llamada a una función el
microprocesador guarda el estado de ciertos registros en un segmento de memoria conocido como
Stack Segment, mismos que serán recuperados al regreso de la función.
Las pilas se conocen también con el nombre de LIFO, last in, first out, traducido como últimos en
entrar y primeros en salir.
5. OPERACIONES CON PILAS.
Una pila se puede representar como un arreglo dinámico. En este contexto las operaciones básicas
que se pueden implementar en la clase stack, son:
1. OPERACIÓN DE INSERCIÓN, push() o put()
La inserción se denomina también push(), que significa insertar o introducir elementos. Después de
crear el primer nodo, se realiza siempre en el tope de la lista enlazada. Esta operación podemos
representar como:
q -> sigte = p;
p = q;
2. SUPRIMIR UN ELEMENTO DE LA PILA, pop() ó get()
La eliminación se denomina también pop(), que significa eliminar el último elemento de la pila. Para
realizar esta operación, es necesario tener un puntero en el tope de la pila (último elemento), se debe
controlar la operación de pila vacía (pila sin elementos). El nodo a ser eliminado es el de la derecha o
tope de la pila, para ello se debe emplear un puntero auxiliar en el nodo, mover el puntero al siguiente
nodo y eliminar el nodo apuntado por el puntero auxiliar. Esta operación se puede representar como:
q = p; // puntero auxiliar
Carrera: Sistemas Informáticos Pá gina 3
ITEC “Fe y Alegría” Estructuras de Datos Lic.
Freddy Ruíz Ucumari
p = p->sigte;
free(q); // eliminación del nodo q
La pila vacía se representa por la función empty(), regresa 1 (TRUE) si la pila esta vacia
La función size(), devuelve el número de elementos en la pila
En el programa que se verá en seguida, se simula el comportamiento de una estructura de pila.
Aunque en el mismo se usa un arreglo estático de tamaño fijo se debe mencionar que normalmente
las implementaciones hechas por fabricantes y/o terceras personas se basan en listas dinámicas o
enlazadas.
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 siguiente esquema se analiza lo que sucede con el SP (puntero de pila) cuando se guardan en
la pila uno por uno los 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 vacía
+---+---+---+---+---+
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();
| | |C|B|A| después de haber retirado un elemento
+---+---+---+---+---+
...
SP
|
+---+---+---+---+---+
Carrera: Sistemas Informáticos Pá gina 4
ITEC “Fe y Alegría” Estructuras de Datos Lic.
Freddy Ruíz Ucumari
| | | | | | después de haber retirado todos los elementos
+---+---+---+---+---+
Nota: observe que al final la lista está vacía, 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 DE APLICACIÓN: Escribir programa aplicando la estructura 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];
Carrera: Sistemas Informáticos Pá gina 5
ITEC “Fe y Alegría” Estructuras de Datos Lic.
Freddy Ruíz Ucumari
}
}; // fin de clase Stack
// Nota: observe cómo los elementos se ingresan en orden desde la A hasta la Z,
// y como los mismos se recuperan 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;
}
}
BIBLIOGRAFÍA.
1. ANCE Samuel Oña – “Programación en C y Orientado a objetos en C++ - Teoría y problemas
resueltos y propuestos”, Universidad Autónoma “Tomás Frías”, 2ª Edición, Potosí – Bolivia, 2004.
2. ANCE Samuel – Díaz Jorge, “Programación Orientada a Objetos con C++”, Universidad
Autónoma “Tomás Frías”, 2ª Edición, Potosí – Bolivia, 2004.
3. AARON M. Tenenbaum et.al., “Estructuras de Datos en C”, Editorial Prentice Hall, México, 1993
4. CAIRO Osvaldo et.al., “Estructura de Datos”, Editorial McGrawHill, México, 3ª Edición, 2006.
5. JOYANES Aguilar Luis, “Estructuras de datos en C++”, Editorial McGrawHill, 1ª Edición, 2007.
6. TANENBAUM Aaron – Yedidyah Langsam, “Estructuras de datos en C++”, Editorial Prentice
Hall, Primera Edición, México, 1993.
7. RUIZ Ucumari Freddy, Texto Guía Elaborado por el docente.
Carrera: Sistemas Informáticos Pá gina 6
