Search in a Binary Search Tree - Practice Coding Problems

Search in a Binary Search Tree - Problem

Search in a Binary Search Tree is a fundamental tree traversal problem that leverages the powerful properties of Binary Search Trees (BSTs).

You are given the root of a binary search tree and an integer val. Your task is to find the node in the BST where the node's value equals val and return the entire subtree rooted at that node. If no such node exists, return null.

Remember: In a BST, for every node, all values in the left subtree are smaller than the node's value, and all values in the right subtree are larger than the node's value. This property allows us to efficiently navigate the tree without checking every node!

Goal: Find and return the subtree starting from the target node
Input: Root of BST + target value
Output: Subtree rooted at target node, or null if not found

Input & Output

example_1.py — Basic Search

$ Input: root = [4,2,7,1,3], val = 2

› Output: [2,1,3]

💡 Note: The node with value 2 exists in the BST. We return the subtree rooted at this node, which includes nodes 2, 1, and 3.

example_2.py — Value Not Found

$ Input: root = [4,2,7,1,3], val = 5

› Output: null

💡 Note: The value 5 does not exist in the BST, so we return null. The search would go: 5 > 4 (go right to 7), 5 < 7 (go left to null).

example_3.py — Single Node Tree

$ Input: root = [1], val = 1

› Output: [1]

💡 Note: The tree has only one node with value 1, which matches our target. We return the single-node subtree.

Visualization

Tap to expand

Understanding the Visualization

Enter Library at Main Desk

Start at the root - this is like the main information desk that directs you to different sections

Check Section Sign

Compare your book number with the current section. The sign tells you the range of books here

Choose Direction

Go left for smaller numbers, right for larger numbers, or stay if you found your section

Repeat Until Found

Keep following the signs until you reach your target book or a dead end (book doesn't exist)

Key Takeaway

🎯 Key Insight: BST property allows us to eliminate half the search space at each step, making search as efficient as a well-organized library system!

Time & Space Complexity

Time Complexity

⏱️

O(h)

Height of the tree h. For balanced BST h = O(log n), for skewed BST h = O(n)

✓ Linear Growth

Space Complexity

O(1)

Iterative version uses constant extra space, recursive version uses O(h) for call stack

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 5000]
1 ≤ Node.val ≤ 10⁷
root is a binary search tree
1 ≤ val ≤ 10⁷

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 Apple 25

The optimal solution leverages the BST property to search in O(log n) time for balanced trees. By comparing the target value with each node and moving left for smaller values or right for larger values, we eliminate half the search space at each step - much more efficient than the O(n) brute force approach that visits every node.

Common Approaches

Approach	Time	Space	Notes
✓ BST Property (Optimal)	O(h)	O(1)	Leverage BST ordering to eliminate half the tree at each step
Brute Force (Visit All Nodes)	O(n)	O(h)	Visit every node in the tree using DFS/BFS until target is found

BST Property (Optimal) — Algorithm Steps

Start at root node
Compare target value with current node's value
If equal, return current node (found!)
If target < current, go to left child
If target > current, go to right child
Repeat until found or reach null

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare at Root

Compare target with root value, decide direction

Navigate Left/Right

Follow BST property to eliminate half the tree

Continue Comparison

Repeat process at each level

Find Target

Located target or determined it doesn't exist

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* searchBST(struct TreeNode* root, int val) {
    struct TreeNode* current = root;
    
    while (current) {
        if (val == current->val) {
            return current;
        } else if (val < current->val) {
            current = current->left;
        } else {
            current = current->right;
        }
    }
    
    return NULL;
}

// Recursive version
struct TreeNode* searchBSTRecursive(struct TreeNode* root, int val) {
    if (!root || root->val == val) {
        return root;
    }
    
    if (val < root->val) {
        return searchBSTRecursive(root->left, val);
    } else {
        return searchBSTRecursive(root->right, val);
    }
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(h)

Height of the tree h. For balanced BST h = O(log n), for skewed BST h = O(n)

✓ Linear Growth

Space Complexity

O(1)

Iterative version uses constant extra space, recursive version uses O(h) for call stack

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 5000]
1 ≤ Node.val ≤ 10⁷
root is a binary search tree
1 ≤ val ≤ 10⁷

82.1K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

BST Property (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler