Improve queue ds & algorithms

Author: sudheerj

README.md

@@ -23,10 +23,10 @@ The implementations are primarily in JavaScript, with some examples in other lan
 
 ### Queue
 
-| No. | Name | Source | Live | Documentation | Level | Pattern |
-| :-: | :--------------------- | :----: | :--: | :-----------: | :---: | :-----: |
-| 1 | Queue using array | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/queue_array.js) | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/queue_array.js) | - | Easy | Using Array operations |
-| 2 | Queue using linkedlist | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/queue_with_linkedlist.js) | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/queue_with_linkedlist.js) | - | Easy | Using LinkedList operations |
+| No. | Name |  Source  | Live  | Documentation  | Level | Pattern |
+| :-: | :--------------------- |:----------------------------------------------------------------------------------------------------------------------------------------------------------------:|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:| :---: | :-----: |
+| 1 | Queue using array |  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/1.queue_with_array/queue_with_array.js)  | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/1.queue_with_array/queue_with_array.js)  | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/1.queue_with_array/queue_with_array.md)  | Easy | Using Array operations |
+| 2 | Queue using linkedlist | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/2.queue_with_linkedlist/queue_with_linkedlist.js) | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/2.queue_with_array/queue_with_linkedlist.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/datastructures/queue/2.queue_with_linkedlist/queue_with_linkedlist.md)  - | Easy | Using LinkedList operations |
 
 ### SinglyLinkedList
 

src/javascript/algorithms/queue/enqueueDequeueWithStacks.js

