add unitest for queue and stack DSA

Author: sangtrandev00

src/data_structure/queue/queue-implement.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { Queue } from './queue-implement';
+
+describe('Queue', () => {
+    let queue: Queue;
+
+    beforeEach(() => {
+        queue = new Queue();
+    });
+
+    it('should initialize an empty queue', () => {
+        expect(queue.isEmpty()).toBe(true);
+        expect(queue.peek()).toBeNull();
+    });
+
+    it('should enqueue elements to the queue', () => {
+        queue.enqueue('first');
+        expect(queue.isEmpty()).toBe(false);
+        expect(queue.peek().value).toBe('first');
+
+        queue.enqueue('second');
+        expect(queue.peek().value).toBe('first'); // First element should still be 'first'
+    });
+
+    it('should dequeue elements from the queue', () => {
+        queue.enqueue('first');
+        queue.enqueue('second');
+
+        const dequeued = queue.dequeue();
+        expect(dequeued.value).toBe('first'); // First element should be dequeued
+        expect(queue.peek().value).toBe('second'); // Now the first element should be 'second'
+    });
+
+    it('should return null when dequeuing from an empty queue', () => {
+        expect(queue.dequeue()).toBeNull();
+    });
+
+    it('should handle special case when dequeuing the last element', () => {
+        queue.enqueue('only');
+        expect(queue.dequeue().value).toBe('only');
+        expect(queue.isEmpty()).toBe(true);
+        expect(queue.peek()).toBeNull();
+    });
+});

src/data_structure/queue/queue-implement.ts

@@ -7,7 +7,7 @@ class Node {
     }
 }
 
-class Queue {
+export class Queue {
     // Dùng Single LinkedList là được rồi!
     first: any;
     last: any;
@@ -21,19 +21,24 @@ class Queue {
         return this.first
     }
     enqueue(value: any) {
+        const newNode = new Node(value)
         if (this.length === 0) {
-            this.first = new Node(value)
-            this.last = this.first
+            this.first = newNode
+            this.last = newNode
         } else {
-            const newNode = new Node(value)
             this.last.next = newNode
             this.last = newNode
         }
         this.length++
         return this.last
     }
     dequeue() {
+        if (!this.first) return null
         const holder = this.first
+        if (this.first == this.last) {
+            this.last = null // Special case (When there is only one element)
+        }
+
         this.first = this.first.next;
         this.length--
         return holder

src/data_structure/stack/stack-implement.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach } from 'bun:test';
+import { Stack } from './stack-implement'; // Adjust the import based on your file structure
+
+describe('Stack', () => {
+    let stack: Stack;
+
+    beforeEach(() => {
+        stack = new Stack();
+    });
+
+    it('should initialize an empty stack', () => {
+        expect(stack.isEmpty()).toBe(true);
+        expect(stack.peek()).toBeNull();
+    });
+
+    it('should push elements onto the stack', () => {
+        stack.push(1);
+        expect(stack.isEmpty()).toBe(false);
+        expect(stack.peek().value).toBe(1); // Check the top value
+
+        stack.push(3);
+        expect(stack.peek().value).toBe(3); // Top value should now be 3
+
+        stack.push(100);
+        expect(stack.peek().value).toBe(100); // Top value should now be 100
+
+        stack.push(3000);
+        expect(stack.peek().value).toBe(3000); // Top value should now be 3000
+    });
+
+    it('should pop elements from the stack', () => {
+        stack.push(1);
+        stack.push(3);
+        stack.push(100);
+
+        const popped = stack.pop();
+        expect(popped.value).toBe(100); // Last pushed value should be popped
+        expect(stack.peek().value).toBe(3); // Now the top value should be 3
+
+        stack.pop(); // Pop 3
+        expect(stack.peek().value).toBe(1); // Now the top value should be 1
+
+        stack.pop(); // Pop 1
+        expect(stack.isEmpty()).toBe(true); // Stack should be empty now
+        expect(stack.peek()).toBeNull(); // Peek should return null
+    });
+
+    it('should return null when popping from an empty stack', () => {
+        expect(stack.pop()).toBeNull(); // Popping from an empty stack should return null
+    });
+
+    it('should handle special case when popping the last element', () => {
+        stack.push(42);
+        expect(stack.pop().value).toBe(42); // Pop the only element
+        expect(stack.isEmpty()).toBe(true); // Stack should be empty now
+        expect(stack.peek()).toBeNull(); // Peek should return null
+    });
+});

src/data_structure/stack/stack-implement.ts

@@ -1,4 +1,3 @@
-import { LinkedList } from "../linkedList/reverseLinkedList";
 
 class Node {
     value: any