BST Property and Why It Matters in DSA C# - Time & Space Complexity

Time Complexity: BST Property and Why It Matters

O(h)

Understanding Time Complexity

We want to understand how the special order in a Binary Search Tree (BST) affects how fast we can find or add items.

How does this order help us do things faster compared to a random tree?

Scenario Under Consideration

Analyze the time complexity of searching a value in a BST.

public bool Search(Node root, int target) {
    if (root == null) return false;
    if (root.Value == target) return true;
    if (target < root.Value) return Search(root.Left, target);
    else return Search(root.Right, target);
}
    

This code looks for a number in a BST by moving left or right depending on the value.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Recursive calls moving down one node at a time.
• How many times: At most once per tree level until the value is found or a leaf is reached.

How Execution Grows With Input

Each step moves down one level of the tree, so the number of steps depends on the tree's height.

Input Size (n)	Approx. Operations (steps)
10	About 4 steps (height ~ log2(10))
100	About 7 steps (height ~ log2(100))
1000	About 10 steps (height ~ log2(1000))

Pattern observation: The steps grow slowly as input grows, roughly doubling input adds only one extra step.

Final Time Complexity

Time Complexity: O(h) where h is the tree height

This means the search time depends on how tall the tree is, not just how many items it has.

Common Mistake

[X] Wrong: "Searching a BST always takes O(log n) time because it is a tree."

[OK] Correct: If the tree is not balanced, it can become tall like a linked list, making search take O(n) time.

Interview Connect

Understanding how the BST property affects search speed helps you explain why balanced trees matter and shows you can analyze real data structures clearly.

Self-Check

"What if the BST is always perfectly balanced? How would that change the search time complexity?"

Practice

1. What is the main property that defines a Binary Search Tree (BST)?

easy

A. Each node has exactly two children.

B. For each node, all values in the left subtree are smaller, and all values in the right subtree are larger.

C. All nodes have the same value.

D. Nodes are arranged in a circular linked list.

Solution

1. Step 1: Understand BST node arrangement

   A BST is defined by the rule that for every node, values in the left subtree are smaller and values in the right subtree are larger.

2. Step 2: Compare options with BST definition

   For each node, all values in the left subtree are smaller, and all values in the right subtree are larger. matches the BST property exactly, while others describe different or incorrect structures.

3. Final Answer:

   For each node, all values in the left subtree are smaller, and all values in the right subtree are larger. -> Option B

4. Quick Check:

   BST property = For each node, all values in the left subtree are smaller, and all values in the right subtree are larger. [OK]

Hint: Remember: left < node < right for BST nodes [OK]

Common Mistakes:

• Thinking BST nodes must have two children
• Confusing BST with binary tree
• Assuming all nodes have same value

2. Which of the following is the correct C# syntax to declare a BST node class with integer value and left/right children?

easy

A. public class Node { public int Value; public Node Left; public Node Right; }

B. class Node { int Value; Node Left, Right; }

C. public struct Node { int Value; Node Left; Node Right; }

D. Node { int Value; Node Left; Node Right; }

Solution

1. Step 1: Check class declaration syntax in C#

   In C#, classes are declared with 'public class ClassName' and members with access modifiers.

2. Step 2: Validate member declarations

   public class Node { public int Value; public Node Left; public Node Right; } correctly declares public fields for value and child nodes. class Node { int Value; Node Left, Right; } misses access modifiers and uses shorthand which is less clear. public struct Node { int Value; Node Left; Node Right; } uses struct which is less common for nodes. Node { int Value; Node Left; Node Right; } is invalid syntax.

3. Final Answer:

   public class Node { public int Value; public Node Left; public Node Right; } -> Option A

4. Quick Check:

   Correct C# class syntax = public class Node { public int Value; public Node Left; public Node Right; } [OK]

Hint: Use 'public class' and public fields for node members [OK]

Common Mistakes:

• Omitting access modifiers
• Using struct instead of class for nodes
• Incorrect class syntax

3. Given the following BST insertion code snippet, what will be the in-order traversal output after inserting values 10, 5, 15, 7?

medium

A. 5 -> 7 -> 10 -> 15 -> null

B. 10 -> 5 -> 7 -> 15 -> null

C. 7 -> 5 -> 10 -> 15 -> null

D. 15 -> 10 -> 7 -> 5 -> null

Solution

1. Step 1: Insert values into BST following property

   Insert 10 as root. Insert 5 to left of 10. Insert 15 to right of 10. Insert 7 to right of 5.

2. Step 2: Perform in-order traversal (left, node, right)

   Traverse left subtree: 5 then 7, then root 10, then right subtree 15.

3. Final Answer:

   5 -> 7 -> 10 -> 15 -> null -> Option A

4. Quick Check:

   In-order traversal sorts BST values ascending [OK]

Hint: In-order traversal of BST gives sorted values [OK]

Common Mistakes:

• Confusing insertion order with traversal order
• Incorrectly placing 7 in BST
• Mixing traversal types

4. Identify the bug in this BST insertion method snippet:

public Node Insert(Node root, int val) {
  if (root == null) return new Node { Value = val };
  if (val < root.Value) Insert(root.Left, val);
  else Insert(root.Right, val);
  return root;
}

medium

A. The method should return void instead of Node.

B. The base case should return null instead of new Node.

C. The method does not assign the returned node to root.Left or root.Right after recursion.

D. The comparison operator should be val <= root.Value.

Solution

1. Step 1: Analyze recursive calls in insertion

   The recursive calls Insert(root.Left, val) and Insert(root.Right, val) do not update root.Left or root.Right with returned nodes.

2. Step 2: Understand why assignment is needed

   Without assigning, new nodes are created but not linked to the tree, breaking BST structure.

3. Final Answer:

   The method does not assign the returned node to root.Left or root.Right after recursion. -> Option C

4. Quick Check:

   Assign recursive result to child nodes [OK]

Hint: Always assign recursive insert result to child pointers [OK]

Common Mistakes:

• Forgetting to assign recursive call results
• Changing base case incorrectly
• Misunderstanding return types

5. Why is maintaining the BST property important when deleting a node from a BST?

hard

A. To ensure the tree remains balanced and search operations stay efficient.

B. Because BSTs do not allow deletion of nodes without this property.

C. To prevent memory leaks in the program.

D. Because violating the property can cause incorrect search results and break traversal order.

Solution

1. Step 1: Understand BST property role in search and traversal

   The BST property ensures that searching and traversing nodes in order works correctly.

2. Step 2: Analyze effect of violating BST property after deletion

   If the property is broken, search may miss nodes or return wrong results, and in-order traversal won't be sorted.

3. Final Answer:

   Because violating the property can cause incorrect search results and break traversal order. -> Option D

4. Quick Check:

   Maintaining BST property preserves correct search and traversal [OK]

Hint: Keep BST property to keep search and traversal correct [OK]

Common Mistakes:

• Confusing balance with BST property
• Thinking deletion is not allowed
• Assuming memory leaks relate to BST property