Blind 75: BST Kth Smallest Element

[pertrai1]

Summary by CodeRabbit

• New Features

  • Added Binary Search Tree Kth Smallest Element problem to Blind 75 collection

• Documentation

  • Added complete problem documentation with examples and constraints
  • Added comprehensive unit tests

Progress: GreatFrontEnd problems solved increased to 9; Blind 75 progress updated to 4/75; Trees category now at 1/12.

_{✏️ Tip: You can customize this high-level summary in your review settings.}

[continue]

Learn more

---

All Green is an AI agent that automatically:

✅ Addresses code review comments

✅ Fixes failing CI checks

✅ Resolves merge conflicts

---

Unsubscribe from All Green comments

[github-actions]

@codex review

[github-actions]

@codex review

[coderabbitai]

📝 Walkthrough

Walkthrough

Added a new Binary Search Tree problem ("Kth Smallest Element") to the GreatFrontEnd Blind 75 challenges collection. Includes TypeScript implementation using iterative in-order traversal, comprehensive test suite, and problem documentation. Updated progress trackers in root and category-level README files.

Changes

Cohort / File(s)	Summary
Progress tracking README.md, greatfrontend/blind-75/README.md	Updated completion metrics: GreatFrontEnd problems increased from 8 to 9; Blind 75 progress updated from 3/75 to 4/75. Trees category incremented from 0/12 to 1/12 with new problem entry.
BST Kth Smallest implementation greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts	Added TreeNode interface and kthSmallestElementInABst function implementing iterative in-order traversal with stack to find kth smallest element; O(h) space, O(h + k) time complexity.
Problem documentation greatfrontend/blind-75/trees/bst-kth-smallest/README.md	New README documenting problem statement, TreeNode interface, input parameters, sample test cases with explanations, and value/count constraints.
Test suite greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts	Comprehensive unit tests covering edge cases (single-node, skewed trees), various k values across different tree shapes (balanced, left/right-skewed), and larger multi-branch BSTs.

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~12 minutes

Poem

🐰 A rabbit hops through trees so tall,
Finding the kth smallest of them all!
With stacks and traversal, left then right,
New problems solved shine ever bright! 🌟

Pre-merge checks and finishing touches

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately describes the main change: adding a new BST Kth Smallest Element problem to the Blind 75 coding challenge collection.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch blind-12292025

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[github-actions]

Claude finished @pertrai1's task in 1m 28s —— View job

---

Code Review Complete ✅

Great implementation of the BST Kth Smallest Element problem! The solution is correct, well-commented, and uses an efficient iterative approach. Here's my detailed review:

---

✅ Correctness

The solution correctly implements an iterative in-order traversal to find the kth smallest element. It handles all edge cases properly:

• Single node trees
• Left-skewed and right-skewed trees
• Balanced BSTs
• Finding the minimum (k=1) and maximum elements

The test suite is comprehensive with 11 test cases covering various tree structures.

---

📊 Complexity Analysis

Time Complexity: O(h + k) ✅

• h is the height of the tree (to reach the leftmost node)
• k is the number of nodes visited during in-order traversal
• In the best case (k=1), we only visit h nodes
• In the worst case, we visit all n nodes if k=n

Space Complexity: O(h) ✅

• The stack stores at most h nodes (height of the tree)
• For a balanced BST: O(log n)
• For a skewed BST: O(n)

The complexity annotations in bst-kth-smallest.ts:7-8 are accurate!

---

🎯 Algorithm Pattern: Iterative In-Order Traversal

Why this pattern works:
The key insight is that in-order traversal of a BST visits nodes in sorted order (ascending). By performing in-order traversal and counting nodes, we can stop at the kth node to get the kth smallest element.

Pattern breakdown:

1. Push left path: Go as far left as possible, pushing nodes onto stack
2. Process node: Pop from stack (this is the next smallest element)
3. Move right: Continue traversal with right subtree

This pattern is superior to the recursive approach because:

