ESTRUCTURA DE DATOS: PILA

DEFINICION: Lista de elementos a la cual se puede insertar o eliminar elementos por uno de sus
extremos, llamado la parte superior de la pila.

CARACTERISTICAS:

 Los elementos de una pila serán eliminados en orden inverso al que se insertaron.
 A esta estructura se le conoce como estructura LIFO (Last In, First Out), es decir el primero
que entra, el último que sale o el último que entra es el primero que sale.

Como se pueden representar:

 Pueden representarse mediante el uso de:

 Arreglos y registros
 Listas enlazadas
 Colecciones

Pilas utilizando como estructura de datos arreglos y registros:

class Pila
{
public int cima;
public int[] elem;
}

Operaciones básicas con pilas

 Inicializar la pila
 Verificar si la pila está vacía
 Verificar si la pila está llena
 Insertar un elemento en la pila (PUSH)
 Eliminar un elemento de la pila (POP)

Algoritmos

Push(pila, valor)
Inicio
si pila.cima < Max-1 entonces
inc(pila.cima)
pila.elem[pila.cima] ← valor
sino
escribir “Desbordamiento”
finsi
Fin

1
Pop(pila, valor)
Inicio
si pila.cima != -1 entonces
valor ← pila.elem[pila.cima]
dec(pila.cima)
sino
escribir “Bajo flujo”
finsi
Fin

Inicializar_pila(pila *p)
Inicio
p->cima = -1;
return;
Fin

Pila_vacia(pila p)
Inicio
If (p.cima == -1)
return(1);
else
return(0);
Fin

Pila_llena(pila p)
Inicio
if (p.cima == MAX-1)
return(1);
else
return(0);
Fin

Pilas utilizando como estructura de datos las colecciones:

Anteriormente hemos estudiado como utilizar los arreglos para referenciar un conjunto de datos, es
evidente, sin embargo que los arreglos tienen algunas limitaciones. La mayor de ellas es que una vez
que se ha creado el arreglo, su tamaño no se puede cambiar debido a que la estructura es estática.
El problema se presenta cuando se pretende añadir nuevos elementos al arreglo, sin crear uno nuevo.

En general, se puede decir que una colección se utiliza para trabajar con listas o conjuntos ordenados
de objetos y proporciona una funcionalidad mayor que la de un simple arreglo. Esta funcionalidad
proviene de la implementación de una serie de interfaces del namespace System.Collections. Este
namespace también contiene clases que implementan estas interfaces y facilitan enormemente la
tarea del programador.

Las colecciones proporcionan métodos básicos para acceder a los elementos de la colección utilizando
corchetes, de manera idéntica a como se accede a los elementos de un arreglo.

2
COLECCIÓN STACK O PILA:

Nos permite guardar elementos y cambia su tamaño de forma dinámica, sin embargo trabaja en forma
diferente al arreglo y al ArrayList.
Para entender su funcionamiento podemos imaginar una pila de platos. El primer plato que colocamos
queda hasta la base, el siguiente se colocará encima y así sucesivamente. Como el primer plato queda
hasta abajo, no lo podemos sacar directamente pues la pila se derrumbaría. Al sacar los platos,
debemos tomar el que se encuentre hasta arriba de la pila primero y así continuar.

LA CAPACIDAD DEL STACK

El Stack tiene una capacidad y ésta crece dinámicamente. Cuando instanciamos el Stack adquiere la
capacidad de default. Si necesitamos crear un Stack con determinada capacidad, la forma de hacerlo
es colocando el valor de capacidad entre los paréntesis del constructor al momento de instanciarlo.

El efecto de colocar nuevos elementos en la parte superior del Stack se conoce como Push. Esto se
muestra en la siguiente figura:

Cuando tomamos un elemento de la parte superior del Stack se conoce como Pop. En la figura
podemos observar cómo esto sucede.

Debido a este comportamiento con Push y Pop podemos entender cómo el primer objeto que se coloca
adentro del Stack es el último en poder salir.

3
Como crear el Stack

Como cualquier otra colección el Stack necesita ser instanciado para poderlo utilizar. C# nos provee
de la clase Stack y adentro de esta clase encontramos todos los métodos necesarios para trabajar con
él. La instanciación simplemente será la creación de un objeto de esta clase. Si deseamos crear un
Stack hacemos lo siguiente:

Stack miPila = new Stack();

Hemos creado un Stack llamado miPila. Nosotros podemos usar cualquier nombre que sea válido.
Una vez instanciado podemos empezar a colocar información en él.

Cómo introducir información al Stack

Para introducir información al Stack usamos el método Push(). Este método coloca el nuevo elemento
en la parte superior del Stack. El método necesita únicamente de un parámetro que es el elemento
que deseamos insertar. Podemos utilizar el método Push() cuantas veces sea necesario para colocar
la información.

miPila.Push(7);
miPila.Push(11);
miPila.Push(8);

En este ejemplo se introduce primero el elemento 7 y luego sobre él se coloca el elemento 11. En
seguida se coloca un nuevo elemento en la parte superior, que en este caso es 8. El Stack resultante
se muestra en la siguiente figura:

Cómo obtener información del Stack

Si lo que necesitamos es obtener la información que está contenida en el Stack lo podemos hacer al
tomar el elemento que se encuentra en la parte superior del Stack. Para lograr esto hacemos uso del
método Pop(). Este método no necesita ningún parámetro y regresa el elemento correspondiente.
Por ejemplo, si deseamos tomar el elemento de nuestro Stack:

