Listas, Colas, Pilas y Conjuntos en C# - Parte 3/6: Queue y Queue(T)

Índice

1. Introducción
2. Palabras Clave
3. Clase No-Genérica Queue
4. Clase Genérica Queue<T>
5. Conclusiones
6. Literatura & Enlaces

1. Introducción

Esta tercera parte se centra en el estudio de dos estructuras basadas en FIFO (First-In-First-Out): primer elemento en entrar, primero en salir. Esta colección se asemaja a una cola de espera, aplicable a modelos que reflejen procesos donde los elementos o entidades son procesados o atentidos a medida que llegan al sistema de espera. C# en particular, cuenta con clases para las operaciones de agregar -Enqueue- y retirar -Dequeue-, e inclusive Peek para obtener el primer elemento a procesar sin removerlo de la estructura. Se estudian las versiones no-genérica y genérica.

2. Palabras Clave

• Cola de espera
• Colección
• Estructura de datos
• FIFO
• Genéricos

2. Clase No-Genérica Queue

Esta clase representa una estructura de datos FIFO que acomoda sus elementos de acuerdo al orden en que llegan a la estructura: el primero en llegar será el que ocupe la posición de mayor prioridad de procesamiento, es decir, que está al frente (head) de la estructura. Ocurre lo contrario para los elementos que tienen la prioridad más baja: deberán esperar a ser atentidos al final respecto a los elementos que ocupan posiciones cercanas al frente.

Figura 1. Representación gráfica de una cola de espera ("Stack and Queue", 2017).

La clase Queue ("Queue Class", 2017) se halla en el namespace de estructuras no-genéricas System.Collections. Implementa los protocolos o interfaces ICollections e IEnumerable (Interfaces ICollection y IList en C# - Parte 1/2) propios para operaciones comunes de colecciones y enumeración de los elementos de la estructura, respectivamente.

Entre las utilidades principales de Queue está la de servir como almacenamiento de datos de elementos que requiren acceso en el mismo orden en que fueron puestos en la cola de espera ("Queue Class", 2017).

Para lograr lo anterior, se cuentan con tres métodos u operaciones elementales:

• Enqueue: o agregar al final de la estructura.
• Dequeue: o remover al frente de la estructura.
• Peek: o retornar el elemento al frente de la estructura (no es removido de la colección).

A medida que se agregan elementos a la cola de espera está irá cambiando su tamaño de forma dinámica. En C#, el factor de crecimiento es de 2.0 ("Queue Class", 2017).

Adicionalmente, la colección permite la agregación elementos null y duplicados.

Un ejemplo de uso sencillo podría ser:

Queue cola = new Queue();

cola.Enqueue("C#");

cola.Enqueue("es");

cola.Enqueue("génial");

System.out.println(cola.Dequeue()); // C#

System.out.println(cola.Peek()); // es

System.out.println(cola.Dequeue()); // es

3. Clase Genérica Queue<T;gt

Queue<T> comparte varias de las características y comportamientos de su contraparte no-genérica: colocación de elementos, crecimiento dinámico, métodos de acceso y mutación, entre otros más; pero se distingue en contener elementos a partir de un tipo paramétrico: no es necesario realizar conversiones (casting), y por consiguiente las operaciones de boxing y unboxing no son necesarias.

Existe una versión de este tipo de estructura para operaciones concurrentes o paralelas: ConcurrentQueue<T>. Esta clase permite el acceso concurrente a los elementos de la colección usando diferentes threads ("Queue(T) Class", 2017).

De acuerdo con Albahari (2012), internamente las colas están compuestas por un arreglo que se redimensiona según es requerido, e índices para indicar el final (tail) y principio (head). Esto ayuda que las operaciones de adición y remoción de elementos sean muy eficientes.

Ejemplo de uso básico:

var queuePrimos = new Queue<int>();

queuePrimos.Enqueue(2);

queuePrimos.Enqueue(3);

queuePrimos.Enqueue(5);

// Exportación a un arreglo:

int[] arrPrimos = queuePrimos.ToArray();

Console.WriteLine(queuePrimos.Count); // 3

Console.WriteLine(queuePrimos.Peek()); // 2

Console.WriteLine(queuePrimos.Dequeue()); // 2

Console.WriteLine(queuePrimos.Dequeue()); // 3

// Generación de excepción:

Console.WriteLine(queuePrimos.Dequeue()); // No hay más elementos

4. Conclusiones

Se exploraron las características fundamentales de las clases Queue y Queue<T>: su estructura FIFO (first-in-first-out), manipulación de elementos con los métodos Enqueue y Dequeue, y obtención del primer elemento en entrar con Peek. Estos métodos son comunes tanto para la versión no-genérica y genérica. Se escribieron algunos ejemplos de uso que presentan las funciones más básicas. Se reconoció la existencia la clase ConcurrentQueue<T>.

5. Literatura & Enlaces

Albahari, J., Albahari, B. (2012). C# 5.0 in a Nutshell. United States: O'Reilly Media.
Queue Class (System.Collections) (2017). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.collections.queue(v=vs.110).aspx
Interfaces ICollection y IList en C# - Parte 1/2 (2017). Recuperado desde: https://ortizol.blogspot.com.co/2017/08/interfaces-icollection-y-ilist-en-csharp-parte-1-2.html
Computer Algorithms: Stack and Queue (2017). Recuperado desde: http://www.stoimen.com/blog/2012/06/05/computer-algorithms-stack-and-queue-data-structure/
Queue(T) Class (System.Collections.Generic) (2017). Recuperado desde: https://msdn.microsoft.com/en-us/library/7977ey2c(v=vs.110).aspx

O