feat: implement queue data structure class

Author: francislagares

src/index.ts

@@ -4,3 +4,4 @@ import './hash-table/HashTable';
 import './linked-list/LinkedList';
 import './doubly-linked-list/DoublyLinkedList';
 import './stack/StackClass';
+import './queue/QueueClass';

src/queue/QueueClass.ts

@@ -0,0 +1,54 @@
+import { QueueNode } from './QueueNode';
+
+export interface Queue<T> {
+  size: number;
+  first: QueueNode<T> | null;
+  last: QueueNode<T> | null;
+  peek(): QueueNode<T> | null;
+  enqueue(value: T): QueueNode<T> | null;
+  dequeue(): QueueNode<T> | null;
+  isEmpty(): boolean;
+}
+
+export class Queue<T> implements Queue<T> {
+  constructor() {
+    this.first = null;
+    this.last = null;
+    this.size = 0;
+  }
+
+  public peek(): QueueNode<T> {
+    if (this.isEmpty()) {
+      throw new Error('Queue is empty');
+    }
+    return this.first;
+  }
+
+  public isEmpty() {
+    return this.size === 0;
+  }
+
+  public enqueue(value: T): QueueNode<T> {
+    const node = new QueueNode(value);
+    if (this.size === 0) {
+      this.first = node;
+      this.last = node;
+    } else {
+      this.last.next = node;
+      this.last = node;
+    }
+    this.size += 1;
+    return this.first;
+  }
+
+  public dequeue(): QueueNode<T> {
+    if (this.size > 0) {
+      const nodeToBeRemoved = this.first;
+      this.first = this.first.next;
+      this.size--;
+      nodeToBeRemoved.next = null;
+      return nodeToBeRemoved;
+    }
+    return null;
+  }
+}

src/queue/QueueNode.ts

@@ -0,0 +1,11 @@
+export interface QueueNode<T> {
+  data: T | null;
+  next: QueueNode<T> | null;
+}
+
+export class QueueNode<T> implements QueueNode<T> {
+  constructor(data?: T) {
+    this.data = data;
+    this.next = null;
+  }
+}

src/queue/__tests__/QueueClass.test.ts

@@ -0,0 +1,62 @@
+import { Queue } from '../QueueClass';
+
+describe('Queue', () => {
+  test('create an empty queue', () => {
+    const queue = new Queue();
+
+    expect(queue).toBeInstanceOf(Queue);
+    expect(queue).not.toBeNull();
+    expect(queue.isEmpty()).toBeTruthy();
+  });
+
+  test('enqueue data to queue', () => {
+    const queue = new Queue<string>();
+
+    queue.enqueue('Joy');
+    queue.enqueue('Matt');
+    queue.enqueue('Pavel');
+    queue.enqueue('Samir');
+
+    expect(queue.size).toBe(4);
+    expect(queue.isEmpty()).toBeFalsy();
+  });
+
+  test('dequeue data from queue', () => {
+    const queue = new Queue<string>();
+
+    queue.enqueue('Joy');
+    queue.enqueue('Matt');
+    queue.enqueue('Pavel');
+    queue.enqueue('Samir');
+
+    expect(queue.size).toBe(4);
+    expect(queue.isEmpty()).toBeFalsy();
+
+    expect(queue.dequeue().data).toBe('Joy');
+    expect(queue.dequeue().data).toBe('Matt');
+
+    expect(queue.size).toBe(2);
+    expect(queue.isEmpty()).toBeFalsy();
+  });
+
+  test('peek node from queue', () => {
+    const queue = new Queue<number>();
+
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+
+    expect(queue.peek().data).toBe(1);
+  });
+
+  test('peek throws error if queue is empty', () => {
+    try {
+      const queue = new Queue();
+
+      expect(queue.peek()).toThrowError();
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect(error).toHaveProperty('message', 'Queue is empty');
+    }
+  });
+});

src/queue/__tests__/QueueNode.test.ts

@@ -0,0 +1,27 @@
+import { QueueNode } from '../QueueNode';
+
+describe('Stack Node', () => {
+  test('create empty queue node', () => {
+    const node = new QueueNode();
+
+    expect(node.data).toBeUndefined();
+    expect(node.next).toBeNull();
+    expect(node.next).toBeNull();
+  });
+
+  test('create queue node with value', () => {
+    const node = new QueueNode(10);
+
+    expect(node.data).toBe(10);
+    expect(node.next).toBeNull();
+  });
+
+  test('create queue node with object as a value', () => {
+    const nodeValue = { key: 1, value: 'test' };
+    const node = new QueueNode(nodeValue);
+
+    expect(node.data.key).toBe(1);
+    expect(node.data.value).toBe('test');
+    expect(node.next).toBeNull();
+  });
+});