EdD - Clase Stack (desarrollada en teoría)

Este post es para facilitar a los estudiantes la implementación desarrollada en las clases teóricas. Como dije en las publicaciones o guias de teoría, se puede y en general se debe utilizar las implementaciones que los lenguajes de programación nos facilitan dado que ellas estan "probadas"; sin embargo es posible que se necesite una implementación propia en cuyo caso es bueno contar con el código de una implementación completa.

De acuerdo a los conceptos teóricos de la asignatura, este tipo de dato abstracto se puede clasificar como una lista lineal, abierta, de acceso restringido, con almacenamiento secuencial.

El diagrama de la clase es el siguiente:

Como puede ver, se muestran los campos de la estructura interna y las propiedades y métodos públicos así como los constructores de cada instancia (objeto) de esta plantilla (clase).

A continuación se muestra la implementación del Tipo de Dato Abstracto Pila (Stack):

Código:


using System;
using System.Collections; // Esto hace falta para utilizar ArrayList

namespace DemoPila2
{
  /// <summary>
  /// Implementación de Lista de pila almacenada en secuencia
  /// </summary>
  public class Stack <ELEMENT>
  {
    #region Estructura Interna

    /// <summary>
    /// Tamaño por defecto del contenedor
    /// </summary>
    private static readonly int DEFAULT_SIZE = 10;

    /// <summary>
    /// Mantiene la colección de elementos
    /// </summary>
    private ArrayList collection;

    #endregion

    #region Constructores
      /// <summary>
    /// Constructor por defecto
    /// Nos aseguramos que el contenedor sea válido
    /// </summary>
    public Stack()
    {
      this.collection = new ArrayList(DEFAULT_SIZE);
    }

    /// <summary>
    /// Constructor especializado
    /// <precondition>
    /// El tamaño debe ser mayor que cero
    /// </precondition>
    /// </summary>
    /// <param name="size">Tamaño del contenedor</param>
    public Stack(int size)
    {
      if (size <= 0)
      {
        throw new ArgumentException("Argumento inválido size " + size.ToString());
      }
      this.collection = new ArrayList(size);
    }

    #endregion

    #region Propiedades

    /// <summary>
    /// Determina si la pila (Stack) está vacía
    /// </summary>
    public bool IsEmpty
    {
      get
      {
        return this.collection.Count <= 0;
      }
    }

    /// <summary>
    /// Determina si la pila (Stack) está llena
    /// </summary>
    public bool IsFull
    {
      get
      {
        return this.collection.Count == this.collection.Capacity;
      }
    }

    /// <summary>
    /// Determina si la pila (Stack) está normal
    /// </summary>
    public bool IsNormal
    {
      get
      {
        return !(this.IsEmpty || this.IsFull);
      }
    }

    #endregion

    #region Métodos que implementan el comportamiento

    /// <summary>
    /// Agrega un elemento en la pila (Stack)
    /// <precondition>
    /// La pila (Stack) no debe estar llena
    /// </precondition>
    /// </summary>
    /// <param name="x">Elemento que se agrega</param>
    public void Push(ELEMENT x)
    {
      if (this.IsFull)
      {
        throw new Exception("Intento de meter un elemento de una pila llena");
      }
      this.collection.Add(x);
    }

    /// <summary>
    /// Extrae un elemento de la pila (Stack)
    /// <precondition>
    /// La pila (Stack) debe contener elementos
    /// </precondition>
    /// </summary>
    /// <returns>Elemento extraído</returns>
    public ELEMENT Pop()
    {
      if (this.IsEmpty)
      {
        throw new Exception("Intento de sacar un elemento de una pila vacía");
      }
      int pos = this.collection.Count - 1;
      ELEMENT obj = (ELEMENT)this.collection[pos];
      this.collection.RemoveAt(pos);
      return obj;
    }

    /// <summary>
    /// Deveuelve el elemento que puede extraerse de la pila (Stack) sin sacarlo
    /// <precondition>
    /// La pila (Stack) debe contener elementos
    /// </precondition>
    /// </summary>
    /// <returns>Elemento que puede extraerse</returns>
    public ELEMENT Peek()
    {
      if (this.IsEmpty)
      {
        throw new Exception("Intento de ver un elemento de una pila vacía");
      }
      return (ELEMENT)this.collection[this.collection.Count - 1];
    }

    #endregion
  }
}


De este modo es posible copiar y pegar todo o parte del código que se necesite.