Merge pull request #77 from madhusudhan1234/notes

Notes

Author: madhusudhan1234

public/podcasts/fortytwo-episode.MP3

@@ -0,0 +1,130 @@
+---
+title: 'Data Structure: Circular Queue in JavaScript'
+description: 'A queue data structure that follows the FIFO (First-In-First-Out) principle. It is similar to a regular queue, but the last element is connected to the first element to form a circle.'
+pubDate: 'Jan 3 2026'
+tags: 'js-data-structure'
+---
+
+## Overview
+
+The size of the queue is fixed and a single block of memory is used as if the first element is connected to the last element to form a circle.
+
+Also referes to the circular buffer or ring buffer and follows the FIFO (First-In-First-Out) principle.
+
+A circular queue reuses the empty block created during the dequeue implementation.
+
+When working with queue of fixed maximum size, a circular queue is a great implementation choice.
+
+The circular Queue data structure supports two main operations.
+
+- Enqueue: Adds an element to the end of the queue.
+- Dequeue: Removes the element from the front of the queue.
+
+Circular Queue usage:
+- Clock 
+- Streaming data
+- Traffic Lights
+
+
+### Circular Queue Implementaiton
+- enqueue(element) - add an element to the queue
+- dequeue() - remove an element from the queue
+- isFull() - check if the queue is full
+- isEmpty() - check if the queue is empty
+- peek() - get the value of the element at the front of the queue without removing it
+- size() - get the number of elements in the queue
+- print() - print the elements in the queue
+
+
+```
+class CircularQueue {
+  constructor(capacity) {
+    this.items = new Array(capacity)
+    this.capacity = capacity
+    this.currentLength = 0
+    this.rear = -1
+    this.front = -1
+  }
+
+  isFull() {
+    return this.currentLength === this.capacity
+  }
+
+  isEmpty() {
+    return this.currentLength === 0
+  }
+
+  enqueue(element) {
+    if (!this.isFull()) {
+      this.rear = (this.rear+1) % this.capacity
+      this.items[this.rear] = element
+      this.currentLength += 1
+
+      if (this.front === -1) {
+        this.front = this.rear
+      }
+    }
+  }
+
+  dequeue() {
+    if (this.isEmpty()) {
+        return null
+    }
+
+    const item = this.items[this.front]
+    this.items[this.front] = null
+    this.front = (this.front+1) % this.capacity
+    this.currentLength -= 1
+    if (this.isEmpty()) {
+      this.front = -1
+      this.rear = -1
+    }
+    return item
+  }
+
+
+  peek() {
+    if (!this.isEmpty()) {
+      return this.items[this.front]
+    }
+
+    return null
+  }
+
+  print() {
+    if (this.isEmpty()) {
+      console.log('Queue is empty')
+    } else {
+      let i
+      let str = ''
+      for (i = this.front; i !== this.rear; i = (i+1) % this.capacity) {
+        str += this.items[i] + ' '
+      }
+      str += this.items[i]
+      console.log(str)
+    }
+  }
+}
+```
+
+This is the implementation for the circular queue data structure in JavaScript. Let's check if it workks correctly.
+
+```
+const circularQueue = new CircularQueue(5)
+console.log(circularQueue.isEmpty()) // true
+
+circularQueue.enqueue(10)
+circularQueue.enqueue(20)
+circularQueue.enqueue(30)
+console.log(circularQueue.size()) // 3
+circularQueue.print() // 10,20,30
+
+circularQueue.enqueue(40)
+circularQueue.enqueue(50)
+console.log(circularQueue.size()) // 5
+circularQueue.print() // 10,20,30,40,50
+
+console.log(circularQueue.isFull()) // true
+```
+
+

src/content/notes/data-structure-circular-queue-in-javascript.md

