structure: queue (TheAlgorithms#84)

* feat: implements the data structure queue

* fix: resolves requested changes

- The removed element is now returned in `dequeue()`
- Files have been renamed
- Time complexity note has been added
- Adjusted tests accordingly

Author: zFl4wless

data_structures/array_queue.ts

@@ -0,0 +1,63 @@
+/**
+ * This is an array-based implementation of a Queue.
+ * A Queue is a data structure that follows the FIFO (First In First Out) principle.
+ * It means that the first element that was added to the queue will be the first one to be removed.
+ * The time complexity of the operations is O(n).
+ */
+export class ArrayQueue<T> {
+    private queue: T[] = [];
+
+    /**
+     * Returns the number of items in the queue.
+     *
+     * @returns {number} The number of items in the queue.
+     */
+    length(): number {
+        return this.queue.length;
+    }
+
+    /**
+     * Checks if the queue is empty.
+     *
+     * @returns {boolean} Whether the queue is empty or not.
+     */
+    isEmpty(): boolean {
+        return this.queue.length === 0;
+    }
+
+    /**
+     * Adds an item to the queue.
+     *
+     * @param item The item being added to the queue.
+     */
+    enqueue(item: T): void {
+        this.queue.push(item);
+    }
+
+    /**
+     * Removes an item from the queue and returns it.
+     *
+     * @throws Queue Underflow if the queue is empty.
+     * @returns The item that was removed from the queue.
+     */
+    dequeue(): T {
+        if (this.isEmpty()) {
+            throw new Error("Queue Underflow");
+        }
+
+        return this.queue.shift() as T;
+    }
+
+    /**
+     * Returns the item at the front of the queue.
+     *
+     * @returns The item at the front of the queue or null if the queue is empty.
+     */
+    front(): T | null {
+        if (this.isEmpty()) {
+            return null;
+        }
+
+        return this.queue[0];
+    }
+}

data_structures/test/array_queue.test.ts

@@ -0,0 +1,60 @@
+import { ArrayQueue } from "../array_queue";
+
+describe("Testing Queue data structure", () => {
+    it("enqueue should add a new element to the queue", () => {
+        const queue = new ArrayQueue<number>();
+        queue.enqueue(1);
+
+        expect(queue.length()).toBe(1);
+    });
+
+    it("isEmpty should return true on empty queue", () => {
+        const queue = new ArrayQueue<number>();
+        expect(queue.isEmpty()).toBeTruthy();
+    });
+
+    it("isEmpty should return false on not empty queue", () => {
+        const queue = new ArrayQueue<number>();
+        queue.enqueue(1);
+
+        expect(queue.isEmpty()).toBeFalsy();
+    });
+
+    it("front should return the first value", () => {
+        const queue = new ArrayQueue<number>();
+        queue.enqueue(1);
+
+        expect(queue.front()).toBe(1);
+    });
+
+    it("front should return null when the queue is empty", () => {
+        const queue = new ArrayQueue<number>();
+
+        expect(queue.front()).toBe(null);
+    });
+
+    it("length should return the number of elements in the queue", () => {
+        const queue = new ArrayQueue<number>();
+        queue.enqueue(1);
+        queue.enqueue(1);
+        queue.enqueue(1);
+
+        expect(queue.length()).toBe(3);
+    });
+
+    it("dequeue should remove the first element", () => {
+        const queue = new ArrayQueue<number>();
+        queue.enqueue(1);
+        queue.enqueue(2);
+        queue.enqueue(3);
+        queue.dequeue();
+
+        expect(queue.length()).toBe(2);
+    });
+
+    it("dequeue should throw error on empty queue", () => {
+        const queue = new ArrayQueue<number>();
+
+        expect(() => queue.dequeue()).toThrow("Queue Underflow");
+    });
+});