BST Property and Why It Matters in DSA Javascript

Mental Model

A Binary Search Tree keeps smaller values on the left and bigger values on the right, making it easy to find things fast.

Analogy: Imagine a library where books are arranged so all books with titles starting with A-M are on the left shelves and N-Z on the right shelves. This helps you find a book quickly without checking every shelf.

      10
     /  \
    5    15
   / \     \
  3   7     20

Dry Run Walkthrough

Input: BST with nodes 10, 5, 15, 3, 7, 20; search for value 7

Goal: Show how BST property helps find 7 quickly by deciding left or right at each step

Step 1: Start at root node 10

      [10↑]
     /    \
    5      15
   / \       \
  3   7       20

Why: We always start searching from the root

Step 2: Compare 7 with 10; 7 is less, go left

      10
     /    \
    [5↑]   15
   /  \      \
  3    7      20

Why: BST property says smaller values are on the left

Step 3: Compare 7 with 5; 7 is greater, go right

      10
     /    \
    5      15
   /   \     \
  3    [7↑]   20

Why: BST property says bigger values are on the right

Step 4: Found node with value 7

      10
     /    \
    5      15
   /   \     \
  3    7↑    20

Why: We stop when we find the value

Result:

      10
     /    \
    5      15
   /   \     \
  3    7↑    20
Answer: Found 7

Annotated Code

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(value) {
    const newNode = new Node(value);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    let curr = this.root;
    while (true) {
      if (value < curr.value) {
        if (!curr.left) {
          curr.left = newNode;
          return;
        }
        curr = curr.left; // move left
      } else {
        if (!curr.right) {
          curr.right = newNode;
          return;
        }
        curr = curr.right; // move right
      }
    }
  }

  search(value) {
    let curr = this.root;
    while (curr) {
      if (value === curr.value) {
        return true; // found
      } else if (value < curr.value) {
        curr = curr.left; // go left
      } else {
        curr = curr.right; // go right
      }
    }
    return false; // not found
  }
}

// Driver code
const bst = new BST();
[10, 5, 15, 3, 7, 20].forEach(v => bst.insert(v));
const found = bst.search(7);
console.log(found ? 'Found 7' : '7 not found');

let curr = this.root;

start searching from root node

if (value === curr.value) { return true; }

check if current node is the target

else if (value < curr.value) { curr = curr.left; }

go left if target is smaller

else { curr = curr.right; }

go right if target is bigger

Output

Found 7

Complexity Analysis

Time: O(h) where h is tree height because we follow one path down the tree

Space: O(1) because search uses only a few variables, no extra space grows with input

vs Alternative: Compared to searching an unsorted tree or list which is O(n), BST search is faster if tree is balanced

Edge Cases

searching in an empty tree

returns false immediately because root is null

DSA Javascript

let curr = this.root;

searching for a value smaller than all nodes

traverses left until null and returns false

DSA Javascript

curr = curr.left;

searching for a value larger than all nodes

traverses right until null and returns false

DSA Javascript

curr = curr.right;

When to Use This Pattern

When you need fast search, insert, or delete in a sorted collection, look for BST property to guide your tree traversal efficiently.

Common Mistakes

Mistake: Not comparing values correctly and going the wrong way in the tree
Fix: Always compare target with current node value and go left if smaller, right if bigger

Summary

It keeps smaller values on the left and bigger on the right to speed up search.

Use it when you want to find, add, or remove items quickly in a sorted way.

The key is deciding direction at each node by comparing values, so you don't check everything.