feat: add Linked Queue

DIRECTORY.md

@@ -4,6 +4,8 @@
 
 ## 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/linkedlist_queue.ts

@@ -0,0 +1,84 @@
+/**
+ * This is an linkedlist-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).
+
+ */
+
+/** USAGE
+
+*Printers
+*CPU task scheduling
+*Callback queue in javascript
+
+*/
+
+import { Queue } from "./queue";
+
+type Node<T> = {
+    value: T,
+    next?: Node<T>,
+}
+
+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 elements to the rear/tail of 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!!
+
+    }
+
+
+    // Remove elements to the front/head of the Queue
+    dequeue(): T | undefined {
+
+        // If there is no head return 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 value of the head
+    peek(): T | undefined | null {
+
+        if (this.isEmpty()) {
+            return null;
+        }
+        return this.head?.value;
+    }
+
+    // Returns true if the Queue is empty
+    isEmpty(): boolean {
+        return this.size === 0
+    }
+
+    length(): number {
+        return this.size;
+    }
+}
+

data_structures/queue.ts

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

data_structures/test/Queue.test.ts

@@ -0,0 +1,64 @@
+
+import { Queue } from '../queue';
+type QueueConstructor = new <T>() => Queue<T>
+export function test(Queue: QueueConstructor) {
+	describe("Testing Queue data structure", () => {
+		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");
+		});
+	});
+
+}

data_structures/test/array_queue.test.ts

@@ -1,60 +1,7 @@
 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);
+import { test } from './Queue.test'
 
-        expect(queue.length()).toBe(1);
-    });
+test(ArrayQueue);
 
-    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");
-    });
-});

data_structures/test/linkedlist_queue.test.ts

@@ -0,0 +1,6 @@
+import { test } from './Queue.test'
+
+import { LinkedQueue } from '../linkedlist_queue';
+
+test(LinkedQueue);
+