Why BST Over Plain Binary Tree in DSA Javascript - Why It Works

Concept Flow - Why BST Over Plain Binary Tree

Start with Plain Binary Tree

↓

Insert nodes anywhere

↓

No order: left/right child any value

↓

Search: must check all nodes

↓

Time: O(n) worst case

↓

Switch to BST

↓

Insert nodes with order: left < parent < right

↓

Search: go left or right based on value

↓

Time: O(log n) average

↓

More efficient search, insert, delete

Shows how a plain binary tree inserts nodes without order causing slow search, while BST keeps order for faster search.

Execution Sample

DSA Javascript

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

Defines a node structure used in both plain binary tree and BST.

Execution Table

Step	Operation	Nodes in Tree	Pointer Changes	Visual State
1	Insert 10 in Plain Binary Tree	10	root -> Node(10)	10
2	Insert 5 in Plain Binary Tree (no order)	10, 5	root.left -> Node(5)	10 / 5
3	Insert 15 in Plain Binary Tree (no order)	10, 5, 15	root.right -> Node(15)	10 / \ 5 15
4	Search 15 in Plain Binary Tree	10, 5, 15	Traverse nodes 10 -> 5 -> 15	Must check all nodes until found
5	Insert 10 in BST	10	root -> Node(10)	10
6	Insert 5 in BST (5 < 10)	10, 5	root.left -> Node(5)	10 / 5
7	Insert 15 in BST (15 > 10)	10, 5, 15	root.right -> Node(15)	10 / \ 5 15
8	Search 15 in BST	10, 5, 15	Traverse nodes 10 -> 15 (skip 5)	Search faster by choosing right branch
9	Search 7 in BST (not found)	10, 5, 15	Traverse nodes 10 -> 5 (stop, no right child)	Stops early, no full traversal
10	End	10, 5, 15	No changes	Search and insert efficient in BST

💡 Execution stops after demonstrating search and insert differences between plain binary tree and BST.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 5	After Step 6	After Step 7	After Step 8	Final
root (Plain Binary Tree)	null	Node(10)	Node(10) with left=Node(5)	Node(10) with left=Node(5), right=Node(15)	Node(10) with left=Node(5), right=Node(15)	Node(10) with left=Node(5), right=Node(15)	Node(10) with left=Node(5), right=Node(15)	Node(10) with left=Node(5), right=Node(15)	Node(10) with left=Node(5), right=Node(15)
root (BST)	null	null	null	null	Node(10)	Node(10) with left=Node(5)	Node(10) with left=Node(5), right=Node(15)	Node(10) with left=Node(5), right=Node(15)	Node(10) with left=Node(5), right=Node(15)

Key Moments - 3 Insights

Why does searching in a plain binary tree take longer?

Because nodes are inserted without order, search must check every node (see execution_table steps 4 and 9).

How does BST improve search speed?

BST keeps nodes ordered so search goes left or right based on value, skipping many nodes (see execution_table step 8).

Why does BST stop searching early when value not found?

Because it follows order rules, if the path ends without finding the value, it stops early (see execution_table step 9).

Visual Quiz - 3 Questions

Look at the execution table, at which step does BST insert the node with value 5?

A Step 2

B Step 3

C Step 6

D Step 7

💡 Hint

Check the 'Operation' column for BST insertions after step 4.

At which step does searching in the plain binary tree check all nodes?

A Step 8

B Step 4

C Step 9

D Step 6

💡 Hint

Look for 'Search' operation in plain binary tree in the execution_table.

If we insert nodes in BST without order, how would the search time change?

A It would become O(n)

B It would stay O(log n)

C It would become O(1)

D It would be unpredictable

💡 Hint

Refer to key_moments about search efficiency and execution_table steps 4 and 8.

Concept Snapshot

Plain Binary Tree inserts nodes anywhere without order.
Search must check all nodes, time O(n).
BST inserts nodes with order: left < parent < right.
Search goes left or right, time O(log n) average.
BST is faster for search, insert, and delete operations.

Full Transcript

This visual shows why a Binary Search Tree (BST) is better than a plain binary tree. In a plain binary tree, nodes are added anywhere without order, so searching means checking every node, which takes longer. In a BST, nodes are added in order: smaller values go left, bigger go right. This order lets us skip many nodes when searching, making it faster. The execution table shows inserting and searching nodes in both trees, highlighting how BST improves efficiency by reducing the number of nodes checked.