int valor = 0;
…
valor = (int)miPila.Pop();

Siguiendo el ejemplo anterior la variable valor ahora tendrá en su interior 8. Esto lo vemos en la
siguiente figura:

4
Uso de foreach para recorrer el Stack

Si necesitamos recorrer el Stack, es posible hacerlo por medio del uso de foreach. Cuando recorremos
el Stack con foreach la estructura no modifica los valores guardados en la pila.

foreach( int n in miPila)

Console.WriteLine(“{0}”,n);

Para obtener la cantidad de elementos del Stack

Es posible conocer la cantidad de elementos que tiene el Stack y hacerlo es muy sencillo.
Debemos leer la propiedad Count del Stack. Esta propiedad nos regresa un valor entero con la
cantidad de elementos.

cantidad = miPila.Count;

OTRA FORMA DE TOMAR EL ELEMENTO

El método Pop() tomó el elemento que se encuentra en la parte superior del Stack y lo regresa al
exterior, pero el elemento ya no pertenece al Stack. Hay otro método conocido como Peek() que lee
el valor del elemento en la parte superior del Stack y lo regresa al exterior, pero no elimina el elemento
del Stack.

Para limpiar el contenido del Stack

Si deseamos eliminar todos los elementos del Stack de forma rápida lo podemos hacer al usar el
método Clear(). Este método no necesita de ningún parámetro y solamente debe ser usado cuando
sepamos que debemos borrar los elementos del Stack.

miPila.Clear();

5
Para saber si el Stack tiene un elemento

Si deseamos saber si dentro del Stack se encuentra un elemento en particular, podemos hacer uso
del método Contains(). Este método necesita de un parámetro que es el objeto a encontrar adentro
del Stack. El método regresa un valor de tipo bool. Si el objeto se encuentra el valor es true, pero si
no se encuentra es false.

bool enStack = false;

…
enStack = miPila.Contains(7);

Creación de una aplicación

Podemos hacer un programa que muestre como usar los métodos del Stack. Para esto crearemos
una aplicación que presente las operaciones del Stack. El contenido se mostrará para ver los
cambios que se tienen debidos al Push y al Pop.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;

namespace PILAS_EJEMPLO1
{
class Program
{
static void Insertar(Stack miPila)
{
int valor;
// Pedimos el valor a introducir
Console.WriteLine("De el valor a introducir ");
valor = int.Parse(Console.ReadLine());
// Adicionamos el valor en el stack
miPila.Push(valor);
}

static void Eliminar(Stack miPila)

{
int valor;
// Obtenemos el elemento
valor = (int)miPila.Pop();
// Mostramos el elemento
Console.WriteLine("El valor obtenido es: {0}", valor);
Console.ReadKey();
}

static void EliminarTodo(Stack miPila)

{
// Eliminamos todos los contenidos del stack
miPila.Clear();
Console.WriteLine("La pila se encuentra totalmente vacía ");
Console.ReadKey();
}

6
static void Encontrar(Stack miPila)
{
int valor;
bool encontrado = false;
// Pedimos el valor a encontrar
Console.WriteLine("De el valor a encontrar ");
valor = int.Parse(Console.ReadLine());
// Vemos si el elemento esta
encontrado = miPila.Contains(valor);
// Mostramos el resultado
if (encontrado)
Console.WriteLine("El valor {0} se encuentra en la pila", valor);
else
Console.WriteLine("El valor {0} NO se encuentra en la pila", valor);
Console.ReadKey();
}

static void Imprimir(Stack miPila)

{
Console.WriteLine("\n \n LOS ELEMENTOS CONTENIDOS EN LA PILA SON: \n\n");
foreach (int n in miPila)
Console.Write(" {0}, ", n);
Console.WriteLine("");
Console.WriteLine("————");
Console.ReadKey();
}

static void Main(string[] args)

{
// Variables necesarias
int opcion = 0;

// Creamos el stack
Stack miPila = new Stack();

// Mostramos menu
do
{
Console.WriteLine(" \n\n"); Console.WriteLine(" \n\n");
Console.WriteLine(" MENU DE OPCIONES");
Console.WriteLine(" \n\n");
Console.WriteLine(" 1: INSERTAR UN VALOR EN LA PILA - PUSH ");
Console.WriteLine(" 2: ELIMINAR UN VALOR DE LA PILA - POP ");
Console.WriteLine(" 3: ELIMINAR TODOS LOS VALORES DE LA PILA - CLEAR ");
Console.WriteLine(" 4: DETERMINAR SI UN VALOR ESTA CONTENIDO EN UNA PILA - CONTAINS ");
Console.WriteLine(" 5: DETERMINAR LA CANTIDAD DE ELEMENTOS DE LA PILA - COUNT ");
Console.WriteLine(" 6: IMPRIMIR EL CONTENIDO DE LA PILA ");
Console.WriteLine(" 7: SALIR ");
Console.Write(" ESCOJA UNA OPCION :");
opcion = int.Parse(Console.ReadLine());
switch (opcion)
{
case 1: Insertar(miPila);
break;
case 2: Eliminar(miPila);
break;
case 3: EliminarTodo(miPila);
break;
case 4: Encontrar(miPila);

7
 break;
case 5: // Mostramos la información del stack
Console.WriteLine("El stack tiene {0} elementos", miPila.Count);
Console.ReadKey();
break;
case 6: Imprimir(miPila);
break;
default:
Console.WriteLine("Se ingreso un valor fuera de rango");
break;
}
}
while (opcion != 7);
}
}
}