Kth Smallest Element in BST in DSA C#

Mental Model

A binary search tree keeps smaller values on the left and bigger on the right. To find the kth smallest, we visit nodes in order from smallest to largest.

Analogy: Imagine a bookshelf sorted by book size from left to right. To find the kth smallest book, you start from the left and count books one by one until you reach k.

      5
     / \
    3   7
   / \   \
  2   4   8
 ↑

Dry Run Walkthrough

Input: BST: 5 -> 3 -> 7 -> 2 -> 4 -> 8, find 3rd smallest element

Goal: Find the 3rd smallest value in the BST

Step 1: Start in-order traversal at root (5), go left to 3

      5
     / \
    3   7
   / \   \
  2   4   8
 ↑ (at 3)

Why: Left subtree has smaller values, so we start there

Step 2: Go left from 3 to 2 (smallest node)

      5
     / \
    3   7
   / \   \
  2   4   8
 ↑ (at 2)

Why: Leftmost node is the smallest value

Step 3: Visit 2 (count=1), move back to 3

2 (visited, count=1) -> 3 ↑ -> 4 -> 5 -> 7 -> 8

Why: Count the smallest node, then move to parent

Step 4: Visit 3 (count=2), move right to 4

2 -> 3 (visited, count=2) -> 4 ↑ -> 5 -> 7 -> 8

Why: Next smallest is parent, then right child

Step 5: Visit 4 (count=3), stop traversal

2 -> 3 -> 4 (visited, count=3) -> 5 -> 7 -> 8

Why: Reached kth smallest element

Result:

2 -> 3 -> 4 (3rd smallest element is 4)

Annotated Code

DSA C#

using System;

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public class Solution {
    private int count = 0;
    private int result = -1;

    public int KthSmallest(TreeNode root, int k) {
        InOrder(root, k);
        return result;
    }

    private void InOrder(TreeNode node, int k) {
        if (node == null || count >= k) return; // stop if node null or kth found

        InOrder(node.left, k); // traverse left subtree

        count++;
        if (count == k) {
            result = node.val; // found kth smallest
            return;
        }

        InOrder(node.right, k); // traverse right subtree
    }
}

public class Program {
    public static void Main() {
        TreeNode root = new TreeNode(5,
            new TreeNode(3,
                new TreeNode(2),
                new TreeNode(4)),
            new TreeNode(7,
                null,
                new TreeNode(8)));

        Solution sol = new Solution();
        int k = 3;
        int kthSmallest = sol.KthSmallest(root, k);
        Console.WriteLine(kthSmallest);
    }
}

if (node == null || count >= k) return; // stop if node null or kth found

stop traversal when no node or kth element found

InOrder(node.left, k); // traverse left subtree

explore smaller values first

count++;

increment count on visiting a node

if (count == k) { result = node.val; return; }

record kth smallest and stop

InOrder(node.right, k); // traverse right subtree

explore larger values after left and current

Output

4

Complexity Analysis

Time: O(h + k) because we traverse down the tree height h and visit k nodes in order

Space: O(h) due to recursion stack for tree height h

vs Alternative: Naive approach sorts all nodes O(n log n), this uses BST property to stop early, saving time

Edge Cases

k is 1 (smallest element)

Returns the leftmost node value

DSA C#

if (count == k) { result = node.val; return; }

k equals number of nodes (largest element)

Traversal visits all nodes in order and returns largest

DSA C#

if (count == k) { result = node.val; return; }

Empty tree (root is null)

Returns -1 as default result since no nodes

DSA C#

if (node == null || count >= k) return;

When to Use This Pattern

When asked for the kth smallest or largest in a BST, use in-order traversal because it visits nodes in sorted order.

Common Mistakes

Mistake: Not stopping traversal after finding kth element, causing unnecessary work
Fix: Add a condition to stop recursion once kth element is found

Mistake: Using pre-order or post-order traversal which does not guarantee sorted order
Fix: Use in-order traversal to visit nodes in ascending order

Summary

Finds the kth smallest value in a binary search tree using in-order traversal.

Use when you need the kth smallest or kth largest element in a BST efficiently.

In-order traversal visits nodes in ascending order, so counting nodes visited gives the kth smallest.

Practice

1. What does the Kth Smallest Element in BST problem ask you to find?

easy

A. The largest element in the Binary Search Tree

B. The height of the Binary Search Tree

C. The element that is the Kth smallest value in the Binary Search Tree

D. The number of nodes in the Binary Search Tree

Solution

1. Step 1: Understand the problem statement

   The problem asks to find the Kth smallest element, meaning the element that would appear in position K if the BST elements were sorted.

2. Step 2: Recognize BST property

   In a BST, an inorder traversal visits nodes in ascending order, so the Kth visited node is the Kth smallest.

3. Final Answer:

   The element that is the Kth smallest value in the Binary Search Tree -> Option C

4. Quick Check:

   Kth smallest = Kth visited in inorder traversal [OK]

Hint: Inorder traversal gives sorted order; pick Kth node [OK]

Common Mistakes:

• Confusing Kth smallest with Kth largest
• Ignoring BST property and sorting separately
• Using preorder or postorder traversal instead of inorder

