EdD - Clase Queue (alternativa de velocidad, desarrollada en teoría)

En este caso la Estructura de Datos implementación del Tipo de Dato Abstrato Cola, prioriza velocidad; como pueden ver el comportamiento que se publica es el mismo y como se dijo en teoría, cuando se utilizan lenguajes orientados a objetos no hay diferencia en performance de una u otra implementación.
Diagrama de clase:

El código es el siguiente:

Código:


using System;

namespace DemoCola2
{
  /// <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;

    #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;
    }

    /// <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;
    }

    #endregion

    #region Propiedades

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

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

    /// <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);
    }

    /// <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);
      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
  }
}


Basicamente se puede ver que no tiene el contador de elementos en la colección interna, lo obliga a implementar un mecanismo diferenter para controlar el estado de la estructura de datos (IsEmpty, IsFull)