EdD - Clase Queue (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 Cola (Queue):

Código:


using System;

namespace DemoCola1
{
  /// <summary>
  /// Implementación de Lista de cola almacenada en secuencia
  /// </summary>
  public class Queue <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 ELEMENT[] collection;
    /// <summary>
    /// Mantiene el punto por donde se extraen los elementos (cabeza)
    /// </summary>
    private int head;
    /// <summary>
    /// Mantiene el punto por donde se agregan los elementos (cola)
    /// </summary>
    private int tail;
    /// <summary>
    /// Mantiene la cuenta de elementos
    /// </summary>
    private int count;

    #endregion

    #region Constructores
    /// <summary>
    /// Constructor por defecto
    /// Nos aseguramos que el contenedor sea válido
    /// </summary>
    public Queue()
    {
      this.collection = new ELEMENT[DEFAULT_SIZE];
      this.head = 0;
      this.tail = 0;
      this.count = 0;
    }

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

    #endregion

    #region Propiedades

    /// <summary>
    /// Determina si la cola (Queue) está vacía
    /// </summary>
    public bool IsEmpty
    {
      get
      {
        return this.count <= 0;
      }
    }

    /// <summary>
    /// Determina si la cola (Queue) está llena
    /// </summary>
    public bool IsFull
    {
      get
      {
        return this.count == this.collection.Length;
      }
    }

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

    #endregion

    #region Métodos utilitarios

    /// <summary>
    /// Implementa el mecanismo para que un índice se incremente hasta llegar al
    /// tamaño del contenedor en cuyo caso vuelve al principio (cero)
    /// </summary>
    /// <param name="pos">Valora actual del índice</param>
    /// <returns>Posición siguiente del índice</returns>
    private int Next(int pos)
    {
      ++pos;
      if (pos >= this.collection.Length)
      {
        pos = 0;
      }
      return pos;
    }

    #endregion

    #region Métodos que implementan el comportamiento

    /// <summary>
    /// Agrega un elemento en la cola (Queue)
    /// <precondition>
    /// La cola (Queue) no debe estar llena
    /// </precondition>
    /// </summary>
    /// <param name="x">Elemento que se agrega</param>
    public void Enqueue(ELEMENT x)
    {
      if (this.IsFull)
      {
        throw new Exception("Intento de meter un elemento de una cola llena");
      }
      this.collection[this.tail] = x;
      this.tail = Next(this.tail);
      ++this.count;
    }

    /// <summary>
    /// Extrae un elemento de la cola (Queue)
    /// <precondition>
    /// La cola (Queue) debe contener elementos
    /// </precondition>
    /// </summary>
    /// <returns>Elemento extraído</returns>
    public ELEMENT Dequeue()
    {
      if (this.IsEmpty)
      {
        throw new Exception("Intento de sacar un elemento de una cola vacía");
      }
      ELEMENT obj = this.collection[this.head];
      this.head = Next(this.head);
      --this.count;
      return obj;
    }

    /// <summary>
    /// Deveuelve el elemento que puede extraerse de la cola (Queue) sin sacarlo
    /// <precondition>
    /// La cola (Queue) debe contener elementos
    /// </precondition>
    /// </summary>
    /// <returns>Elemento que puede extraerse</returns>
    public ELEMENT Peek()
    {
      if (this.IsEmpty)
      {
        throw new Exception("Intento de consultar un elemento en una cola vacía");
      }
      return this.collection[this.head];
    }
    #endregion
  }
}


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