2. Which of the following C# method signatures correctly represents a function to find the Kth smallest element in a BST node class named TreeNode?

easy

A. public int KthSmallest(TreeNode root, int k)

B. public void KthSmallest(int root, int k)

C. public int KthSmallest(TreeNode root)

D. public int KthSmallest(int k)

Solution

1. Step 1: Identify correct parameter types

   The method needs the root node of type TreeNode and an integer k to find the Kth smallest element.

2. Step 2: Check return type and parameters

   The method returns an int (the value of the Kth smallest node) and takes TreeNode root and int k as parameters.

3. Final Answer:

   public int KthSmallest(TreeNode root, int k) -> Option A

4. Quick Check:

   Correct signature includes root node and k as parameters [OK]

Hint: Method needs root node and k as inputs, returns int [OK]

Common Mistakes:

• Using void return type instead of int
• Missing root node parameter
• Using wrong parameter types

3. Given the BST below and k = 3, what will the following C# code print?

class TreeNode {
  public int val;
  public TreeNode left, right;
  public TreeNode(int v) { val = v; }
}

// BST structure:
//       5
//      / \
//     3   7
//    / \   \
//   2   4   8

int KthSmallest(TreeNode root, int k) {
  List<int> vals = new List<int>();
  void Inorder(TreeNode node) {
    if (node == null) return;
    Inorder(node.left);
    vals.Add(node.val);
    Inorder(node.right);
  }
  Inorder(root);
  return vals[k - 1];
}

TreeNode root = new TreeNode(5);
root.left = new TreeNode(3);
root.right = new TreeNode(7);
root.left.left = new TreeNode(2);
root.left.right = new TreeNode(4);
root.right.right = new TreeNode(8);

Console.WriteLine(KthSmallest(root, 3));

medium

A. 4

B. 3

C. 5

D. 7

Solution

1. Step 1: Perform inorder traversal of BST

   Inorder traversal visits nodes in ascending order: 2, 3, 4, 5, 7, 8.

2. Step 2: Find the 3rd element in the sorted list

   The 3rd element (index 2) is 4.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Inorder sorted list = [2,3,4,5,7,8], 3rd element = 4 [OK]

Hint: Inorder traversal sorts BST; pick element at index k-1 [OK]

Common Mistakes:

• Using preorder or postorder traversal order
• Off-by-one error in indexing k-1
• Confusing left and right subtree values

4. The following code attempts to find the Kth smallest element in a BST but fails to stop the traversal early after finding the Kth element. What is the main issue?

int KthSmallest(TreeNode root, int k) {
  int count = 0;
  int result = -1;
  void Inorder(TreeNode node) {
    if (node == null) return;
    Inorder(node.left);
    count++;
    if (count == k) {
      result = node.val;
      return;
    }
    Inorder(node.right);
  }
  Inorder(root);
  return result;
}

medium

A. The function does not handle empty trees

B. The variable count is not incremented correctly

C. The result variable is not initialized

D. The return inside Inorder does not stop the entire traversal

Solution

1. Step 1: Analyze the recursive Inorder function

   The return statement inside Inorder only exits the current call, not the entire traversal, so traversal continues after finding the Kth element.

2. Step 2: Understand why this is problematic

   Continuing traversal after setting result wastes time and space; no mechanism to stop recursion early.

3. Final Answer:

   The return inside Inorder does not stop the entire traversal -> Option D

4. Quick Check:

   Return in recursion stops only current call, not whole traversal [OK]

Hint: Return in recursion stops only one call, not full traversal [OK]

Common Mistakes:

• Assuming return stops all recursion
• Not using a flag to stop traversal after finding element
• Ignoring null root case

5. You want to find the Kth smallest element in a BST but the tree is very large and you want to optimize for time and space. Which approach is best?

Options:
A) Use an iterative inorder traversal with a stack and stop when the Kth element is found.
B) Perform a full inorder traversal and store all elements in a list, then return the Kth element.
C) Convert the BST to a sorted array by any method, then binary search for the Kth element.
D) Use preorder traversal and count nodes until K is reached.

hard

A. Perform full inorder traversal and store all elements

B. Use iterative inorder traversal with stack, stop at Kth element

C. Convert BST to sorted array then binary search for Kth element

D. Use preorder traversal and count nodes until K is reached

Solution

1. Step 1: Evaluate full inorder traversal approach

   Storing all elements uses extra space and time, not efficient for large trees.

2. Step 2: Consider iterative inorder traversal with early stop

   This approach uses a stack to traverse nodes in order and stops immediately after finding the Kth smallest, saving time and space.

3. Step 3: Analyze other options

   Binary search requires sorted array, which needs full traversal first; preorder traversal does not guarantee sorted order.

4. Final Answer:

   Use iterative inorder traversal with stack, stop at Kth element -> Option B

5. Quick Check:

   Iterative inorder + early stop = efficient Kth smallest search [OK]

Hint: Iterative inorder with stack stops early, saves time and space [OK]

Common Mistakes:

• Using full traversal wasting memory
• Using preorder which is unsorted
• Trying binary search without sorted array