En programación, las pilas o Stacks son uno de los varios tipos de estructuras de datos. En C# están definidas en el namespace System.Collections.

Para entender una pila te pongo el ejemplo:

Los platos de un estante de la cocina: conforme vas poniendo los platos los vas apilando cierto? y cuando quieras usar alguno, cuál usarías? el que está abajo o el que está encima de todos?

La respuesta es lógica, sacas el de más arriba (y el último que pusiste en la pila), así mismo es en las pilas, por eso a este comportamiento se le conoce con el acrónimo LIFO Last in first out, el último en entrar es el primero en salir.

Operaciones básicas

Tenemos 3:

• Push: Apila un elemento a la pila, es decir agrega un item como si añadiéramos un plato a una pila de platos en una cocina.
• Pop: Desapila un elemento, y como hablamos de pilas, será el último elemento apilado así como cuando uno toma el plato que está encima de una pila de platos en una cocina. Ten en cuenta que un elemento desapilado ya no forma parte de la pila.
• Peek: Nos da el primer elemento de la pila pero no lo desapila, es decir sigue siendo parte de la pila.

En esta entrada anterior hablé sobre estas operaciones, échale un vistaso capo. En esa entrada mostré una imagen que resumen muy bien estas operaciones básicas:

Caso práctico

Siempre digo que este blog es práctico, es brutalmente pragmático, así que veamos un uso real de una pila, lo haremos resolviendo un algoritmo:

Dada una cadena se nos pide darle la vuelta.

Veamos cómo resolveríamos este algoritmo mediante pilas en C#, daremos la vuelta a la siguiente cadena: "hola como va todo cracks!".

using System;
using System.Collections;

class MainClass {
  static void Main() {  
    //Llamo el método desde el main
    Console.WriteLine(StringReverse("hola como va todo cracks!"));
  } 
  public static string StringReverse(string cadena) {
    string response = "";
    char[] caracteres = cadena.ToCharArray(); //convertimos la cadena a un array de caracteres

    Stack miPila = new Stack();//declaro la pila

    foreach(var item in caracteres){
      miPila.Push(item);//voy apilando los caracteres de la cadena
    }

    while(miPila.Count > 0){ //itero hasta vacear la pila
      response += miPila.Pop();  //voy desapilando los caracteres y los concateno
      //también podríamos haber hecho un peek pero luego un pop
    }    
    return response;
  }
}

El resultado es el siguiente:

Nota entonces cómo es que utilizamos las pilas y sus operaciones básicas.

También podemos crear pilas indicándole el tipo de dato ya sea primitivo como entero, double, string o complejo como veremos con el ejemplo a continuacion.

Con el siguiente código podrás ver un poco de esto y hacer pruebas:

Primero creo una clase llamada Alumno:

    public class Alumno
    {
        public int Id { get; set; }
        public string Nombre { get; set; }
        public int Edad { get; set; }
    }

Hacemos pruebas con una pila que utiliza ese tipo complejo:

Stack<Alumno> pila = new Stack<Alumno>();
pila.Push(new Alumno { Id = 1, Nombre = "Gerson", Edad = 32 }); //apilamos elementos
pila.Push(new Alumno { Id = 2, Nombre = "Eder", Edad = 42 });
pila.Push(new Alumno { Id = 3, Nombre = "Rosa", Edad = 12 });

Console.WriteLine(pila.Count);//3-> Muestra el número de elementos de la pila           
Console.WriteLine(pila.Peek().Nombre);//Rosa -> Muestra el primero de la pila
Console.WriteLine(pila.Pop().Nombre);//Rosa -> Muestra el primero y borra
Console.WriteLine(pila.Peek().Nombre);//Eder -> Ahora el primero es Eder
Console.WriteLine(pila.Count);//2-> Ahora hay dos 

Y eso es todo por ahora estimados cracks! En posteriores posts veremos las otras dos estructuras importantísimas en C#: las colas y los diccionarios.

Si esta entrada te ha encantado, compártela ps crack! 😎