@@ -1,35 +1,45 @@
-class Stack {
+class MyStack {
  constructor() {
- this.array = [];
+ this.items = [];
  }
 
- isEmpty() {
- return this.array.length === 0;
+ // Core stack operations
+ push(value) {
+ this.items.push(value);
+ }
+
+ pop() {
+ if (this.isEmpty()) {
+ throw new Error("Stack Underflow: Cannot pop from an empty stack.");
+ }
+ return this.items.pop();
  }
 
  peek() {
  if (this.isEmpty()) {
- return null;
- } else {
- return this.array[this.array.length - 1];
+ throw new Error("Stack Underflow: Cannot peek from an empty stack.");
  }
+ return this.items[this.items.length - 1];
  }
 
- push(value) {
- this.array.push(value);
+ // Helper functions
+ isEmpty() {
+ return this.items.length === 0;
  }
 
- pop() {
- if (this.isEmpty()) return null;
- return this.array.pop();
+ size() {
+ return this.items.length;
+ }
+
+ printStack() {
+ return this.items.join(' ');
  }
- 
 }
 
 class MyQueue {
  constructor() {
- this.stack1 = new Stack();
- this.stack2 = new Stack();
+ this.stack1 = new MyStack();
+ this.stack2 = new MyStack();
  }
 
  peek() {

src/javascript/datastructures/queue/1.queue_with_array/queue_with_array.js

@@ -0,0 +1,61 @@
+class MyQueue {
+ constructor() {
+ this.items = []; // Array is used to implement a Queue
+ }
+
+ // Core queue operations
+ enqueue(value) {
+ this.items.push(value); // adds an item to the queue
+ }
+
+ dequeue() {
+ if (this.isEmpty()) {
+ throw new Error("Queue Underflow: Cannot dequeue from an empty queue.");
+ }
+ return this.items.shift(); // Removes an item from the front of a queue and returns the removed item
+ }
+
+ peek() {
+ if (this.isEmpty()) {
+ throw new Error("Queue Underflow: Cannot peek from an empty queue.");
+ }
+ return this.items[0]; // returns the front item of the queue without removing it
+ }
+
+ // Helper functions
+ isEmpty() {
+ return this.items.length === 0; // returns true if the queue is empty
+ }
+
+ size() {
+ return this.items.length; // returns the number of elements in the queue
+ }
+
+ printQueue() {
+ return this.items.join(" ");
+ }
+}
+
+// Usage example
+function useQueue() {
+ const queue = new MyQueue();
+
+ console.log("Is empty?", queue.isEmpty()); // true
+
+ try {
+ queue.dequeue(); // Should throw
+ } catch (e) {
+ console.error(e.message);
+ }
+
+ queue.enqueue(1);
+ queue.enqueue(2);
+ queue.enqueue(3);
+
+ console.log("Queue contents:", queue.printQueue()); // 1 2 3
+ console.log("Front element:", queue.peek()); // 1
+ console.log("Dequeued element:", queue.dequeue()); // 1
+ console.log("Queue after dequeue:", queue.printQueue()); // 2 3
+}
+
+useQueue();

src/javascript/datastructures/queue/1.queue_with_array/queue_with_array.md

@@ -0,0 +1,97 @@
+# Queue Implementation Using Array
+
+A queue is a linear data structure that follows the First In, First Out (FIFO) principle. This means that the first element added to the queue will be the first one to be removed. A queue can be visualized as a line of people waiting for a service, where new people join at the back and are served from the front.
+
+## Overview
+
+This implementation uses a JavaScript array to represent a queue. While arrays in JavaScript provide methods that make queue operations straightforward, it's important to understand the underlying concepts.
+
+## Operations
+
+### Core Queue Operations
+
+1. **Enqueue**: Adds an element to the back of the queue.
+ - Time Complexity: O(1) amortized
+ - Implementation: Uses the array's `push()` method
+
+2. **Dequeue**: Removes and returns the element from the front of the queue.
+ - Time Complexity: O(n) - because shifting all elements is required
+ - Implementation: Uses the array's `shift()` method
+
+3. **Peek**: Returns the element at the front of the queue without removing it.
+ - Time Complexity: O(1)
+ - Implementation: Accesses the first element of the array
+
+### Helper Operations
+
+1. **isEmpty**: Checks if the queue is empty.
+ - Time Complexity: O(1)
+ - Implementation: Checks if the array's length is 0
+
+2. **Size**: Returns the number of elements in the queue.
+ - Time Complexity: O(1)
+ - Implementation: Returns the array's length
+
+3. **PrintQueue**: Returns a string representation of the queue.
+ - Time Complexity: O(n)
+ - Implementation: Joins all elements of the array with spaces
+
+## Implementation Details
+
+```javascript
+class MyQueue {
+ constructor() {
+ this.items = []; // Array is used to implement a Queue
+ }
+
+ // Core queue operations
+ enqueue(value) {
+ this.items.push(value); // adds an item to the queue
+ }
+
+ dequeue() {
+ if (this.isEmpty()) {
+ throw new Error("Queue Underflow: Cannot dequeue from an empty queue.");
+ }
+ return this.items.shift(); // Removes an item from the front of a queue
+ }
+
+ peek() {
+ if (this.isEmpty()) {
+ throw new Error("Queue Underflow: Cannot peek from an empty queue.");
+ }
+ return this.items[0]; // returns the front item without removing it
+ }
+
+ // Helper functions
+ isEmpty() {
+ return this.items.length === 0;
+ }
+
+ size() {
+ return this.items.length;
+ }
+
+ printQueue() {
+ return this.items.join(" ");
+ }
+}
+```
+
+## Advantages and Disadvantages
+
+### Advantages
+- Simple implementation
+- Dynamic size (no need to specify capacity)
+- Easy to understand and use
+
+### Disadvantages
+- The `dequeue` operation has O(n) time complexity because it uses `shift()`, which requires moving all remaining elements
+- Not as efficient for large queues compared to linked list implementation
+
+## Complexity Analysis
+
+- **Enqueue**: O(1) amortized time complexity
+- **Dequeue**: O(n) time complexity
+- **Peek**: O(1) time complexity
+- **Space Complexity**: O(n) where n is the number of elements in the queue

src/javascript/datastructures/queue/2.queue_with_linkedlist/queue_with_linkedlist.js

@@ -0,0 +1,95 @@
+class Node {
+ constructor(value) {
+ this.value = value;
+ this.next = null;
+ }
+}
+
+class MyQueue {
+ constructor() {
+ this.first = null;
+ this.last = null;
+ this.length = 0;
+ }
+
+ // Core queue operations
+ enqueue(value) {
+ const newNode = new Node(value);
+ if (this.isEmpty()) {
+ this.first = newNode;
+ this.last = newNode;
+ } else {
+ this.last.next = newNode;
+ this.last = newNode;
+ }
+ this.length++;
+ }
+
+ dequeue() {
+ if (this.isEmpty()) {
+ throw new Error("Queue Underflow: Cannot dequeue from an empty queue.");
+ }
+
+ const temp = this.first;
+ if (this.length === 1) {
+ this.first = null;
+ this.last = null;
+ } else {
+ this.first = this.first.next;
+ temp.next = null;
+ }
+
+ this.length--;
+ return temp.value;
+ }
+
+ peek() {
+ if (this.isEmpty()) {
+ throw new Error("Queue Underflow: Cannot peek from an empty queue.");
+ }
+ return this.first.value;
+ }
+
+ // Helper functions
+ isEmpty() {
+ return this.length === 0;
+ }
+
+ size() {
+ return this.length;
+ }
+
+ printQueue() {
+ let current = this.first;
+ const values = [];
+ while (current) {
+ values.push(current.value);
+ current = current.next;
+ }
+ return values.join(' ');
+ }
+}
+
+// Usage example
+function useQueue() {
+ const queue = new MyQueue();
+
+ console.log("Is empty?", queue.isEmpty()); // true
+
+ try {
+ queue.dequeue(); // Should throw
+ } catch (e) {
+ console.error(e.message);
+ }
+
+ queue.enqueue(1);
+ queue.enqueue(2);
+ queue.enqueue(3);
+
+ console.log("Queue contents:", queue.printQueue()); // 1 2 3
+ console.log("Front element:", queue.peek()); // 1
+ console.log("Dequeued element:", queue.dequeue()); // 1
+ console.log("Queue after dequeue:", queue.printQueue()); // 2 3
+}
+
+useQueue();