feat: add Linked Queue (#88)

* feat: add Array Queue to Directory.md

* feat: add linkedlist Queue

* feat: add test for linkedlist queue

* feat: update Directory.md

* fixed typos and formatting

* BREAKING CHANGE: change front to peek

* fix: added the queue interface

* fix: duplication of queue interface and minor bug

* fix: queue test problem

* fix: change filename to match naming convention

* fix: leading newline and time complexity

* feat: add jsDoc comments

* Rename Queue.test.ts to queue.test.ts

* Update queue.test.ts

* Update array_queue.test.ts

* Update and rename linkedlist_queue.test.ts to linked_queue.test.ts

* Update and rename linkedlist_queue.ts to linked_queue.ts

* Update linked_queue.test.ts

* Update linked_queue.test.ts

* Rename queue.test.ts to queue.ts

* Update array_queue.test.ts

* Update linked_queue.test.ts

Co-authored-by: Lars Müller <[email protected]>

Author: co-bby

DIRECTORY.md

@@ -5,6 +5,7 @@
 ## Data Structures
   * [Stack](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/stack.ts)
   * [Array Queue](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/array_queue.ts)
+  * [Linkedlist Queue](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/linkedlist_queue.ts)
 
 ## Dynamic Programming
   * [Knapsack](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/dynamic_programming/knapsack.ts)

data_structures/array_queue.ts

@@ -4,7 +4,8 @@
  * 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> {
+import { Queue } from './queue'
+export class ArrayQueue<T> implements Queue<T>{
     private queue: T[] = [];
 
     /**
@@ -53,7 +54,7 @@ export class ArrayQueue<T> {
      *
      * @returns The item at the front of the queue or null if the queue is empty.
      */
-    front(): T | null {
+    peek(): T | null {
         if (this.isEmpty()) {
             return null;
         }

data_structures/linked_queue.ts

@@ -0,0 +1,95 @@
+import { Queue } from "./queue";
+
+type Node<T> = {
+    value: T,
+    next?: Node<T>,
+}
+
+/**
+ * This is a LinkedList-like implementation of a Queue,
+ * allowing the operations to be implemented in constant time.
+ * A Queue is a data structure that follows the FIFO (First-In First-Out) principle:
+ * The first element that was added to the queue will be the first one to be removed.
+ */
+export class LinkedQueue<T> implements Queue<T> {
+
+    public size: number;
+    public head?: Node<T>;
+    private tail?: Node<T>;
+
+    constructor() {
+        this.head = this.tail = undefined;
+        this.size = 0;
+    }
+
+    /**
+     * Adds an item to the queue.
+     *
+     * @param item The item being added to the queue.
+     */
+    enqueue(item: T): void {
+        const node = { value: item } as Node<T>; // Creates a new node
+        this.size++ // Increase the length of the Queue
+
+
+        if (!this.tail) {
+            this.tail = this.head = node;
+            return;
+        }
+        this.tail.next = node; // Updates  the next tail to the node created
+        this.tail = node;  // The tail of the Queue then becomes the node created!!
+
+    }
+
+
+    /**
+     * 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 | undefined {
+
+        if (!this.head) {
+            throw new Error("Queue Underflow");
+        }
+
+        this.size--;
+        let head = this.head; // We store the head in order not to lose track of it
+        this.head = this.head.next; // Update the the head to the next node
+        return head.value; // Return the value of the head
+    }
+
+
+    /**
+     * 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.
+     */
+    peek(): T | undefined | null {
+
+        if (this.isEmpty()) {
+            return null;
+        }
+        return this.head?.value;
+    }
+
+    /**
+     * Checks if the queue is empty.
+     *
+     * @returns {boolean} Whether the queue is empty or not.
+     */
+    isEmpty(): boolean {
+        return this.size === 0
+    }
+
+    /**
+     * Returns the number of items in the queue.
+     *
+     * @returns {number} The number of items in the queue.
+     */
+    length(): number {
+        return this.size;
+    }
+}
+

data_structures/queue.ts

@@ -0,0 +1,7 @@
+export interface Queue<T> {
+	enqueue(item: T): void
+	dequeue(): T | undefined
+	peek(): T | undefined | null
+	isEmpty(): boolean
+	length(): number
+}

data_structures/test/array_queue.test.ts

@@ -1,60 +1,4 @@
 import { ArrayQueue } from "../array_queue";
+import { testQueue } from './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");
-    });
-});
+describe("Array Queue", () => testQueue(ArrayQueue));

data_structures/test/linked_queue.test.ts

@@ -0,0 +1,4 @@
+import { testQueue } from './queue'
+import { LinkedQueue } from '../linked_queue';
+
+describe("Linked Queue", () => testQueue(LinkedQueue));

data_structures/test/queue.ts

@@ -0,0 +1,53 @@
+import { Queue } from '../queue';
+type QueueConstructor = new <T>() => Queue<T>
+export function testQueue(Queue: QueueConstructor) {
+	it("enqueue should add a new element to the queue", () => {
+		const queue = new Queue<number>();
+		queue.enqueue(1);
+		expect(queue.length()).toBe(1);
+	});
+
+	it("isEmpty should return true on empty queue", () => {
+		const queue = new Queue<number>();
+		expect(queue.isEmpty()).toBeTruthy();
+	});
+
+	it("isEmpty should return false on not empty queue", () => {
+		const queue = new Queue<number>();
+		queue.enqueue(1);
+		expect(queue.isEmpty()).toBeFalsy();
+	});
+
+	it("front should return the first value", () => {
+		const queue = new Queue<number>();
+		queue.enqueue(1);
+		expect(queue.peek()).toBe(1);
+	});
+
+	it("front should return null when the queue is empty", () => {
+		const queue = new Queue<number>();
+		expect(queue.peek()).toBe(null);
+	});
+
+	it("length should return the number of elements in the queue", () => {
+		const queue = new Queue<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 Queue<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 Queue<number>();
+		expect(() => queue.dequeue()).toThrow("Queue Underflow");
+	});
+}