@@ -0,0 +1,147 @@
+---
+title: 'Data Structure: Queue in JavaScript'
+description: 'FIFO structure, operations, array/class implementations, performance, and pitfalls.'
+pubDate: 'Jan 4 2026'
+tags: 'js-data-structure'
+---
+
+## Overview
+
+The Queue data structure is a sequential collection of elements that follows the principle of First In First Out (FIFO).
+
+The first element inserted into the queue is the first element to be removed.
+
+A queue of people. People enter the queue at one end (rear/tail) and leave the queue from the other end (front/head).
+
+Queue is an abstract data structure. It is defined by behavior rather than being a mathematical model.
+
+The queue data structure supports two main operations.
+
+- Enqueue: Add an element to the end of the queue.
+- Dequeue: Remove the element from the front of the queue.
+
+Queue is useful when we have to do some operations in a particular order.
+
+For e.g: 
+- Printer to print multiple document
+- CPU task scheduling
+- Callback Queue in JavaScript
+
+
+### Queue Implementation
+- enqueue(element): add an element to the queue
+- dequeue - remove the oldest element from queue
+- peek - get the value of the element at the front of the queue without removing it.
+- isEmpty - check is the queue is empty
+- size - get the number of the element in a queue
+- print - visualize the elements in the queue
+
+```
+class Queue {
+  constructor() {
+    this.items = []
+  }
+
+  enqueue(element) {
+    this.items.push(element)
+  }
+
+  dequeue() {
+    return this.items.shift()
+  }
+
+  peek() {
+    if (this.isEmpty()) {
+      return null
+    }
+
+    return this.items[0]
+  }
+
+  isEmpty() {
+    return this.items.length === 0
+  }
+
+  size() {
+    return this.items.length
+  }
+
+  print() {
+    console.log(this.items.toString())
+  }
+}
+```
+
+Let's instantiate the Queue class.
+
+```
+const queue = new Queue()
+
+console.log(queue.isEmpty()) // true
+queue.enqueue(10)
+queue.enqueue(20)
+queue.enqueue(30)
+console.log(queue.size()) // 3
+queue.print() // 10,20,30
+
+
+console.log(queue.dequeue()) // 10
+console.log(queue.peek()) // 20
+```
+
+Here if you see the implmentation return this.items.shift() it remove the first element from the queue. This is going to be complexity of O(n) because it re-index the array after removing the first element.
+
+```
+class Queue {
+  constructor() {
+    this.items = {}
+    this.rear = 0
+    this.front = 0
+  }
+
+  enqueue(element) {
+    this.items[this.rear] = element
+    this.rear++
+  }
+
+  dequeue() {
+    const item = this.items[this.front]
+    delete this.items[this.front]
+    this.front++
+    return item
+  }
+
+  isEmpty() {
+    return this.rear - this.front === 0
+  }
+
+  peek() {
+    return this.items[this.front]
+  }
+
+  size() {
+    return this.rear - this.front
+  }
+
+  print() {
+    console.log(this.items.toString())
+  }
+}
+```
+
+That is the optimized version of the queue implementation. How to use this class is similar to the previous implementation.
+
+```
+const queue = new Queue()
+
+console.log(queue.isEmpty()) // true
+queue.enqueue(10)
+queue.enqueue(20)
+queue.enqueue(30)
+console.log(queue.size()) // 3
+queue.print() // 10,20,30
+
+
+console.log(queue.dequeue()) // 10
+console.log(queue.peek()) // 20
+```

src/content/notes/data-structure-queue-in-javascript.md

@@ -0,0 +1,100 @@
+---
+title: 'Data Structure: Stack in JavaScript'
+description: 'LIFO structure, operations, implementations, performance, and pitfalls using arrays and classes.'
+pubDate: 'Jan 4 2026'
+tags: 'js-data-structure'
+---
+
+## Overview
+
+The stack data structure is a sequential collection of elements that follows the principle of last in first out (LIFO).
+
+The last element inserted into the stack is the first element to be removed.
+
+A stack of plates, The last plate placed on top of the stack is also the first plate removed from the stack.
+
+Stack is an abstract data type. It is defined by it's behavior rather than being a mathematical model.
+
+The stack data structure supports two main operations:
+
+- Push: Add an element to the top of the stack.
+- Pop: Remove the element from the top of the stack.
+
+
+Stack Usage:
+
+- Browser history tracking
+- undo operations while typing
+- Expression conversation
+- Call Stack in Javascript runtime
+
+```
+class Stack {
+  constructor() {
+    this.items = [];
+  }
+
+  // Add element to top of stack
+  push(element) {
+    this.items.push(element);
+  }
+
+  // Remove and return top element
+  pop() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    return this.items.pop();
+  }
+
+  // View top element without removing
+  peek() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    return this.items[this.items.length - 1];
+  }
+
+  // Check if stack is empty
+  isEmpty() {
+    return this.items.length === 0;
+  }
+
+  // Get stack size
+  size() {
+    return this.items.length;
+  }
+
+  // Clear all elements
+  clear() {
+    this.items = [];
+  }
+
+  // Print stack contents
+  print() {
+    console.log(this.items.toString());
+  }
+}
+
+// Example usage
+const stack = new Stack();
+stack.push(10);
+stack.push(20);
+stack.push(30);
+console.log(stack.peek()); // 30
+console.log(stack.pop());  // 30
+console.log(stack.size()); // 2
+```
+
+
+## Big‑O Complexity
+
+| Operation | Complexity |
+| --------- | ---------- |
+| push      | O(1)       |
+| pop       | O(1)       |
+| peek      | O(1)       |
+| size      | O(1)       |
+| iterate   | O(n)       |
+
+