Esta estructura es bastante usada para simular métodos recursivos y resolver algunos tipos de problemas. Esto viene simulando como un montón de objetos que se van apilando (uno encima de otro). La filosofía de una pila (stack) es “El último que entra es el primero que sale”. Pueden ver un poco más de que se trata en la figura. Es importante también señalar que esta clase implementa la interfaz IEnumerable.

Una pila tiene un constructor con tres sobre cargas:

Contructor por defecto que crea una pila vacía

Stack s = new Stack();

Podemos indicar la cantidad inicial de elementos que tendrá la pila

Stack s = new Stack(int initialCapacity);

Podemos también pasarle una colección de elementos (List, Quee, ArrayList). Este constructor copiará todos estos elementos a la pila iniciará

Stack s = new Stack(ICollection col);

Además de los métodos de la interfaz ICollection (Contains, Remove, GetEnumerator, etc), encontramos básicamente 3 métodos que explico ahora:

public object Peek()
//Retorna el último elemento que se agregó en la pila.
 
public object Pop()
// Retorna el último elemento de la pila al igual que Peek(), pero elimina dicho elemento de la pila una vez devuelto.
 
public void Push(object x)
//Agrega un nuevo elemento a la pila

Ahora veamos la implementación de la clase Pila (Stack) de CSharp:

public class Pila: IEnumerable
{
    Node primero;
    int cambios;
    int contador
 
    //El constructor
    public Pila()
    {
        contador=0;
        cambios=0;
    }
 
public object Peek()
{
     if(count<=0)
         throw new InvalidOperationException("La pila esta vacia");
     return primero.value;
}
 
public object Pop()
{
     object temp=primero.value;
     primero=primero.next;
     contador--;
     cambios++;
     return temp;
}
 
public void Push(object x)
{
    if(primero==null)
        primero= new Node(x);
    else
    {
        primero=new Node(x,primero);
        cambios++;
        contador++;
    }
}
 
public int Count
{
    get{
       return contador;
   }
}
 
public bool Contiene(object x)
{
    Node temp= primero;
    for(int i=0; i<contador;i++)
    {
       if(temp.value.Equals(x))
          return true;
       temp=temp.next;
    }
    return false;
}
}

Por supuesto, le faltan algunos métodos de la interfaz ICollection, pero esos ya los vimos cuando hablamos de  la clase LinkedNode en C# y la Interfaz Ilist.

También implementé esta clase usando nodos enlazables, pero por supuesto sería mucho más sencillo con arrays o listas…

Si tienen alguna duda o creen que falta algo, ya saben, comenten…

Proximamente hablaremos de otras dos estructuras (colas, lista generica) y de genericidad.