• ✅ No recursion overhead
• ✅ Can stop early once we find the kth element (doesn't need to traverse entire tree)
• ✅ Space-efficient (no call stack)

---

💡 Key Insight

The BST property + in-order traversal = sorted sequence

By leveraging the BST invariant (left < root < right), in-order traversal naturally produces elements in ascending order. Instead of sorting the entire tree into an array (O(n) space), we can use iterative traversal to find the kth element in O(h) space.

---

🔍 Code Quality Review

Strengths:

• ✅ Excellent variable naming (stack, root, k)
• ✅ Clear, step-by-step comments explaining each phase
• ✅ Proper TypeScript types with TreeNode interface
• ✅ Modern syntax with const for immutable variables
• ✅ Non-null assertion stack.pop()! is safe (stack is never empty when we pop)

Minor observations:

1. Line 16: while (true) with eslint-disable (bst-kth-smallest.ts:15-16)

   • The eslint-disable-next-line no-constant-condition is appropriate here
   • This is a common pattern for iterative traversal algorithms
   • The loop terminates via the return statement when k reaches 0

2. Line 25: Pre-decrement operator (bst-kth-smallest.ts:25)

   if (--k === 0) {

   • This is concise and efficient
   • Alternative: k--; if (k === 0) would be slightly more readable but less idiomatic
   • Current approach is fine for algorithmic code

---

🔄 Alternative Approaches

1. Recursive In-Order Traversal

function kthSmallest(root: TreeNode | null, k: number): number {
  const result = { count: 0, value: -1 };
  
  function inorder(node: TreeNode | null) {
    if (!node || result.count >= k) return;
    inorder(node.left);
    result.count++;
    if (result.count === k) {
      result.value = node.val;
      return;
    }
    inorder(node.right);
  }
  
  inorder(root);
  return result.value;
}

Trade-offs:

• ❌ More space: O(h) recursion call stack + O(h) function frames
• ❌ Less intuitive with mutation needed for counting
• ✅ More functional/declarative style

2. Morris Traversal (O(1) space)

// Uses threaded binary tree technique
// Time: O(n), Space: O(1)

Trade-offs:

• ✅ O(1) space complexity
• ❌ More complex to implement and understand
• ❌ Temporarily modifies tree structure (restores it afterward)
• Not worth the complexity for this problem

Your iterative solution is optimal for interview settings: it's efficient, clear, and demonstrates solid understanding of tree traversal patterns.

---

🎓 Learning Summary

Pattern Family: Tree Traversal (In-Order DFS)

When to use this pattern:

• Finding kth smallest/largest in BST
• Validating BST properties
• Converting BST to sorted array
• Range queries in BST

Related Problems for Practice:

1. LeetCode 98 - Validate Binary Search Tree

   • Uses in-order traversal to verify BST property
   • Same pattern: iterative in-order with early termination

2. LeetCode 173 - Binary Search Tree Iterator

   • Implements next() and hasNext() using controlled in-order traversal
   • Directly extends the stack-based approach you used here

3. LeetCode 94 - Binary Tree Inorder Traversal

   • Fundamental pattern practice
   • Both recursive and iterative approaches

Common Mistakes to Avoid:

• ❌ Forgetting to handle null nodes when going left/right
• ❌ Not checking if stack is empty before popping
• ❌ Using k-- after the check instead of --k (off-by-one error)
• ❌ Recursively traversing entire tree when k is small (inefficient)

Interview Tips:

• Always mention the BST property enables in-order = sorted
• Discuss trade-offs between recursive vs iterative
• Know the O(1) space Morris traversal exists (but iterative is preferred)
• This problem often leads to follow-ups: "What if we need to find kth smallest multiple times?" (Answer: augment each node with subtree size)

---

📝 Summary

Verdict: ✅ Excellent implementation

This is a textbook-quality solution that demonstrates:

• Deep understanding of BST properties
• Mastery of iterative tree traversal
• Clean code practices with good documentation
• Comprehensive test coverage

The solution is optimal for time complexity and uses the right pattern. No changes needed!

---

[chatgpt-codex-connector]

To use Codex here, create a Codex account and connect to github.

[chatgpt-codex-connector]

To use Codex here, create a Codex account and connect to github.

[github-actions]

🧮 Solution Analysis

PR: Blind 75: BST Kth Smallest Element
Files Changed: greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts

📊 Code Quality Results

ESLint Analysis

• Errors: 0
• Warnings: 1

Issues by file:

• /home/runner/work/coding-challenges/coding-challenges/greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts: 0 errors, 1 warnings

🔍 Complexity Analysis

bst-kth-smallest

📋 Analysis Results:

🔍 Automated Complexity Analysis

⚠️ Disclaimer: This is an automated analysis that may not be 100% accurate.
Always verify the complexity analysis manually, especially for complex algorithms.
Dynamic Programming, recursive, and mathematical algorithms may need manual review.

File: greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts
Generated: 2025-12-29T14:40:31.323Z

Time Complexity

Estimated: O(1)
Description: Constant time - single operations
Confidence: 53.1%

⚠️ Low Confidence: Please manually verify this analysis.
💡 Tip: Add // @complexity: O(n) time, O(1) space to override automated detection.

Space Complexity

Estimated: O(1)
Reason: Constant extra space

Data Structures Used

• Array: []
  • access: O(1)
  • search: O(n)
  • insertion: O(1) amortized
  • deletion: O(n)
• Stack/Queue: .push(
  • push/pop: O(1)
  • shift/unshift: O(n) for arrays
• Stack/Queue: .pop(
  • push/pop: O(1)
  • shift/unshift: O(n) for arrays

Code Metrics

• Lines of Code: 22
• Cyclomatic Complexity: 5
• Max Nesting Level: 3

Recommendations

• VERIFICATION: ⚠️ Manual Review Needed: Low confidence score suggests manual verification is required

bst-kth-smallest.test

📋 Analysis Results:

🔍 Automated Complexity Analysis

⚠️ Disclaimer: This is an automated analysis that may not be 100% accurate.
Always verify the complexity analysis manually, especially for complex algorithms.
Dynamic Programming, recursive, and mathematical algorithms may need manual review.

File: greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts
Generated: 2025-12-29T14:40:31.286Z

Time Complexity

Estimated: O(1)
Description: Constant time - single operations
Confidence: 50.5%

⚠️ Low Confidence: Please manually verify this analysis.
💡 Tip: Add // @complexity: O(n) time, O(1) space to override automated detection.

Space Complexity

Estimated: O(1)
Reason: Constant extra space

Code Metrics

• Lines of Code: 112
• Cyclomatic Complexity: 1
• Max Nesting Level: 2

Recommendations

• VERIFICATION: ⚠️ Manual Review Needed: Low confidence score suggests manual verification is required

💡 Analysis Tips

• Time Complexity: Focus on the dominant operation in loops
• Space Complexity: Consider auxiliary data structures
• Optimization: Look for opportunities to improve efficiency
• Edge Cases: Ensure your solution handles empty inputs, null/undefined, edge conditions

📁 Analysis Files Created

Detailed analysis files have been automatically generated and committed to docs/analysis/ for future reference.

🎯 Next Steps

1. Review any ESLint errors/warnings above
2. Consider the complexity analysis - is this the optimal approach?
3. Test with edge cases mentioned in the problem description
4. Add comments explaining complex logic
5. Check the docs/analysis/ directory for detailed complexity analysis files

---

Analysis generated for PR files only

[github-actions]

✅ Test Results

Tests have been executed for this pull request.

📊 Coverage Summary

Metric	Coverage
Statements	93.54%
Branches	87.8%
Functions	82.35%
Lines	93.64%

Check the workflow logs for detailed test output.

[github-actions]

---

🤖 Gemini Code Review (Model: gemini-2.5-flash)

Here's a review of the kthSmallestElementInABst solution:

---

1. Pattern Identification

This solution utilizes In-order Traversal of a Binary Search Tree (BST). The key property of a BST is that an in-order traversal (Left -> Node -> Right) visits nodes in ascending order of their values. The implementation specifically uses an iterative in-order traversal with an explicit stack.

2. Complexity Verification

• Time Complexity: O(h + k)

  • Verification: The stated time complexity is accurate.
  • Explanation: In the worst case, we might have to traverse down to the deepest left node, which takes O(h) time (where h is the height of the tree). After reaching the leftmost node, we perform k "pop" operations and potentially k "push" operations for right children. Each node is pushed onto the stack and popped from the stack at most once. However, we stop once the k-th element is found. Therefore, we effectively visit at most k nodes in the in-order sequence, plus the initial traversal down to the leftmost node.
  • In a balanced BST, h = log N, so time is O(log N + k).
  • In a skewed BST (worst case for height), h = N, so time is O(N).
  • Since k <= N, the overall worst-case time is O(N). The O(h+k) notation is more precise.

• Space Complexity: O(h)

  • Verification: The stated space complexity is accurate.
  • Explanation: The stack stores the nodes along the current path from the root to the node being visited. In the worst-case scenario (a skewed tree), the stack could hold up to h nodes, where h is the height of the tree.
  • In a balanced BST, h = log N, so space is O(log N).
  • In a skewed BST, h = N, so space is O(N).

3. Key Insight

The fundamental insight for solving this problem efficiently is leveraging the in-order traversal property of a Binary Search Tree. An in-order traversal of a BST yields all its node values in sorted (ascending) order. Therefore, to find the k-th smallest element, we just need to perform an in-order traversal and count the elements. Once the counter reaches k, the current node's value is our answer, and we can stop the traversal early. We don't need to traverse the entire tree.

4. Edge Case Analysis

The current solution handles most common edge cases correctly due to the robust nature of iterative in-order traversal:

• Single node tree: root = {val: 1}, k = 1. The loop will push 1, pop 1, k becomes 0, returns 1. Correct.
• Skewed trees (left or right): The iterative approach correctly handles both left-skewed (like a linked list going left) and right-skewed (like a linked list going right) trees. The stack grows and shrinks appropriately.
• k = 1 (smallest element): The algorithm correctly finds the leftmost node, decrements k to 0, and returns its value.
• k = Number of nodes (largest element): The algorithm will traverse until it reaches the largest node (the rightmost node), at which point k will decrement to 0 and its value will be returned.
• root is null: The problem constraints state 1 <= k <= Number of nodes, implying root will never be null for valid inputs. However, if root could be null, the while (root) loop would never execute, stack would be empty, and stack.pop()! would throw an error. A check if (!root) return -1; (or throw error) at the beginning would handle this, though not strictly necessary per current constraints.
• k is invalid: Constraints state 1 <= k <= Number of nodes, so k is always valid. If k could be out of bounds, additional checks would be needed.

5. Learning Points

• Similar Problems:

  • Nth Largest Element in a BST: Similar logic, but instead of standard in-order (left-root-right), you'd do a reverse in-order traversal (right-root-left) and count k.
  • Validate BST: In-order traversal can be used to check if the elements are strictly increasing.
  • Convert BST to Sorted Doubly Linked List/Array: A full in-order traversal is essentially this.
  • Two Sum IV - Input is a BST: Can be solved by doing an in-order traversal to get a sorted array, then using two pointers.
  • Median of a BST: Find the (N/2)-th or (N/2 + 1)-th element.

• Common Mistakes with this Pattern:

  • Off-by-one errors with k: Forgetting to decrement k or miscounting the k-th element (e.g., 0-indexed vs. 1-indexed).
  • Not stopping early: Performing a full traversal of the tree even after finding the k-th element, which unnecessarily increases runtime.
  • Incorrect traversal order: Using pre-order or post-order traversal, which doesn't yield sorted elements in a BST.
  • Stack management errors (iterative): Forgetting to push root's left children, or incorrect handling of root = root.right.

• Variations of this Problem:

  • Kth Smallest Element with frequent queries: If you need to find the k-th smallest element many times, you can augment the BST nodes to store the size of their left subtrees. This allows finding the k-th smallest element in O(h) time per query.
  • Kth Smallest Element in a BST with Duplicates: The definition of "smallest" might change (distinct vs. non-distinct). The current solution works for non-distinct as well, provided the BST allows duplicates (e.g., left <= root < right or left < root <= right).

6. Code Quality

• Variable Naming: root, k, stack are all standard and clear. val, left, right for TreeNode are also standard.
• Code Structure: The iterative approach is well-structured. The while (true) loop with an explicit return when k reaches 0 is a common and acceptable pattern for this type of problem. The eslint-disable-next-line comment is good practice to acknowledge the constant condition.
• Readability: The comments // Push all left nodes onto stack and // Pop the leftmost unvisited node enhance readability, explaining the two main phases of the iterative in-order traversal.
• Type Safety: The TypeScript types (TreeNode | null, TreeNode[]) are correctly used, providing good type safety. The non-null assertion ! on stack.pop()! is justified given the problem constraints (k is always valid and root is never null initially).

7. Alternative Approaches

1. Recursive In-order Traversal:

   • Approach: Implement a helper function that recursively traverses the tree in-order. Maintain a global counter and a variable to store the result. When the counter reaches k, store the current node's value and stop further recursion (or return early).
   • Trade-offs:
     • Pros: Often simpler to write and understand for beginners.
     • Cons: Uses the call stack for space, which can lead to Stack Overflow errors for very deep trees (large h) in some languages/environments. Space complexity is O(h). Time complexity is O(h + k).

2. Augmented BST (for multiple queries):

   • Approach: Modify the TreeNode structure to include an additional field, say leftSubtreeSize, which stores the number of nodes in its left subtree. During insertion/deletion, these sizes would need to be updated.
   • Trade-offs:
     • Pros: For multiple k-th smallest queries on the same BST, this approach allows O(h) lookup time per query after an initial O(N) preprocessing step (or O(log N) amortized during insertions/deletions).
     • Cons: Requires modifying the BST structure and potentially the insertion/deletion logic, which is more complex if not already part of the tree's design. Not optimal if only one k-th smallest query is performed.

3. Morris Traversal:

   • Approach: This is an advanced in-order traversal technique that achieves O(N) time complexity and O(1) space complexity (excluding the output array). It works by temporarily modifying the tree structure by creating "threaded" links to predecessors, then restoring them.
   • Trade-offs:
     • Pros: Optimal space complexity (O(1)).
     • Cons: More complex to implement, harder to debug, and modifies the tree temporarily. Generally not recommended unless O(1) space is a strict requirement, as it sacrifices readability for optimization.

[github-actions]

---

🤖 Gemini Code Review (Model: gemini-2.5-flash)

Here's a review of your kthSmallestElementInABst solution:

1. Pattern Identification

This solution primarily uses Tree Traversal, specifically an Iterative In-order Traversal using a stack.

• Why this pattern? Binary Search Trees (BSTs) have a fundamental property: an in-order traversal (visiting the left child, then the node itself, then the right child) processes nodes in strictly ascending order of their values. To find the k-th smallest element, we simply need to perform an in-order traversal and count the nodes until we've visited k of them. The iterative approach is a common way to implement DFS (Depth-First Search) traversals without relying on the call stack for recursion.

2. Complexity Verification

• Time Complexity: O(h + k)

  • Verification: The stated time complexity is accurate.
  • Explanation:
    • In the worst case, we might traverse down to a leaf node (h steps) to find the first element, then backtrack and go right, repeatedly, until we find the k-th element.
    • Each node is pushed onto the stack and popped at most once. We stop the traversal once the k-th element is found.
    • Therefore, the number of operations is proportional to the height of the tree h (for the initial descent to the leftmost node) plus k (for processing k elements).
    • In a skewed tree, h can be N (number of nodes), making the worst-case O(N). In a balanced tree, h is log N, making it O(log N + k). The O(h + k) accurately captures this behavior.

• Space Complexity: O(h)

  • Verification: The stated space complexity is accurate.
  • Explanation: The stack stores nodes along the path from the root to the current node being processed. At any given time, the maximum number of nodes in the stack is equal to the height of the tree h. In the worst case (a skewed tree), h can be N, so the space complexity can be O(N). In a balanced tree, h is log N, so it's O(log N).

3. Key Insight

The key insight is leveraging the in-order traversal property of a Binary Search Tree. Because an in-order traversal visits nodes in ascending order, if we simply perform an in-order traversal and keep a counter, the k-th node we visit will be the k-th smallest element in the BST. The iterative approach with a stack is just a specific implementation strategy for this traversal.

4. Edge Case Analysis

The current solution handles most standard edge cases correctly:

• k = 1 (smallest element): The algorithm correctly finds the leftmost node, processes it, and returns its value.
• k = N (largest element): The algorithm continues the in-order traversal until the N-th node (which is the rightmost node) is processed.
• Single node tree: The node is pushed, popped, k becomes 0, and its value is returned.
• Skewed trees (left or right): The iterative in-order traversal naturally handles these by either pushing many left children or immediately processing and moving to the right.

Potential Edge Case / Constraint Consideration:

• Empty Tree (root = null): The problem constraints typically state 1 <= k <= Number of nodes, which implies root will never be null. If root could be null and k is still 1, the current while (true) loop would eventually try to stack.pop() from an empty stack, leading to an error (or an infinite loop if root stays null and stack is empty). Given the constraints, this is not a concern for this specific problem instance.

5. Learning Points

• Similar Problems Using This Pattern:

  • Validating a BST: Perform an in-order traversal and check if each subsequent element is strictly greater than the previous one.
  • Convert BST to Sorted Linked List: An in-order traversal can be used to collect nodes in sorted order, then link them.
  • Finding the k-th Largest Element in a BST: This is a slight variation. You could either perform a reverse in-order traversal (right, root, left) or modify the k value and use the existing in-order traversal.
  • Iterator for a BST: Implementing an iterator that returns elements in sorted order is essentially building a mechanism for iterative in-order traversal.

• Common Mistakes with This Pattern:

  • Off-by-one errors with k: Whether k is 0-indexed or 1-indexed is crucial. This solution correctly uses k as 1-indexed and decrements it.
  • Incorrectly handling null children: Forgetting to set root = root.left or root = root.right correctly can lead to infinite loops or skipping nodes.
  • Stack management: Pushing and popping nodes from the stack in the right order is essential for correct traversal.
  • Confusing traversal types: Mistaking in-order for pre-order (root, left, right) or post-order (left, right, root) will yield incorrect results for problems relying on sorted order.

• Variations of This Problem:

  • k-th largest element: As mentioned, a reverse in-order traversal would find this.
  • Augmented BST: If the TreeNode structure could be modified to store the count of nodes in its left subtree, finding the k-th smallest element could be optimized to O(h) time by using these counts to decide whether to go left or right. This is a common follow-up question.
  • Find elements in a range [min, max]: An in-order traversal can be adapted to collect all nodes within a given range.

6. Code Quality

The code quality is good:

• Variable Naming: root, k, stack are standard and clear.
• Code Structure: The iterative in-order traversal pattern is well-implemented and easy to follow.
• Readability: The comments explaining the time and space complexity are helpful. The // eslint-disable-next-line no-constant-condition comment is excellent for explaining the while (true) loop.
• TypeScript Specifics:
  • The TreeNode interface is properly defined.
  • stack.pop()!: The non-null assertion operator ! is used. This is safe here because the problem constraints guarantee that k will always be valid (i.e., there will always be at least k nodes, so the stack won't be empty when pop is called to find the k-th element).

7. Alternative Approaches

1. Recursive In-order Traversal:

   • Approach: Define a helper function that performs an in-order traversal recursively. Maintain a global/closure variable for the count and the result. When the count reaches k, store the current node's value and stop.
   • Trade-offs:
     • Pros: Often simpler to write and understand for many developers due to its natural mapping to the tree structure.
     • Cons: Uses the call stack for recursion, leading to O(h) space complexity (same as iterative in worst case). Can incur slightly higher overhead due to function calls.

2. Morris Traversal:

   • Approach: An advanced tree traversal algorithm that performs in-order traversal without using a stack or recursion. It modifies the tree temporarily by creating "threaded" links to predecessors and then restoring them.
   • Trade-offs:
     • Pros: Achieves O(N) time complexity with O(1) space complexity.
     • Cons: Significantly more complex to implement and debug. Not typically expected in interviews unless specifically asked for O(1) space.

3. Augmented BST (with subtree sizes):

   • Approach: If each TreeNode could store the size of its left subtree (or total subtree size), we could determine the k-th smallest element in O(h) time. For a node curr, if k is less than or equal to curr.left.size, go left. If k is equal to curr.left.size + 1, curr.val is the answer. Otherwise, adjust k and go right.
   • Trade-offs:
     • Pros: Very efficient O(h) time complexity.
     • Cons: Requires modifying the tree structure and maintaining these counts during insertions/deletions, which adds complexity to those operations. This is usually a follow-up or a variation where the tree is explicitly built to support this.

[Copilot]

Pull request overview

This PR adds a solution for the "BST Kth Smallest Element" problem to the Blind 75 collection. The implementation uses an iterative in-order traversal approach to find the kth smallest element in a binary search tree with O(h+k) time complexity and O(h) space complexity.

• Implements an efficient iterative solution using a stack-based in-order traversal
• Includes comprehensive test suite with 11 test cases covering edge cases (single node, skewed trees, balanced trees)
• Updates progress tracking across multiple README files (4/75 problems completed)

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts	Implements iterative in-order traversal solution with proper TypeScript types and JSDoc complexity annotations
greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts	Adds comprehensive test suite with 11 test cases covering various tree structures and k values
greatfrontend/blind-75/trees/bst-kth-smallest/README.md	Provides problem description, examples, and constraints (contains spelling errors and unclear documentation)
greatfrontend/blind-75/README.md	Updates Blind 75 progress tracker from 3/75 to 4/75 and adds Trees category entry
README.md	Updates GreatFrontEnd problems count from 8 to 9 and Blind 75 from 3/75 to 4/75

[Copilot]

The problem statement says "The smallest value in the tree is 1" which is confusing and incorrect. This statement seems to suggest that the minimum value in the BST is always 1, which is not true based on the examples and constraints. This should clarify that "k" starts from 1 (i.e., k=1 means the smallest element), not that the tree's minimum value is 1.

Suggested change

	Given the `root` node of a binary search tree (BST) and an integer `k`, write a function to find and return the `k`k`-th smallest value in the BST. The smallest value in the tree is 1.
	Given the `root` node of a binary search tree (BST) and an integer `k`, write a function to find and return the `k`-th smallest value in the BST (where `k = 1` corresponds to the smallest element).

[Copilot]

There's a typo in the problem description. The backtick character is duplicated after "k" making it read "kk-th" instead of just "k-th".

Suggested change

	Given the `root` node of a binary search tree (BST) and an integer `k`, write a function to find and return the `k`k`-th smallest value in the BST. The smallest value in the tree is 1.
	Given the `root` node of a binary search tree (BST) and an integer `k`, write a function to find and return the `k`-th smallest value in the BST. The smallest value in the tree is 1.

[Copilot]

There's a spelling error: "traversale" should be "traversal".

Suggested change

	- `root: TreeNode`: Root node of the tree. Examples display a level-order traversale of the tree
	- `root: TreeNode`: Root node of the tree. Examples display a level-order traversal of the tree

[coderabbitai]

Actionable comments posted: 2

🧹 Nitpick comments (1)

greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts (1)

10-31: Correct iterative in-order traversal implementation.

The algorithm correctly finds the kth smallest element using an iterative in-order traversal. The logic is clear and well-commented.

Optional: Consider safer handling of stack.pop()

Line 23 uses the non-null assertion operator ! which assumes the stack is never empty. While the problem constraints guarantee k is valid (1 ≤ k ≤ number of nodes), you could make this more explicit for robustness:

-    root = stack.pop()!;
+    const node = stack.pop();
+    if (!node) {
+      throw new Error('Invalid k: exceeds number of nodes in tree');
+    }
+    root = node;

This trades brevity for better error handling and maintains full type safety, though it's optional given the guaranteed constraints.

📜 Review details

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 7b4d4e0 and ab602aa.

📒 Files selected for processing (5)

• README.md
• greatfrontend/blind-75/README.md
• greatfrontend/blind-75/trees/bst-kth-smallest/README.md
• greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts
• greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts

🧰 Additional context used

📓 Path-based instructions (5)

**/*.ts

📄 CodeRabbit inference engine (AGENTS.md)

**/*.ts: Use explicit type annotations for function parameters and return types in TypeScript solutions
Follow strict TypeScript configuration with ES2020 target and CommonJS modules in TypeScript solutions
Enforce full type safety in TypeScript solutions

Files:

• greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts
• greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts

**/*.{js,ts}

📄 CodeRabbit inference engine (AGENTS.md)

**/*.{js,ts}: Use clear, descriptive variable names across all solutions
Add comments for non-obvious logic or algorithm steps in code
Keep functions focused and single-purpose across all solutions
Prefer readability over cleverness in code implementation

**/*.{js,ts}: Use descriptive variable names; single letters like i, j, k are acceptable for loop iterators and standard mathematical contexts
Add comments for complex logic, but prefer self-documenting code with clear logic
Minimize external dependencies and keep solutions self-contained

**/*.{js,ts}: Use clear, descriptive variable names (not just i, j, k unless in simple loops) and add comments for non-obvious logic or algorithm steps
Keep functions focused and single-purpose, preferring readability over cleverness
Use const by default, let only when reassignment needed; avoid var except for LeetCode solution function definitions
Use modern ES6+ syntax (arrow functions, destructuring, spread operators) where appropriate
Prefer built-in methods (.map(), .filter(), .reduce()) when appropriate and use strict equality (===) over loose equality (==)

Files:

• greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts
• greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts

**/*.{ts,tsx}

📄 CodeRabbit inference engine (.github/copilot-instructions.md)

**/*.{ts,tsx}: Use explicit type annotations for function parameters and return types in TypeScript
Follow strict TypeScript configuration as defined in tsconfig.json with ES2020 target and CommonJS modules

Files:

• greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts
• greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts

**/*.md

📄 CodeRabbit inference engine (AGENTS.md)

**/*.md: Create comprehensive documentation guides for arrays, trees, graphs, heaps, and other data structures
Document reusable code templates for common algorithmic patterns
Maintain Big O complexity cheatsheets and references

Files:

• README.md
• greatfrontend/blind-75/trees/bst-kth-smallest/README.md
• greatfrontend/blind-75/README.md

**/README.md

📄 CodeRabbit inference engine (CLAUDE.md)

Each problem directory should include a README.md containing: problem title and difficulty badge, link to the problem on the respective platform, problem description, examples and constraints

Files:

• README.md
• greatfrontend/blind-75/trees/bst-kth-smallest/README.md
• greatfrontend/blind-75/README.md

🧠 Learnings (3)

📚 Learning: 2025-12-02T17:56:01.747Z

Learnt from: CR
Repo: pertrai1/coding-challenges PR: 0
File: CLAUDE.md:0-0
Timestamp: 2025-12-02T17:56:01.747Z
Learning: Applies to GreatFrontEnd/**/*.{js,ts} : Evaluate the public API for clarity and usability, check for consistent naming conventions, verify parameter validation and error handling in GreatFrontEnd solutions

Applied to files:

• README.md

📚 Learning: 2025-12-02T17:56:01.747Z

Learnt from: CR
Repo: pertrai1/coding-challenges PR: 0
File: CLAUDE.md:0-0
Timestamp: 2025-12-02T17:56:01.747Z
Learning: Applies to GreatFrontEnd/**/*.{js,ts} : Check for unnecessary re-renders or DOM manipulations, verify efficient data structure usage for UI updates in GreatFrontEnd solutions

Applied to files:

• README.md

📚 Learning: 2025-11-26T14:46:46.097Z

Learnt from: CR
Repo: pertrai1/coding-challenges PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2025-11-26T14:46:46.097Z
Learning: Applies to [0-9]*-*/*.md : Problem README files should include: problem title with difficulty badge, problem description from LeetCode, examples with inputs/outputs, and constraints

Applied to files:

• greatfrontend/blind-75/trees/bst-kth-smallest/README.md

🪛 LanguageTool

greatfrontend/blind-75/trees/bst-kth-smallest/README.md

[grammar] ~19-~19: Ensure spelling is correct
Context: ...he tree. Examples display a level-order traversale of the tree - k: number: A positive i...

(QB_NEW_EN_ORTHOGRAPHY_ERROR_IDS_1)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (2)

• GitHub Check: Upload results
• GitHub Check: review

🔇 Additional comments (6)

README.md (1)

10-10: Progress tracker updates look correct!

The increments from 8 to 9 GreatFrontEnd problems and 3/75 to 4/75 Blind 75 problems accurately reflect the addition of the new BST Kth Smallest Element problem.

Also applies to: 47-47

greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.ts (2)

1-5: Clean TreeNode interface definition.

The interface follows TypeScript best practices with explicit types for all properties.

---

6-9: Accurate complexity analysis.

The space and time complexity annotations are correct:

• O(h) space for the stack holding at most h nodes (tree height)
• O(h + k) time for traversing to the leftmost node plus visiting k nodes

greatfrontend/blind-75/README.md (1)

7-7: Progress updates and problem entry are accurate.

The status updates correctly reflect the completion of one new Trees problem, and the new entry follows the established format with proper path and difficulty level.

Also applies to: 28-30

greatfrontend/blind-75/trees/bst-kth-smallest/README.md (1)

1-41: Well-structured problem documentation.

The README follows the repository conventions with clear problem description, TreeNode interface definition, input specifications, examples, and constraints.

greatfrontend/blind-75/trees/bst-kth-smallest/bst-kth-smallest.test.ts (1)

1-193: Excellent comprehensive test suite!

The tests thoroughly validate the implementation across multiple dimensions:

• Edge cases: Single node, minimum (k=1), maximum values
• Tree shapes: Left-skewed, right-skewed, balanced BSTs
• Various k values: First, middle, and last positions
• Reference examples: LeetCode test cases for cross-verification
• Clear documentation: ASCII tree diagrams aid understanding

The test coverage gives high confidence in the correctness of the implementation.

[coderabbitai]

⚠️ Potential issue | 🟡 Minor

Fix typo in problem description.

There's a duplicated backtick in the text: "kk-th" should be "k`-th".

🔎 Proposed fix

-Given the `root` node of a binary search tree (BST) and an integer `k`, write a function to find and return the `k`k`-th smallest value in the BST. The smallest value in the tree is 1.
+Given the `root` node of a binary search tree (BST) and an integer `k`, write a function to find and return the `k`-th smallest value in the BST. The smallest value in the tree is 1.

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	Given the `root` node of a binary search tree (BST) and an integer `k`, write a function to find and return the `k`k`-th smallest value in the BST. The smallest value in the tree is 1.
	Given the `root` node of a binary search tree (BST) and an integer `k`, write a function to find and return the `k`-th smallest value in the BST. The smallest value in the tree is 1.

🤖 Prompt for AI Agents

In greatfrontend/blind-75/trees/bst-kth-smallest/README.md around line 3, fix
the typo in the problem description where "`k`k`-th" appears; replace it with
the correct "`k`-th" so the sentence reads "find and return the `k`-th smallest
value in the BST." Ensure only the duplicated backtick and extra 'k' are removed
and the rest of the sentence remains unchanged.

[coderabbitai]

⚠️ Potential issue | 🟡 Minor

Fix spelling error.

"traversale" should be "traversal".

🔎 Proposed fix

-- `root: TreeNode`: Root node of the tree. Examples display a level-order traversale of the tree
+- `root: TreeNode`: Root node of the tree. Examples display a level-order traversal of the tree

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	- `root: TreeNode`: Root node of the tree. Examples display a level-order traversale of the tree
	- `root: TreeNode`: Root node of the tree. Examples display a level-order traversal of the tree

🧰 Tools

🪛 LanguageTool

[grammar] ~19-~19: Ensure spelling is correct
Context: ...he tree. Examples display a level-order traversale of the tree - k: number: A positive i...

(QB_NEW_EN_ORTHOGRAPHY_ERROR_IDS_1)

🤖 Prompt for AI Agents

In greatfrontend/blind-75/trees/bst-kth-smallest/README.md around line 19, fix
the spelling mistake in the parameter description by replacing the word
"traversale" with "traversal" so the sentence reads "...Examples display a
level-order traversal of the tree."

[github-actions]

@codex review

[github-actions]

Claude finished @pertrai1's task in 1m 34s —— View job

---

Code Review Complete ✅

Great work on implementing the BST Kth Smallest Element problem! This is a well-executed solution with excellent test coverage. Here's my detailed review:

---

✅ 1. Correctness

Verdict: Correct - The solution properly implements iterative in-order traversal to find the kth smallest element.

Edge Cases Verified:

• ✅ Single node tree (k=1)
• ✅ Left-skewed trees (worst case for height)
• ✅ Right-skewed trees
• ✅ Balanced BSTs
• ✅ k=1 (minimum element)
• ✅ k=n (maximum element)
• ✅ Various k values in the middle

The test suite is outstanding with 11 comprehensive test cases covering all edge cases and tree structures. This gives high confidence in correctness.

---

📊 2. Complexity Analysis

Time Complexity: O(h + k) ✅ CORRECT

• Explanation: We first traverse down to the leftmost node (height h), then perform k iterations of the in-order traversal. Each node is visited at most once.
• In a balanced BST: O(log n + k)
• In a skewed BST: O(n) worst case when k=n

Space Complexity: O(h) ✅ CORRECT

• Explanation: The stack stores nodes along the path from root to current node. Maximum stack size equals tree height.
• In a balanced BST: O(log n)
• In a skewed BST: O(n)

The complexity annotations in bst-kth-smallest.ts:7-8 are accurate and well-documented!

---

🎯 3. Pattern Identification & Learning Focus

Primary Pattern: Iterative In-Order Traversal (DFS)

Why this pattern works:

The key insight is that in-order traversal of a BST visits nodes in ascending sorted order (left → root → right). By leveraging the BST property where left < root < right, we can:

1. Traverse to find the kth element without sorting the entire tree
2. Stop early once we find the kth element (optimization)
3. Use O(h) space instead of O(n) space that a full array would require

Why this approach is optimal for this problem:

• BST property guarantees sorted order during in-order traversal
• Early termination when k reaches 0
• No need to collect all nodes into an array first
• Iterative approach avoids recursion call stack overhead

Key Insight Breakdown:

"In-order traversal of a BST = sorted sequence"

This fundamental property transforms the problem from "find kth smallest in a tree" to "count k nodes during in-order traversal." The iterative stack-based approach gives us fine-grained control to stop exactly at the kth element.

The Two-Phase Algorithm:

1. Descend Phase (lines 17-21): Go as far left as possible, pushing nodes onto stack
2. Process Phase (lines 22-29): Pop node (next smallest), decrement k, move right

---

💻 4. Code Quality

Strengths:

• ✅ Clear, descriptive variable names (root, k, stack)
• ✅ Excellent inline comments explaining each phase
• ✅ Proper TypeScript types with explicit TreeNode interface
• ✅ Good use of const for immutable variables
• ✅ eslint-disable-next-line comment properly documents the while (true) pattern
• ✅ Non-null assertion stack.pop()! is safe given problem constraints (k is always valid)

Best Practices Followed:

• Modern ES6+ syntax
• Focused, single-purpose function
• Self-documenting code with strategic comments
• Proper TypeScript type annotations

Minor Observations:

1. Line 3 in README.md: There's a typo: `k`k`-th should be `k`-th
2. Line 19 in README.md: "traversale" should be "traversal"
3. Line 3 in README.md: The phrase "The smallest value in the tree is 1" is confusing - it should clarify that k=1 means the smallest element, not that the minimum value is always 1.

These are documentation issues only - the code itself is excellent!

---

🔄 5. Alternative Approaches

Approach 1: Recursive In-Order Traversal

function kthSmallest(root: TreeNode | null, k: number): number {
  let count = 0;
  let result = -1;
  
  function inorder(node: TreeNode | null) {
    if (!node || count >= k) return;
    inorder(node.left);
    count++;
    if (count === k) {
      result = node.val;
      return;
    }
    inorder(node.right);
  }
  
  inorder(root);
  return result;
}

Trade-offs:

• ❌ Uses call stack (O(h) implicit space) + potential overhead
• ✅ More intuitive for some developers
• ❌ Less control over early termination
• Your iterative solution is superior for interviews

Approach 2: Morris Traversal (Advanced)

Trade-offs:

• ✅ O(1) space complexity (no stack or recursion)
• ❌ Much more complex to implement
• ❌ Temporarily modifies tree structure (creates threaded links)
• ❌ Not worth the complexity for this problem

Approach 3: Augmented BST

Modify each node to store left subtree size. Allows O(h) lookup by comparing k with subtree sizes.
Trade-offs:

• ✅ Optimal for multiple queries (O(h) per query)
• ❌ Requires modifying BST structure
• ❌ Adds complexity to insert/delete operations
• Only useful if this operation is performed frequently

Recommendation: Your iterative in-order traversal is the optimal balance of clarity, efficiency, and interview-friendliness.

---

📚 6. Related Problems for Practice

These problems use the same or similar patterns:

Same Pattern (In-Order Traversal):

1. LeetCode 98 - Validate Binary Search Tree

   • Uses in-order traversal to verify elements are strictly increasing
   • Practice: Extend your stack-based approach to track previous value

2. LeetCode 173 - Binary Search Tree Iterator

   • Implements next() and hasNext() using controlled in-order traversal
   • Directly extends your solution - the stack management is identical!

3. LeetCode 94 - Binary Tree Inorder Traversal

   • Fundamental pattern practice (both recursive and iterative)
   • Master this to understand your current solution deeply

Related BST Problems:

4. LeetCode 538 - Convert BST to Greater Tree

   • Uses reverse in-order traversal (right → root → left)
   • Builds on the same traversal concept

5. LeetCode 285 - Inorder Successor in BST

   • Finding the next node in in-order sequence
   • Similar pattern recognition needed

---

⚠️ 7. Common Mistakes to Avoid

When working with this pattern, watch out for:

1. Off-by-one errors: Using k-- after the check instead of --k (your code correctly uses --k)
2. Forgetting to move right: After processing a node, must set root = root.right to continue traversal
3. Stack underflow: Calling pop() on empty stack (your code is safe due to problem constraints)
4. Wrong traversal order: Using pre-order or post-order instead of in-order won't give sorted sequence
5. Not stopping early: Traversing entire tree even after finding kth element (your code optimizes this correctly)

---

🎓 Learning Summary

Core Concept: This problem teaches the fundamental relationship between BST properties and in-order traversal.

Key Takeaways:

1. BST In-Order = Sorted: Always remember this property for BST problems
2. Iterative DFS with Stack: A powerful technique for tree traversal with fine-grained control
3. Early Termination: When k reaches 0, we can return immediately without processing remaining nodes
4. Space-Time Trade-off: O(h) space with stack vs O(1) space with Morris traversal

Interview Tips:

• Always mention the BST in-order property when explaining your approach
• Discuss trade-offs: recursive vs iterative vs Morris
• Know the follow-up: "What if we need to find kth smallest multiple times?" → Augmented BST with subtree sizes
• This problem often appears in medium-difficulty interviews testing tree traversal understanding

Pattern Family: Tree Traversal → In-Order DFS → Stack-Based Iteration

---

🎯 Final Verdict

Excellent implementation! ⭐⭐⭐⭐⭐

• Algorithm correctness: ✅
• Complexity analysis: ✅ (accurate)
• Code quality: ✅ (clean, well-commented)
• Test coverage: ✅ (comprehensive)
• TypeScript best practices: ✅

This solution demonstrates strong understanding of:

• BST properties
• Tree traversal patterns
• Iterative DFS with explicit stack
• Early termination optimization

Only minor documentation fixes needed (typos in README). The code itself is production-ready and interview-optimal!

---

[chatgpt-codex-connector]

To use Codex here, create a Codex account and connect to github.

[github-actions]

---

🤖 Gemini Code Review (Model: gemini-2.5-flash)

Here's a detailed review of your bst-kth-smallest solution:

---

1. Pattern Identification

This solution utilizes the In-order Traversal pattern, specifically an iterative in-order traversal using a stack. The key property of a Binary Search Tree (BST) is that an in-order traversal (left, root, right) visits nodes in ascending order of their values. This makes it ideal for finding the k-th smallest element.

2. Complexity Verification

• Time Complexity: O(h + k)

  • Stated: O(h + k) where h is the height of the tree and k is the number of nodes needed to visit.
  • Verification: Accurate.
    • The algorithm first traverses down the left side of the tree, pushing nodes onto the stack until it reaches the leftmost node. This takes O(h) time in the worst case (a skewed tree).
    • Then, it pops nodes from the stack and visits their right subtrees. Each node is pushed onto the stack and popped exactly once. We stop once we have visited k nodes.
    • Therefore, in total, we visit k nodes and perform k stack operations, plus the initial descent which could be up to h pushes. This results in O(h + k) time complexity.
    • In the worst case where the tree is skewed and k is close to N (total nodes), h can be N, making the complexity O(N).

• Space Complexity: O(h)

  • Stated: O(h) which is the height of the tree.
  • Verification: Accurate.
    • The stack stores nodes along the path from the root to the current node being processed, plus any left children waiting to be visited.
    • In the worst-case scenario (a completely skewed tree, e.g., a linked list), the height h would be equal to the number of nodes N. In this case, the stack could hold up to N nodes.
    • For a balanced tree, h would be log N, so the space complexity would be O(log N).
    • Thus, O(h) correctly represents the auxiliary space used by the stack.

3. Key Insight

The fundamental insight for this problem is leveraging the inherent sorted property of a Binary Search Tree (BST) during an in-order traversal. If you traverse a BST in-order (left child, current node, right child), the values of the nodes are visited in strictly increasing order. Therefore, to find the k-th smallest element, you simply need to perform an in-order traversal and stop after visiting k nodes. The k-th node encountered will be your answer.

4. Edge Case Analysis

The current solution is robust and should handle the following edge cases correctly:

• k = 1 (smallest element): The algorithm will immediately find the leftmost node, decrement k to 0, and return its value. Correct.
• k = N (largest element, where N is total nodes): The algorithm will traverse the entire tree in-order until the N-th node is visited. Correct.
• Single node tree: If root has only one node, it will be pushed, popped, k decremented to 0, and its value returned. Correct.
• Skewed trees (left-skewed, right-skewed):
  • Right-skewed: The stack will initially only contain the root. The traversal will proceed to the right child, pushing it, then popping it, and so on. This correctly simulates an in-order traversal for such a tree.
  • Left-skewed: The stack will fill up to h nodes initially. Then, nodes will be popped one by one. Correct.
• Balanced BSTs: The algorithm naturally handles balanced trees by traversing down and up as needed.
• Constraints:
  • 1 <= k <= Number of nodes <= 1000: This ensures k is always valid and root will not be null (as k >= 1 means there's at least one node). The stack.pop()! non-null assertion is safe under these constraints.
  • 1 <= TreeNode.val <= 1,000,000: Node values fit standard integer types.

5. Learning Points

• Similar Problems using this pattern:
  • Validate Binary Search Tree (LeetCode 98): Uses in-order traversal to check if elements are strictly increasing.
  • Convert BST to Greater Tree (LeetCode 538): Uses reverse in-order traversal (right, root, left) to sum up larger values.
  • Inorder Successor in BST (LeetCode 285): Finding the next element in sorted order can be done with an in-order traversal.
  • Binary Tree Inorder Traversal (LeetCode 94): The fundamental iterative traversal problem.
• Common Mistakes with this pattern:
  • Forgetting to handle null nodes: The while (root) loop correctly stops when root becomes null, indicating the end of a left branch.
  • Incorrect stack management: Pushing/popping at the wrong times can lead to incorrect traversal order or infinite loops.
  • Off-by-one errors with k: Incorrectly decrementing k or checking k === 0 at the wrong point can lead to returning the (k-1)-th or (k+1)-th element.
  • Confusing in-order with pre-order or post-order: Each traversal visits nodes in a different order, and only in-order guarantees sorted output for a BST.
• Variations of this problem:
  • Kth Largest Element in a BST: Perform a reverse in-order traversal (right, root, left) and count k elements.
  • Kth Smallest Element in a general Binary Tree: This would require sorting all elements (e.g., by putting them into an array and sorting) or using a min-heap, as the BST property doesn't apply.
  • Kth Smallest Element with Augmented BST: If the TreeNode structure could be augmented to store the count of nodes in its left subtree, then the k-th smallest element could be found in O(h) time without explicit traversal, by making decisions at each node based on k and the left subtree size. This would require modifications to insertion/deletion operations to maintain the counts.

6. Code Quality

• Variable Naming: root, stack, k are standard and clear. val, left, right for TreeNode are also standard.
• Code Structure: The iterative in-order traversal structure is standard and well-organized. The inner while loop for pushing left nodes and the outer while loop for processing nodes are clear.
• Readability: The code is quite readable for anyone familiar with iterative tree traversals.
• TypeScript Specifics:
  • The export interface TreeNode is good for type definitions.
  • The use of ! for stack.pop()! is a non-null assertion. As discussed, given the problem constraints (k >= 1, root is never null), this is safe. However, in scenarios where k could potentially be invalid or the tree empty, it would be safer to add a check (e.g., if (!root) throw new Error(...) or if (stack.length === 0) throw new Error(...)). For LeetCode/GreatFrontEnd, this is generally acceptable.
  • The // eslint-disable-next-line no-constant-condition comment is appropriate for while (true) loops, indicating that it's an intentional infinite loop with an explicit return statement.

7. Alternative Approaches

1. Recursive In-order Traversal:

   • Approach: Implement a recursive helper function that performs an in-order traversal. This function would usually take the current node, a count (or an array to store elements), and k. It would first recurse left, then process the current node (decrementing k and checking if k is 0), then recurse right.
   • Trade-offs:
     • Pros: Often more concise and easier to write for tree traversals.
     • Cons: Uses the call stack for space, leading to O(h) space complexity, same as iterative. Might be slightly slower due to function call overhead.

2. Augmented BST (Pre-computation):

   • Approach: Modify the TreeNode structure to include an additional field, say leftSubtreeSize, which stores the number of nodes in its left subtree. During insertion/deletion, this field would need to be updated. To find the k-th smallest, you would start at the root:
     • If k == leftSubtreeSize + 1, the current node is the k-th smallest.
     • If k <= leftSubtreeSize, recurse on the left child.
     • If k > leftSubtreeSize + 1, recurse on the right child, adjusting k to k - (leftSubtreeSize + 1).
   • Trade-offs:
     • Pros: Allows O(h) time complexity for finding the k-th smallest element (faster than O(h+k) if k is large).
     • Cons: Requires modifying the tree structure and maintaining the leftSubtreeSize during all tree operations (insertion, deletion), adding complexity to those operations. Not suitable if the tree cannot be modified or if you only need to find k-th smallest once.

Your current iterative solution is a standard and efficient approach for this problem without modifying the tree structure.

[github-actions]

📅 Spaced Repetition Reviews Scheduled!

Great job solving #GFE-960f - Bst Kth Smallest! 🎉

To help you retain this knowledge long-term, I've scheduled 5 review sessions using spaced repetition:

Review	Interval	Schedule Logic
1st Review	1 day after solving	Scheduled now
2nd Review	3 days after 1st review	Auto-scheduled when 1st completes
3rd Review	7 days after 2nd review	Auto-scheduled when 2nd completes
4th Review	14 days after 3rd review	Auto-scheduled when 3rd completes
5th Review	30 days after 4th review	Auto-scheduled when 4th completes

What to expect:

• Your 1st review is scheduled for tomorrow
• Each subsequent review is scheduled automatically when you complete the previous one
• This ensures proper spacing even if you complete a review a few days late
• GitHub issues will be created automatically for each review
• Each issue will link back to your solution

🧠 Why Spaced Repetition?

Research shows that reviewing material at increasing intervals dramatically improves retention. This adaptive scheduling ensures optimal spacing based on when you actually complete each review!

Check docs/reviews/review-schedule.json to see your review schedule.