All Elements in Two Binary Search Trees - Practice Coding Problems

All Elements in Two Binary Search Trees - Problem

You have two binary search trees containing integers, and your task is to merge all their elements into a single sorted list. This is like combining two sorted collections while maintaining the overall ascending order.

The Challenge: Given the root nodes of two BSTs (root1 and root2), return a list containing all integers from both trees sorted in ascending order.

Key Insight: Since BSTs naturally store elements in a way that supports in-order traversal to get sorted sequences, we can leverage this property for an efficient solution.

Example: If BST1 contains [2, 1, 4] and BST2 contains [1, 0, 3], the merged result should be [0, 1, 1, 2, 3, 4].

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Tree 1 contains values [1,2,4] in sorted order, Tree 2 contains [0,1,3]. Merging gives [0,1,1,2,3,4].

example_2.py — One Empty Tree

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

› Output: [0,1,2,5,7]

💡 Note: When one tree is empty, result is just the in-order traversal of the non-empty tree.

example_3.py — Both Empty

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

› Output: []

💡 Note: When both trees are empty, the result is an empty list.

Visualization

Tap to expand

Understanding the Visualization

Walk Through Collections

Traverse each BST in-order to get naturally sorted sequences

Set Two Readers

Position one reader at the start of each sorted collection

Pick Smaller Item

Compare current items, always pick the smaller one for the merged list

Advance Reader

Move the reader forward in whichever collection we just took from

Key Takeaway

🎯 Key Insight: BSTs give us sorted sequences through in-order traversal, so we can merge them efficiently like two sorted lists without re-sorting!

Time & Space Complexity

Time Complexity

⏱️

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

O(m+n) to traverse both trees plus O((m+n) log(m+n)) to sort the combined list

⚡ Linearithmic

Space Complexity

O(m+n)

Space needed to store all values from both trees in the result list

⚡ Linearithmic Space

Constraints

The number of nodes in each tree is in the range [0, 5000]
-10⁵ ≤ Node.val ≤ 10⁵
Both trees are valid binary search trees

Asked in

a Amazon 45 G Google 32 f Meta 28 ⊞ Microsoft 22

The optimal approach uses two-pointers technique after extracting sorted sequences from both BSTs via in-order traversal. This leverages the BST property that in-order traversal yields sorted order, achieving O(m+n) time complexity without unnecessary sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Collect All + Sort)	O((m+n) log(m+n))	O(m+n)	Extract all values from both trees and sort the combined list
Two Pointers (Merge Sorted Lists)	O(m+n)	O(m+n)	Extract values from both BSTs, then merge like two sorted arrays

Brute Force (Collect All + Sort) — Algorithm Steps

Perform in-order traversal on first BST to collect all values
Perform in-order traversal on second BST to collect all values
Combine both lists into a single list
Sort the combined list
Return the sorted result

Visualization

Tap to expand

Step-by-Step Walkthrough

Traverse Tree 1

Collect all values from first BST using in-order traversal

Traverse Tree 2

Collect all values from second BST using in-order traversal

Combine Lists

Merge both value lists into a single unsorted list

Sort Combined

Sort the entire combined list to get final result

Code -

solution.c — C

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

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

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

void inorder(struct TreeNode* root, int* values, int* size) {
    if (!root) return;
    inorder(root->left, values, size);
    values[(*size)++] = root->val;
    inorder(root->right, values, size);
}

int* getAllElements(struct TreeNode* root1, struct TreeNode* root2, int* returnSize) {
    int* result = (int*)malloc(10000 * sizeof(int));
    int size1 = 0, size2 = 0;
    
    inorder(root1, result, &size1);
    inorder(root2, result + size1, &size2);
    
    *returnSize = size1 + size2;
    qsort(result, *returnSize, sizeof(int), compare);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

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

O(m+n) to traverse both trees plus O((m+n) log(m+n)) to sort the combined list

⚡ Linearithmic

Space Complexity

O(m+n)

Space needed to store all values from both trees in the result list

⚡ Linearithmic Space

Constraints

The number of nodes in each tree is in the range [0, 5000]
-10⁵ ≤ Node.val ≤ 10⁵
Both trees are valid binary search trees

35.7K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force (Collect All + Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler