feat(bst): implement balanced binary search tree with traversal, balance, and rebalance support

singharyan006 · singharyan006 · commit ead784cbf856 · 2025-07-13T21:52:05.000+05:30
diff --git a/binary-search-tree/Node.js b/binary-search-tree/Node.js
@@ -0,0 +1,7 @@
+export default class Node {
+    constructor(data) {
+        this.data = data;
+        this.left = null;
+        this.right = null;
+    }
+}
diff --git a/binary-search-tree/README.md b/binary-search-tree/README.md
@@ -0,0 +1,174 @@
+# 🌳 Binary Search Tree (BST) — The Odin Project
+
+A Binary Search Tree (BST) is a hierarchical data structure where each node has:
+- At most two children
+- Left child < Parent
+- Right child > Parent
+
+This project implements a **balanced BST** from scratch and covers all common operations.
+
+---
+
+## 📚 Node & Tree Overview
+
+### ✅ Node Structure
+Each node holds:
+- `data`: the value
+- `left`: reference to the left child
+- `right`: reference to the right child
+
+```js
+class Node {
+  constructor(data) {
+    this.data = data;
+    this.left = null;
+    this.right = null;
+  }
+}
+```
+---
+
+## ✅ Tree Class
+
+The `Tree` class:
+- Accepts an array
+- Builds a balanced BST
+- Provides methods to insert, delete, traverse, check balance, etc.
+
+---
+
+## ⚙️ Core Methods
+
+### 🔨 buildTree(array)
+- Removes duplicates
+- Sorts the array
+- Recursively selects the middle element as the root
+- Balances the tree by design
+
+```js
+[1, 2, 3, 4, 5, 6, 7]
+         ⬇️
+        (4)
+      /     \
+    (2)     (6)
+   /  \     /  \
+ (1) (3) (5)  (7)
+ ```
+ ---
+
+## ➕ insert(value)
+Adds a value while preserving BST rules.
+
+---
+
+## ➖ deleteItem(value)
+Deletes a node while handling:
+- No children
+- One child
+- Two children (replace with in-order successor)
+
+---
+
+## 🔍 find(value)
+Searches for a value in **O(log n)** time (if balanced).
+
+---
+
+## 🔄 Tree Traversals
+Each function accepts a callback (e.g., `node => console.log(node.data)`):
+
+### 🌐 levelOrderForEach(callback)
+- Breadth-first traversal
+- Uses a queue
+
+### 🧭 inOrderForEach(callback)
+- Left → Root → Right
+- Yields sorted values in BST
+
+### 🧭 preOrderForEach(callback)
+- Root → Left → Right
+
+### 🧭 postOrderForEach(callback)
+- Left → Right → Root
+
+---
+
+## 📏 Tree Measurements
+
+### 📐 height(value)
+- Number of edges in longest path from node to a leaf.
+
+### 📏 depth(value)
+- Number of edges from root to the node.
+
+---
+
+## ✅ Balancing
+
+### 🔄 isBalanced()
+A tree is balanced if:
+- Heights of left and right subtrees of every node differ by ≤ 1
+- Both subtrees are balanced
+
+### 🧘 rebalance()
+- Traverses in-order to collect all values
+- Rebuilds tree using `buildTree`
+
+---
+
+## 🧪 Driver Script
+```js
+// Create a tree
+const tree = new Tree([1, 7, 4, 23, 8, 9, 4, 3, 5, 7, 9, 67, 6345, 324]);
+
+tree.insert(101);
+tree.insert(150);
+tree.insert(203);
+
+console.log(tree.isBalanced()); // false
+
+tree.rebalance();
+
+console.log(tree.isBalanced()); // true
+```
+---
+
+## 🖼️ prettyPrint()
+A function to visualize the tree:
+
+```js
+const prettyPrint = (node, prefix = '', isLeft = true) => { ... }
+prettyPrint(tree.root);
+```
+Example output:
+```bash
+        ┌── 67
+    ┌── 23
+    │   └── 9
+└── 7
+    └── 4
+```
+---
+
+## 🧠 Key Takeaways
+
+- BST enables fast **search, insert, delete** — O(log n) if balanced.
+- **Balance is crucial** for performance.
+- Traversals reveal structural and logical properties of the tree.
+- Practice **recursion deeply** — it’s everywhere in trees.
+
+---
+
+## ✅ Tasks Completed (TOP Milestones)
+
+- [x] Node class  
+- [x] Tree class with `buildTree`  
+- [x] Insertion & deletion logic  
+- [x] Find method  
+- [x] All four traversals with callback support  
+- [x] `height()` and `depth()`  
+- [x] `isBalanced()` and `rebalance()`  
+- [x] Driver script and visualization  
+
+---
+
diff --git a/binary-search-tree/Tree.js b/binary-search-tree/Tree.js
@@ -0,0 +1,146 @@
+import Node from './Node.js';
+
+export default class Tree {
+  constructor(array) {
+    this.root = this.buildTree(array);
+  }
+
+  buildTree(array) {
+    const sorted = [...new Set(array)].sort((a, b) => a - b);
+    return this.buildBalancedTree(sorted);
+  }
+
+  buildBalancedTree(sorted) {
+    if (!sorted.length) return null;
+
+    const mid = Math.floor(sorted.length / 2);
+    const root = new Node(sorted[mid]);
+
+    root.left = this.buildBalancedTree(sorted.slice(0, mid));
+    root.right = this.buildBalancedTree(sorted.slice(mid + 1));
+
+    return root;
+  }
+
+  insert(value, root = this.root) {
+    if (root === null) return new Node(value);
+
+    if (value < root.data) {
+      root.left = this.insert(value, root.left);
+    } else if (value > root.data) {
+      root.right = this.insert(value, root.right);
+    }
+
+    return root;
+  }
+
+  deleteItem(value, root = this.root) {
+    if (root === null) return null;
+
+    if (value < root.data) {
+      root.left = this.deleteItem(value, root.left);
+    } else if (value > root.data) {
+      root.right = this.deleteItem(value, root.right);
+    } else {
+      if (!root.left) return root.right;
+      if (!root.right) return root.left;
+
+      const minLargerNode = this.findMin(root.right);
+      root.data = minLargerNode.data;
+      root.right = this.deleteItem(minLargerNode.data, root.right);
+    }
+    return root;
+  }
+
+  findMin(node) {
+    while (node.left !== null) node = node.left;
+    return node;
+  }
+
+  find(value, root = this.root) {
+    if (!root || root.data === value) return root;
+    return value < root.data
+      ? this.find(value, root.left)
+      : this.find(value, root.right);
+  }
+
+  levelOrderForEach(callback) {
+    if (!callback) throw new Error("Callback is required");
+    const queue = [this.root];
+    while (queue.length) {
+      const node = queue.shift();
+      callback(node);
+      if (node.left) queue.push(node.left);
+      if (node.right) queue.push(node.right);
+    }
+  }
+
+  inOrderForEach(callback, node = this.root) {
+    if (!callback) throw new Error("Callback is required");
+    if (node === null) return;
+    this.inOrderForEach(callback, node.left);
+    callback(node);
+    this.inOrderForEach(callback, node.right);
+  }
+
+  preOrderForEach(callback, node = this.root) {
+    if (!callback) throw new Error("Callback is required");
+    if (node === null) return;
+    callback(node);
+    this.preOrderForEach(callback, node.left);
+    this.preOrderForEach(callback, node.right);
+  }
+
+  postOrderForEach(callback, node = this.root) {
+    if (!callback) throw new Error("Callback is required");
+    if (node === null) return;
+    this.postOrderForEach(callback, node.left);
+    this.postOrderForEach(callback, node.right);
+    callback(node);
+  }
+
+  height(value) {
+    const node = this.find(value);
+    if (!node) return null;
+
+    const getHeight = (node) => {
+      if (!node) return -1;
+      return 1 + Math.max(getHeight(node.left), getHeight(node.right));
+    };
+
+    return getHeight(node);
+  }
+
+  depth(value, node = this.root, depthCount = 0) {
+    if (!node) return null;
+    if (node.data === value) return depthCount;
+
+    if (value < node.data) return this.depth(value, node.left, depthCount + 1);
+    return this.depth(value, node.right, depthCount + 1);
+  }
+
+  isBalanced(root = this.root) {
+    if (!root) return true;
+
+    const height = (node) => {
+      if (!node) return -1;
+      return 1 + Math.max(height(node.left), height(node.right));
+    };
+
+    const leftHeight = height(root.left);
+    const rightHeight = height(root.right);
+
+    const balanced =
+      Math.abs(leftHeight - rightHeight) <= 1 &&
+      this.isBalanced(root.left) &&
+      this.isBalanced(root.right);
+
+    return balanced;
+  }
+
+  rebalance() {
+    const values = [];
+    this.inOrderForEach((node) => values.push(node.data));
+    this.root = this.buildBalancedTree(values);
+  }
+}
diff --git a/binary-search-tree/driver.js b/binary-search-tree/driver.js
@@ -0,0 +1,41 @@
+import Tree from './Tree.js';
+import prettyPrint from './prettyPrint.js';
+
+function getRandomArray(length = 10, max = 100) {
+  return Array.from({ length }, () => Math.floor(Math.random() * max));
+}
+
+const randomData = getRandomArray();
+const tree = new Tree(randomData);
+
+console.log('Initial Tree:');
+prettyPrint(tree.root);
+
+console.log('Is Balanced:', tree.isBalanced());
+
+console.log('Level Order:');
+tree.levelOrderForEach((node) => console.log(node.data));
+
+console.log('Pre Order:');
+tree.preOrderForEach((node) => console.log(node.data));
+
+console.log('Post Order:');
+tree.postOrderForEach((node) => console.log(node.data));
+
+console.log('In Order:');
+tree.inOrderForEach((node) => console.log(node.data));
+
+// Unbalancing
+tree.insert(150);
+tree.insert(200);
+tree.insert(300);
+
+console.log('\nUnbalanced Tree:');
+prettyPrint(tree.root);
+console.log('Is Balanced:', tree.isBalanced());
+
+// Rebalancing
+tree.rebalance();
+console.log('\nRebalanced Tree:');
+prettyPrint(tree.root);
+console.log('Is Balanced:', tree.isBalanced());
diff --git a/binary-search-tree/prettyPrint.js b/binary-search-tree/prettyPrint.js
@@ -0,0 +1,12 @@
+const prettyPrint = (node, prefix = '', isLeft = true) => {
+  if (node === null) return;
+  if (node.right !== null) {
+    prettyPrint(node.right, `${prefix}${isLeft ? '│   ' : '    '}`, false);
+  }
+  console.log(`${prefix}${isLeft ? '└── ' : '┌── '}${node.data}`);
+  if (node.left !== null) {
+    prettyPrint(node.left, `${prefix}${isLeft ? '    ' : '│   '}`, true);
+  }
+};
+
+export default prettyPrint;
