Kth Smallest Element in BST in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to perform an inorder traversal that visits nodes in ascending order.

DSA C#

void InorderTraversal(TreeNode node) {
    if (node == null) return;
    InorderTraversal(node.[1]);
    Console.WriteLine(node.val);
    InorderTraversal(node.right);
}

Drag options to blanks, or click blank then click option'

Achild

Bright

Cleft

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Using node.right instead of node.left causes wrong traversal order.

The inorder traversal visits the left subtree first, then the node, then the right subtree. So, we call InorderTraversal on node.left first.

2fill in blank

medium

Complete the code to count nodes visited during inorder traversal.

DSA C#

int count = 0;
int KthSmallest(TreeNode node, int k) {
    if (node == null) return -1;
    int left = KthSmallest(node.left, k);
    if (left != -1) return left;
    count++;
    if (count == [1]) return node.val;
    return KthSmallest(node.right, k);
}

Drag options to blanks, or click blank then click option'

Anode.val

Bcount

C0

Dk

Attempts:

3 left

💡 Hint

Common Mistakes

Using count instead of k causes incorrect comparison.

We compare the count of visited nodes with k to find the kth smallest element.

3fill in blank

hard

Fix the error in the code to correctly return the kth smallest element or -1 if not found.

DSA C#

int count = 0;
int KthSmallest(TreeNode node, int k) {
    if (node == null) return -1;
    int left = KthSmallest(node.left, k);
    if (left != -1) return left;
    count++;
    if (count == k) return node.[1];
    return KthSmallest(node.right, k);
}

Drag options to blanks, or click blank then click option'

Aval

Bvalue

Ckey

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect property name causes compilation error.

The TreeNode property for the node's value is val. Using the correct property returns the node's value.

4fill in blank

hard

Fill both blanks to complete the code that populates a dictionary mapping each node's value to its depth in the BST.

DSA C#

var depthMap = new Dictionary<int, int>();
void MapDepth(TreeNode node, int depth) {
    if (node == null) return;
    depthMap[node.val] = [1];
    MapDepth(node.left, depth [2] 1);
    MapDepth(node.right, depth + 1);
}

Drag options to blanks, or click blank then click option'

Adepth

Bdepth + 1

C-

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using the subtraction operator '-' causes incorrect depth mapping for the left subtree.

We assign the current depth to the node's value. We recurse on the left child with depth + 1, same as the right child.

5fill in blank

hard

Fill all three blanks to complete the code that returns the kth smallest element using an iterative inorder traversal.

DSA C#

int KthSmallestIterative(TreeNode root, int k) {
    var stack = new Stack<TreeNode>();
    var current = root;
    int count = 0;
    while (current != null || stack.Count > 0) {
        while (current != null) {
            stack.Push(current);
            current = current.[1];
        }
        current = stack.Pop();
        count++;
        if (count == [2]) return current.[3];
        current = current.right;
    }
    return -1;
}

Drag options to blanks, or click blank then click option'

Aleft

Bk

Cval

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using current.right instead of current.left in inner loop causes wrong traversal.

The iterative inorder traversal goes left as far as possible, so current = current.left. We compare count with k to find the kth smallest, and return current.val.

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