fix: duplication of queue interface and minor bug

Author: co-bby

data_structures/array_queue.ts

@@ -4,13 +4,7 @@
  * 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).
  */
-interface Queue<T> {
-    enqueue(item: T): void
-    dequeue(): T | undefined
-    peek(): T | undefined | null
-    isEmpty(): boolean
-
-}
+import { Queue } from './queue'
 export class ArrayQueue<T> implements Queue<T>{
     private queue: T[] = [];
 

data_structures/linkedlist_queue.ts

@@ -14,13 +14,7 @@
 
 */
 
-export interface Queue<T> {
-    enqueue(item: T): void
-    dequeue(): T | undefined
-    peek(): T | undefined | null
-    isEmpty(): boolean
-
-}
+import { Queue } from "./queue";
 
 type Node<T> = {
     value: T,
@@ -32,19 +26,19 @@ type Node<T> = {
 
 export class LinkedQueue<T> implements Queue<T> {
 
-    public length: number;
+    public size: number;
     public head?: Node<T>;
     private tail?: Node<T>;
 
     constructor() {
         this.head = this.tail = undefined;
-        this.length = 0;
+        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.length++ // Increase the length of the Queue
+        this.size++ // Increase the length of the Queue
 
 
         if (!this.tail) {
@@ -55,15 +49,17 @@ export class LinkedQueue<T> implements Queue<T> {
         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) {
-            return undefined;
+            throw new Error("Queue Underflow");
         }
 
-        this.length--;
+        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
@@ -77,7 +73,11 @@ export class LinkedQueue<T> implements Queue<T> {
 
     // Returns true if the Queue is empty
     isEmpty(): boolean {
-        return this.length == 0
+        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/linkedlist_queue.test.ts

@@ -6,7 +6,7 @@ describe("Testing Queue data structure", () => {
         const queue = new LinkedQueue<number>();
         queue.enqueue(1);
 
-        expect(queue.length).toBe(1);
+        expect(queue.length()).toBe(1);
     });
 
     it("isEmpty should return true on empty queue", () => {
@@ -21,26 +21,41 @@ describe("Testing Queue data structure", () => {
         expect(queue.isEmpty()).toBeFalsy();
     });
 
+    it("front should return the first value", () => {
+        const queue = new LinkedQueue<number>();
+        queue.enqueue(1);
+
+        expect(queue.peek()).toBe(1);
+    });
+
+    it("front should return null when the queue is empty", () => {
+        const queue = new LinkedQueue<number>();
 
+        expect(queue.peek()).toBe(undefined);
+    });
 
     it("length should return the number of elements in the queue", () => {
         const queue = new LinkedQueue<number>();
         queue.enqueue(1);
         queue.enqueue(1);
         queue.enqueue(1);
 
-        expect(queue.length).toBe(3);
+        expect(queue.length()).toBe(3);
     });
 
     it("dequeue should remove the first element", () => {
         const queue = new LinkedQueue<number>();
         queue.enqueue(1);
         queue.enqueue(2);
         queue.enqueue(3);
+        queue.dequeue();
 
-
-        expect(queue.length).toBe(3);
+        expect(queue.length()).toBe(2);
     });
 
+    it("dequeue should throw error on empty queue", () => {
+        const queue = new LinkedQueue<number>();
 
+        expect(() => queue.dequeue()).toThrow("Queue Underflow");
+    });
 });