Find Mode in Binary Search Tree - Practice Coding Problems

Find Mode in Binary Search Tree - Problem

Given the root of a binary search tree (BST) with duplicates, find all the mode(s) - the values that appear most frequently in the tree.

A mode is a value that appears with the highest frequency. If multiple values share the same highest frequency, return all of them in any order.

BST Properties:

Left subtree contains nodes with keys ≤ current node's key
Right subtree contains nodes with keys ≥ current node's key
Both subtrees are also BSTs

For example, in BST [1,null,2,2], the value 2 appears twice while 1 appears once, so [2] is returned as it has the highest frequency.

Input & Output

example_1.py — Basic BST with duplicate values

$ Input: root = [1,null,2,2]

› Output: [2]

💡 Note: The value 2 appears twice while 1 appears only once, making 2 the mode with frequency 2.

example_2.py — Multiple modes case

$ Input: root = [1,1,2,2,3,3]

› Output: [1,2,3]

💡 Note: All values 1, 2, and 3 appear exactly twice, so they all share the highest frequency and are all modes.

example_3.py — Single node edge case

$ Input: root = [5]

› Output: [5]

💡 Note: Tree has only one node with value 5, so 5 is the only mode with frequency 1.

Visualization

Tap to expand

Understanding the Visualization

Ordered Traversal

Walk through the BST library in order - this naturally groups identical books together

Count Consecutive

As you encounter identical books, count them efficiently since they appear consecutively

Track Popularity

Keep track of the highest popularity (frequency) found so far

Identify Champions

Collect all books that achieve the maximum popularity level

Key Takeaway

🎯 Key Insight: BST's in-order traversal gives us values in sorted order, allowing efficient consecutive counting in a single pass - no hash table needed!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single in-order traversal visiting each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus result array

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
The tree is guaranteed to be a valid BST
Follow-up: Could you do that without using any extra space? (Assume the implicit stack space of the recursion doesn't count)

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution leverages the BST's in-order traversal property to process values in sorted order. This allows us to count frequencies of consecutive identical values in a single pass with O(n) time and O(h) space complexity, where h is the tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized In-Order Traversal (BST Property)	O(n)	O(h)	Leverage BST's in-order property for optimal single-pass solution
Two-Pass Hash Table	O(n)	O(n)	First pass counts frequencies, second pass finds modes
Brute Force (Collect All & Count)	O(n²)	O(n)	Collect all values in array, then count frequency of each value

Optimized In-Order Traversal (BST Property) — Algorithm Steps

Perform in-order traversal of BST (gives sorted sequence)
During traversal, count consecutive identical values
Keep track of current maximum frequency found so far
When frequency equals max, add to result; when frequency exceeds max, reset result
Return final result list containing all modes

Visualization

Tap to expand

Step-by-Step Walkthrough

In-Order Start

Begin in-order traversal, values appear sorted

Count Consecutive

Count consecutive identical values efficiently

Update Modes

Track maximum frequency and update result dynamically

Final Result

Complete traversal with all modes identified

Code -

solution.c — C

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

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

static int prevVal = INT_MIN;
static int currCount = 0;
static int maxCount = 0;
static int* result = NULL;
static int resultSize = 0;
static int resultCapacity = 0;
static int first = 1;

void addToResult(int val) {
    if (resultSize >= resultCapacity) {
        resultCapacity = resultCapacity == 0 ? 1 : resultCapacity * 2;
        result = (int*)realloc(result, resultCapacity * sizeof(int));
    }
    result[resultSize++] = val;
}

void inorder(struct TreeNode* node) {
    if (!node) return;
    
    // Traverse left subtree
    inorder(node->left);
    
    // Process current node
    if (!first && prevVal == node->val) {
        currCount++;
    } else {
        currCount = 1;
        prevVal = node->val;
        first = 0;
    }
    
    // Update result based on frequency
    if (currCount > maxCount) {
        maxCount = currCount;
        resultSize = 0; // Clear result
        addToResult(node->val);
    } else if (currCount == maxCount) {
        addToResult(node->val);
    }
    
    // Traverse right subtree
    inorder(node->right);
}

int* findMode(struct TreeNode* root, int* returnSize) {
    // Reset static variables
    prevVal = INT_MIN;
    currCount = 0;
    maxCount = 0;
    resultSize = 0;
    resultCapacity = 0;
    first = 1;
    if (result) {
        free(result);
        result = NULL;
    }
    
    inorder(root);
    *returnSize = resultSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single in-order traversal visiting each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus result array

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁵ ≤ Node.val ≤ 10⁵
The tree is guaranteed to be a valid BST
Follow-up: Could you do that without using any extra space? (Assume the implicit stack space of the recursion doesn't count)

89.4K Views

Medium 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

Optimized In-Order Traversal (BST Property) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler