All Elements in Two Binary Search Trees

All Elements in Two Binary Search Trees - Problem

Given two binary search trees root1 and root2, return a list containing all the integers from both trees sorted in ascending order.

A binary search tree (BST) is a tree where for every node, all values in the left subtree are smaller and all values in the right subtree are larger than the node's value.

Constraints:

The number of nodes in each tree is in the range [0, 5000]
-10⁵ ≤ Node.val ≤ 10⁵

Input & Output

Example 1 — Basic Two BSTs

$ Input: root1 = [2,1,4], root2 = [1,0,3]

› Output: [0,1,1,2,3,4]

💡 Note: BST1 inorder: [1,2,4], BST2 inorder: [0,1,3]. Merged result: [0,1,1,2,3,4]

Example 2 — One Empty Tree

$ Input: root1 = [5,1,7], root2 = []

› Output: [1,5,7]

💡 Note: BST1 inorder: [1,5,7], BST2 is empty. Result is just BST1's values in sorted order.

Example 3 — Single Node Trees

$ Input: root1 = [1], root2 = [8]

› Output: [1,8]

💡 Note: BST1 has [1], BST2 has [8]. Combined sorted: [1,8]

Constraints

The number of nodes in each tree is in the range [0, 5000]
-10⁵ ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Asked in

A Amazon 38 G Google 25 M Microsoft 20 F Facebook 15

The key insight is leveraging the BST property: inorder traversal gives sorted order. Best approach is inorder traversal + merge - traverse each BST to get sorted arrays, then merge them like merging two sorted lists. Time: O(m+n), Space: O(m+n)

Common Approaches

✓ Collect All and Sort

⏱️ Time: O((m+n)log(m+n)) Space: O(m+n)

First traverse both BSTs to collect all node values into a single array. Then sort this array to get the final result in ascending order.

Inorder Traversal + Merge

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

Since inorder traversal of a BST gives values in sorted order, we can traverse both trees to get two sorted arrays, then merge them efficiently like merging two sorted lists.

Collect All and Sort — Algorithm Steps

Traverse first BST and collect all values
Traverse second BST and collect all values
Sort the combined array

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect from BST1

Traverse first tree and collect values

Collect from BST2

Traverse second tree and collect values

Sort Combined

Sort the combined array

Code -

solution.c — C

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

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

static int result[10000];
static int resultSize = 0;

void collectValues(struct TreeNode* node) {
    if (!node) return;
    collectValues(node->left);
    result[resultSize++] = node->val;
    collectValues(node->right);
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int* solution(struct TreeNode* root1, struct TreeNode* root2, int* returnSize) {
    resultSize = 0;
    
    collectValues(root1);
    collectValues(root2);
    
    qsort(result, resultSize, sizeof(int), compare);
    *returnSize = resultSize;
    return result;
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTree(char* line) {
    if (strcmp(line, "[]") == 0) return NULL;
    
    // Remove brackets
    line[strlen(line) - 1] = '\0';
    line++;
    
    static struct TreeNode* nodes[10000];
    int nodeCount = 0;
    
    char* token = strtok(line, ",");
    while (token) {
        // Trim whitespace
        while (isspace(*token)) token++;
        char* end = token + strlen(token) - 1;
        while (end > token && isspace(*end)) *end-- = '\0';
        
        if (strcmp(token, "null") == 0) {
            nodes[nodeCount++] = NULL;
        } else {
            nodes[nodeCount++] = createNode(atoi(token));
        }
        token = strtok(NULL, ",");
    }
    
    // Build tree structure
    for (int i = 0; i < nodeCount; i++) {
        if (nodes[i]) {
            int leftIdx = 2 * i + 1;
            int rightIdx = 2 * i + 2;
            if (leftIdx < nodeCount) nodes[i]->left = nodes[leftIdx];
            if (rightIdx < nodeCount) nodes[i]->right = nodes[rightIdx];
        }
    }
    
    return nodeCount > 0 ? nodes[0] : NULL;
}

int main() {
    static char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = '\0';
    line2[strcspn(line2, "\n")] = '\0';
    
    struct TreeNode* root1 = buildTree(line1);
    struct TreeNode* root2 = buildTree(line2);
    
    int returnSize;
    int* res = solution(root1, root2, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", res[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m+n)log(m+n))

Collecting values takes O(m+n), sorting takes O((m+n)log(m+n))

⚡ Linearithmic

Space Complexity

O(m+n)

Array to store all m+n values from both trees

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~18 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Collect All and Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler