Find Mode in Binary Search Tree

Find Mode in Binary Search Tree - Problem

Given the root of a binary search tree (BST) with duplicates, return all the mode(s) (i.e., the most frequently occurred element) in it.

If the tree has more than one mode, return them in any order.

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than or equal to the node's key.
The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
Both the left and right subtrees must also be binary search trees.

Input & Output

Example 1 — Basic BST

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

› Output: [2]

💡 Note: The value 2 appears twice while 1 appears once. So 2 is the mode.

Example 2 — Multiple Modes

$ Input: root = [0]

› Output: [0]

💡 Note: Single node tree, so 0 is the only and most frequent value.

Example 3 — Balanced BST

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

› Output: [0,1,2]

💡 Note: All values appear exactly once, so all are modes.

Constraints

The number of nodes in the tree is in the range [1, 10⁴].
-10⁵ ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is leveraging the BST's in-order traversal property to process values in sorted order. Best approach uses in-order DFS to count consecutive duplicates efficiently. Time: O(n), Space: O(h).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - HashMap Count

⏱️ Time: O(n) Space: O(n)

Use any traversal (DFS) to visit all nodes and store frequency counts in a hash map. Then scan the map to find the maximum frequency and collect all values with that frequency.

Optimized In-Order DFS

⏱️ Time: O(n) Space: O(h)

Leverage BST property by using in-order traversal which visits nodes in sorted order. Track current value and its count while traversing, updating modes when we find higher frequencies.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define INF 1000000000
#define MAX_N 100

int solution(int n, int edges[][3], int edgesSize, int distanceThreshold) {
    // Initialize distance matrix
    static int dist[MAX_N][MAX_N];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                dist[i][j] = 0;
            } else {
                dist[i][j] = INF;
            }
        }
    }
    
    // Set direct edge distances
    for (int i = 0; i < edgesSize; i++) {
        dist[edges[i][0]][edges[i][1]] = edges[i][2];
        dist[edges[i][1]][edges[i][0]] = edges[i][2];
    }
    
    // Floyd-Warshall algorithm
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (dist[i][k] != INF && dist[k][j] != INF &&
                    dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }
    
    // Find city with minimum reachable neighbors
    int minReachable = n + 1;
    int result = -1;
    
    for (int i = 0; i < n; i++) {
        int reachable = 0;
        for (int j = 0; j < n; j++) {
            if (i != j && dist[i][j] <= distanceThreshold) {
                reachable++;
            }
        }
        
        if (reachable <= minReachable) {
            minReachable = reachable;
            result = i;
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[1000];
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin); // read edges line
    
    int edges[MAX_N * MAX_N][3];
    int edgesSize = 0;
    
    // Simple parsing for edges array
    if (strcmp(line, "[]\n") != 0) {
        char* ptr = line;
        while (*ptr) {
            if (*ptr == '[' && *(ptr+1) != ']') {
                ptr++;
                edges[edgesSize][0] = atoi(ptr);
                while (*ptr && *ptr != ',') ptr++;
                ptr++;
                edges[edgesSize][1] = atoi(ptr);
                while (*ptr && *ptr != ',') ptr++;
                ptr++;
                edges[edgesSize][2] = atoi(ptr);
                edgesSize++;
            }
            ptr++;
        }
    }
    
    int distanceThreshold;
    scanf("%d", &distanceThreshold);
    
    int result = solution(n, edges, edgesSize, distanceThreshold);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

64.8K Views

Medium Frequency

~15 min Avg. Time

2.4K 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