# Merge Two Balanced Binary Search Trees

You are given two balanced binary search trees e.g., AVL or Red-Black Tree. Write a function that merges the two given balanced BSTs into a balanced binary search tree. Let there be m elements in the first tree and n elements in the other tree. Your merge function should take O(m+n) time.
In the following solutions, it is assumed that the sizes of trees are also given as input. If the size is not given, then we can get the size by traversing the tree (See this).

Method 1 (Insert elements of the first tree to the second):

Take all elements of the first BST one by one, and insert them into the second BST. Inserting an element to a self-balancing BST takes Logn time (See this) where n is the size of the BST. So time complexity of this method is Log(n) + Log(n+1) … Log(m+n-1). The value of this expression will be between mLogn and mLog(m+n-1). As an optimization, we can pick the smaller tree as the first tree.

Method 2 (Merge Inorder Traversals):

1. Do inorder traversal of the first tree and store the traversal in one temp array arr1[]. This step takes O(m) time.
2. Do inorder traversal of the second tree and store the traversal in another temp array arr2[]. This step takes O(n) time.
3. The arrays created in steps 1 and 2 are sorted arrays. Merge the two sorted arrays into one array of size m + n. This step takes O(m+n) time.
4. Construct a balanced tree from the merged array using the technique discussed in this post. This step takes O(m+n) time.

The time complexity of this method is O(m+n) which is better than method 1. This method takes O(m+n) time even if the input BSTs are not balanced.
Following is the implementation of this method.

## C++

 `// C++ program to Merge Two Balanced Binary Search Trees ` `#include` `using` `namespace` `std;`   `/* A binary tree node has data, pointer to left child ` `and a pointer to right child */` `class` `node ` `{ ` `    ``public``:` `    ``int` `data; ` `    ``node* left; ` `    ``node* right; ` `}; `   `// A utility function to merge two sorted arrays into one ` `int` `*merge(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n); `   `// A helper function that stores inorder` `// traversal of a tree in inorder array ` `void` `storeInorder(node* node, ``int` `inorder[],` `                            ``int` `*index_ptr); `   `/* A function that constructs Balanced` `Binary Search Tree from a sorted array ` `See https://www.geeksforgeeks.org/sorted-array-to-balanced-bst/ */` `node* sortedArrayToBST(``int` `arr[], ``int` `start, ``int` `end); `   `/* This function merges two balanced ` `BSTs with roots as root1 and root2. ` `m and n are the sizes of the trees respectively */` `node* mergeTrees(node *root1, node *root2, ``int` `m, ``int` `n) ` `{ ` `    ``// Store inorder traversal of ` `    ``// first tree in an array arr1[] ` `    ``int` `*arr1 = ``new` `int``[m]; ` `    ``int` `i = 0; ` `    ``storeInorder(root1, arr1, &i); `   `    ``// Store inorder traversal of second` `    ``// tree in another array arr2[] ` `    ``int` `*arr2 = ``new` `int``[n]; ` `    ``int` `j = 0; ` `    ``storeInorder(root2, arr2, &j); `   `    ``// Merge the two sorted array into one ` `    ``int` `*mergedArr = merge(arr1, arr2, m, n); `   `    ``// Construct a tree from the merged ` `    ``// array and return root of the tree ` `    ``return` `sortedArrayToBST (mergedArr, 0, m + n - 1); ` `} `   `/* Helper function that allocates` `a new node with the given data and ` `NULL left and right pointers. */` `node* newNode(``int` `data) ` `{ ` `    ``node* Node = ``new` `node();` `    ``Node->data = data; ` `    ``Node->left = NULL; ` `    ``Node->right = NULL; `   `    ``return``(Node); ` `} `   `// A utility function to print inorder` `// traversal of a given binary tree ` `void` `printInorder(node* node) ` `{ ` `    ``if` `(node == NULL) ` `        ``return``; `   `    ``/* first recur on left child */` `    ``printInorder(node->left); `   `    ``cout << node->data << ``" "``; `   `    ``/* now recur on right child */` `    ``printInorder(node->right); ` `} `   `// A utility function to merge` `// two sorted arrays into one ` `int` `*merge(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n) ` `{ ` `    ``// mergedArr[] is going to contain result ` `    ``int` `*mergedArr = ``new` `int``[m + n]; ` `    ``int` `i = 0, j = 0, k = 0; `   `    ``// Traverse through both arrays ` `    ``while` `(i < m && j < n) ` `    ``{ ` `        ``// Pick the smaller element and put it in mergedArr ` `        ``if` `(arr1[i] < arr2[j]) ` `        ``{ ` `            ``mergedArr[k] = arr1[i]; ` `            ``i++; ` `        ``} ` `        ``else` `        ``{ ` `            ``mergedArr[k] = arr2[j]; ` `            ``j++; ` `        ``} ` `        ``k++; ` `    ``} `   `    ``// If there are more elements in first array ` `    ``while` `(i < m) ` `    ``{ ` `        ``mergedArr[k] = arr1[i]; ` `        ``i++; k++; ` `    ``} `   `    ``// If there are more elements in second array ` `    ``while` `(j < n) ` `    ``{ ` `        ``mergedArr[k] = arr2[j]; ` `        ``j++; k++; ` `    ``} `   `    ``return` `mergedArr; ` `} `   `// A helper function that stores inorder` `// traversal of a tree rooted with node ` `void` `storeInorder(node* node, ``int` `inorder[], ``int` `*index_ptr) ` `{ ` `    ``if` `(node == NULL) ` `        ``return``; `   `    ``/* first recur on left child */` `    ``storeInorder(node->left, inorder, index_ptr); `   `    ``inorder[*index_ptr] = node->data; ` `    ``(*index_ptr)++; ``// increase index for next entry `   `    ``/* now recur on right child */` `    ``storeInorder(node->right, inorder, index_ptr); ` `} `   `/* A function that constructs Balanced ` `// Binary Search Tree from a sorted array ` `See https://www.geeksforgeeks.org/sorted-array-to-balanced-bst/ */` `node* sortedArrayToBST(``int` `arr[], ``int` `start, ``int` `end) ` `{ ` `    ``/* Base Case */` `    ``if` `(start > end) ` `    ``return` `NULL; `   `    ``/* Get the middle element and make it root */` `    ``int` `mid = (start + end)/2; ` `    ``node *root = newNode(arr[mid]); `   `    ``/* Recursively construct the left subtree and make it ` `    ``left child of root */` `    ``root->left = sortedArrayToBST(arr, start, mid-1); `   `    ``/* Recursively construct the right subtree and make it ` `    ``right child of root */` `    ``root->right = sortedArrayToBST(arr, mid+1, end); `   `    ``return` `root; ` `} `   `/* Driver code*/` `int` `main() ` `{ ` `    ``/* Create following tree as first balanced BST ` `        ``100 ` `        ``/ \ ` `        ``50 300 ` `    ``/ \ ` `    ``20 70 ` `    ``*/` `    ``node *root1 = newNode(100); ` `    ``root1->left     = newNode(50); ` `    ``root1->right = newNode(300); ` `    ``root1->left->left = newNode(20); ` `    ``root1->left->right = newNode(70); `   `    ``/* Create following tree as second balanced BST ` `            ``80 ` `        ``/ \ ` `        ``40 120 ` `    ``*/` `    ``node *root2 = newNode(80); ` `    ``root2->left     = newNode(40); ` `    ``root2->right = newNode(120); `   `    ``node *mergedTree = mergeTrees(root1, root2, 5, 3); `   `    ``cout << ``"Following is Inorder traversal of the merged tree \n"``; ` `    ``printInorder(mergedTree); `   `    ``return` `0; ` `} `   `// This code is contributed by rathbhupendra`

## C

 `// C program to Merge Two Balanced Binary Search Trees` `#include ` `#include `   `/* A binary tree node has data, pointer to left child` `   ``and a pointer to right child */` `struct` `node` `{` `    ``int` `data;` `    ``struct` `node* left;` `    ``struct` `node* right;` `};`   `// A utility function to merge two sorted arrays into one` `int` `*merge(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n);`   `// A helper function that stores inorder traversal of a tree in inorder array` `void` `storeInorder(``struct` `node* node, ``int` `inorder[], ``int` `*index_ptr);`   `/* A function that constructs Balanced Binary Search Tree from a sorted array` `   ``See https://www.geeksforgeeks.org/sorted-array-to-balanced-bst/ */` `struct` `node* sortedArrayToBST(``int` `arr[], ``int` `start, ``int` `end);`   `/* This function merges two balanced BSTs with roots as root1 and root2.` `   ``m and n are the sizes of the trees respectively */` `struct` `node* mergeTrees(``struct` `node *root1, ``struct` `node *root2, ``int` `m, ``int` `n)` `{` `    ``// Store inorder traversal of first tree in an array arr1[]` `    ``int` `*arr1 = ``new` `int``[m];` `    ``int` `i = 0;` `    ``storeInorder(root1, arr1, &i);`   `    ``// Store inorder traversal of second tree in another array arr2[]` `    ``int` `*arr2 = ``new` `int``[n];` `    ``int` `j = 0;` `    ``storeInorder(root2, arr2, &j);`   `    ``// Merge the two sorted array into one` `    ``int` `*mergedArr = merge(arr1, arr2, m, n);`   `    ``// Construct a tree from the merged array and return root of the tree` `    ``return` `sortedArrayToBST (mergedArr, 0, m+n-1);` `}`   `/* Helper function that allocates a new node with the` `   ``given data and NULL left and right pointers. */` `struct` `node* newNode(``int` `data)` `{` `    ``struct` `node* node = (``struct` `node*)` `                        ``malloc``(``sizeof``(``struct` `node));` `    ``node->data = data;` `    ``node->left = NULL;` `    ``node->right = NULL;`   `    ``return``(node);` `}`   `// A utility function to print inorder traversal of a given binary tree` `void` `printInorder(``struct` `node* node)` `{` `    ``if` `(node == NULL)` `        ``return``;`   `    ``/* first recur on left child */` `    ``printInorder(node->left);`   `    ``printf``(``"%d "``, node->data);`   `    ``/* now recur on right child */` `    ``printInorder(node->right);` `}`   `// A utility function to merge two sorted arrays into one` `int` `*merge(``int` `arr1[], ``int` `arr2[], ``int` `m, ``int` `n)` `{` `    ``// mergedArr[] is going to contain result` `    ``int` `*mergedArr = ``new` `int``[m + n];` `    ``int` `i = 0, j = 0, k = 0;`   `    ``// Traverse through both arrays` `    ``while` `(i < m && j < n)` `    ``{` `        ``// Pick the smaller element and put it in mergedArr` `        ``if` `(arr1[i] < arr2[j])` `        ``{` `            ``mergedArr[k] = arr1[i];` `            ``i++;` `        ``}` `        ``else` `        ``{` `            ``mergedArr[k] = arr2[j];` `            ``j++;` `        ``}` `        ``k++;` `    ``}`   `    ``// If there are more elements in first array` `    ``while` `(i < m)` `    ``{` `        ``mergedArr[k] = arr1[i];` `        ``i++; k++;` `    ``}`   `    ``// If there are more elements in second array` `    ``while` `(j < n)` `    ``{` `        ``mergedArr[k] = arr2[j];` `        ``j++; k++;` `    ``}`   `    ``return` `mergedArr;` `}`   `// A helper function that stores inorder traversal of a tree rooted with node` `void` `storeInorder(``struct` `node* node, ``int` `inorder[], ``int` `*index_ptr)` `{` `    ``if` `(node == NULL)` `        ``return``;`   `    ``/* first recur on left child */` `    ``storeInorder(node->left, inorder, index_ptr);`   `    ``inorder[*index_ptr] = node->data;` `    ``(*index_ptr)++;  ``// increase index for next entry`   `    ``/* now recur on right child */` `    ``storeInorder(node->right, inorder, index_ptr);` `}`   `/* A function that constructs Balanced Binary Search Tree from a sorted array` `   ``See https://www.geeksforgeeks.org/sorted-array-to-balanced-bst/ */` `struct` `node* sortedArrayToBST(``int` `arr[], ``int` `start, ``int` `end)` `{` `    ``/* Base Case */` `    ``if` `(start > end)` `      ``return` `NULL;`   `    ``/* Get the middle element and make it root */` `    ``int` `mid = (start + end)/2;` `    ``struct` `node *root = newNode(arr[mid]);`   `    ``/* Recursively construct the left subtree and make it` `       ``left child of root */` `    ``root->left =  sortedArrayToBST(arr, start, mid-1);`   `    ``/* Recursively construct the right subtree and make it` `       ``right child of root */` `    ``root->right = sortedArrayToBST(arr, mid+1, end);`   `    ``return` `root;` `}`   `/* Driver program to test above functions*/` `int` `main()` `{` `    ``/* Create following tree as first balanced BST` `           ``100` `          ``/  \` `        ``50    300` `       ``/ \` `      ``20  70` `    ``*/` `    ``struct` `node *root1  = newNode(100);` `    ``root1->left         = newNode(50);` `    ``root1->right        = newNode(300);` `    ``root1->left->left   = newNode(20);` `    ``root1->left->right  = newNode(70);`   `    ``/* Create following tree as second balanced BST` `            ``80` `           ``/  \` `         ``40   120` `    ``*/` `    ``struct` `node *root2  = newNode(80);` `    ``root2->left         = newNode(40);` `    ``root2->right        = newNode(120);`   `    ``struct` `node *mergedTree = mergeTrees(root1, root2, 5, 3);`   `    ``printf` `(``"Following is Inorder traversal of the merged tree \n"``);` `    ``printInorder(mergedTree);`   `    ``getchar``();` `    ``return` `0;` `}`

## Java

 `// Java program to Merge Two Balanced Binary Search Trees` `import` `java.io.*;` `import` `java.util.ArrayList;`   `// A binary tree node` `class` `Node {` `    `  `    ``int` `data;` `    ``Node left, right;` `    `  `    ``Node(``int` `d) {` `        ``data = d;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinarySearchTree` `{` `    `  `    ``// Root of BST` `    ``Node root;`   `    ``// Constructor` `    ``BinarySearchTree() { ` `        ``root = ``null``; ` `    ``}` `    `  `    ``// Inorder traversal of the tree` `    ``void` `inorder()` `    ``{` `        ``inorderUtil(``this``.root);` `    ``}` `    `  `// Utility function for inorder traversal of the tree` `void` `inorderUtil(Node node)` `{` `    ``if``(node==``null``)` `        ``return``;` `        `  `    ``inorderUtil(node.left);` `    ``System.out.print(node.data + ``" "``);` `    ``inorderUtil(node.right);` `}` `    `    `    ``// A Utility Method that stores inorder traversal of a tree` `    ``public` `ArrayList storeInorderUtil(Node node, ArrayList list)` `    ``{` `        ``if``(node == ``null``)` `            ``return` `list;` `        `  `        ``//recur on the left child` `        ``storeInorderUtil(node.left, list);` `        `  `        ``// Adds data to the list` `        ``list.add(node.data);` `        `  `        ``//recur on the right child` `        ``storeInorderUtil(node.right, list);` `        `  `        ``return` `list;` `    ``}` `    `  `    ``// Method that stores inorder traversal of a tree` `    ``ArrayList storeInorder(Node node)` `    ``{` `        ``ArrayList list1 = ``new` `ArrayList<>(); ` `        ``ArrayList list2 = storeInorderUtil(node,list1); ` `        ``return` `list2;` `    ``}`   `    ``// Method that merges two ArrayLists into one. ` `    ``ArrayList merge(ArrayListlist1, ArrayListlist2, ``int` `m, ``int` `n)` `    ``{` `        ``// list3 will contain the merge of list1 and list2` `        ``ArrayList list3 = ``new` `ArrayList<>();` `        ``int` `i=``0``;` `        ``int` `j=``0``;` `        `  `        ``//Traversing through both ArrayLists` `        ``while``( ilist, ``int` `start, ``int` `end)` `    ``{` `        ``// Base case` `        ``if``(start > end)` `            ``return` `null``;` `    `  `        ``// Get the middle element and make it root     ` `        ``int` `mid = (start+end)/``2``;` `        ``Node node = ``new` `Node(list.get(mid));`   `        ``/* Recursively construct the left subtree and make it` `        ``left child of root */` `        ``node.left = ALtoBST(list, start, mid-``1``);` `        `  `        ``/* Recursively construct the right subtree and make it` `        ``right child of root */` `        ``node.right = ALtoBST(list, mid+``1``, end);` `    `  `    ``return` `node;` `    ``}` `    `  `    ``// Method that merges two trees into a single one. ` `    ``Node mergeTrees(Node node1, Node node2)` `    ``{` `        ``//Stores Inorder of tree1 to list1` `        ``ArrayListlist1 = storeInorder(node1);` `        `  `        ``//Stores Inorder of tree2 to list2` `        ``ArrayListlist2 = storeInorder(node2);` `        `  `        ``// Merges both list1 and list2 into list3` `        ``ArrayListlist3 = merge(list1, list2, list1.size(), list2.size());` `        `  `        ``//Eventually converts the merged list into resultant BST` `        ``Node node = ALtoBST(list3, ``0``, list3.size()-``1``);` `        ``return` `node;` `    ``}`   `    ``// Driver function` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        `  `        ``/* Creating following tree as First balanced BST` `                ``100` `                ``/ \` `                ``50 300` `                ``/ \` `               ``20 70` `        ``*/` `        `  `        ``BinarySearchTree tree1 = ``new` `BinarySearchTree();` `        ``tree1.root = ``new` `Node(``100``);` `        ``tree1.root.left = ``new` `Node(``50``);` `        ``tree1.root.right = ``new` `Node(``300``);` `        ``tree1.root.left.left = ``new` `Node(``20``);` `        ``tree1.root.left.right = ``new` `Node(``70``);` `        `  `        ``/* Creating following tree as second balanced BST` `                ``80` `                ``/ \` `              ``40 120` `        ``*/` `            `  `        ``BinarySearchTree tree2 = ``new` `BinarySearchTree();` `        ``tree2.root = ``new` `Node(``80``);    ` `        ``tree2.root.left = ``new` `Node(``40``);` `        ``tree2.root.right = ``new` `Node(``120``);` `            `  `            `  `        ``BinarySearchTree tree = ``new` `BinarySearchTree();    ` `        ``tree.root = tree.mergeTrees(tree1.root, tree2.root);` `        ``System.out.println(``"The Inorder traversal of the merged BST is: "``);` `        ``tree.inorder();` `    ``}` `}` `// This code has been contributed by Kamal Rawal`

## Python3

 `# A binary tree node has data, pointer to left child  ` `# and a pointer to right child` `class` `Node:` `    ``def` `__init__(``self``, val):` `        ``self``.val ``=` `val` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# A utility function to merge two sorted arrays into one` `# Time Complexity of below function: O(m + n)` `# Space Complexity of below function: O(m + n)` `def` `merge_sorted_arr(arr1, arr2):` `    ``arr ``=` `[]` `    ``i ``=` `j ``=` `0` `    ``while` `i < ``len``(arr1) ``and` `j < ``len``(arr2):` `        ``if` `arr1[i] <``=` `arr2[j]:` `            ``arr.append(arr1[i])` `            ``i ``+``=` `1` `        ``else``:` `            ``arr.append(arr2[j])` `            ``j ``+``=` `1` `    ``while` `i < ``len``(arr1):` `        ``arr.append(arr1[i])` `        ``i ``+``=` `1` `    ``while` `i < ``len``(arr2):` `        ``arr.append(arr2[j])` `        ``j ``+``=` `1` `    ``return` `arr`   `# A helper function that stores inorder` `# traversal of a tree in arr` `def` `inorder(root, arr ``=` `[]):` `    ``if` `root:` `        ``inorder(root.left, arr)` `        ``arr.append(root.val)` `        ``inorder(root.right, arr)`   `# A utility function to insert the values` `# in the individual Tree` `def` `insert(root, val):` `    ``if` `not` `root:` `        ``return` `Node(val)` `    ``if` `root.val ``=``=` `val:` `        ``return` `root` `    ``elif` `root.val > val:` `        ``root.left ``=` `insert(root.left, val)` `    ``else``:` `        ``root.right ``=` `insert(root.right, val)` `    ``return` `root`   `# Converts the merged array to a balanced BST` `# Explanation of the below code:` `# https://www.geeksforgeeks.org/sorted-array-to-balanced-bst/` `def` `arr_to_bst(arr):` `    ``if` `not` `arr:` `        ``return` `None` `    ``mid ``=` `len``(arr) ``/``/` `2` `    ``root ``=` `Node(arr[mid])` `    ``root.left ``=` `arr_to_bst(arr[:mid])` `    ``root.right ``=` `arr_to_bst(arr[mid ``+` `1``:])` `    ``return` `root`   `if` `__name__``=``=``'__main__'``:` `    ``root1 ``=` `root2 ``=` `None` `    `  `    ``# Inserting values in first tree` `    ``root1 ``=` `insert(root1, ``100``)` `    ``root1 ``=` `insert(root1, ``50``)` `    ``root1 ``=` `insert(root1, ``300``)` `    ``root1 ``=` `insert(root1, ``20``)` `    ``root1 ``=` `insert(root1, ``70``)` `    `  `    ``# Inserting values in second tree` `    ``root2 ``=` `insert(root2, ``80``)` `    ``root2 ``=` `insert(root2, ``40``)` `    ``root2 ``=` `insert(root2, ``120``)` `    ``arr1 ``=` `[]` `    ``inorder(root1, arr1)` `    ``arr2 ``=` `[]` `    ``inorder(root2, arr2)` `    ``arr ``=` `merge_sorted_arr(arr1, arr2)` `    ``root ``=` `arr_to_bst(arr)` `    ``res ``=` `[]` `    ``inorder(root, res)` `    ``print``(``'Following is Inorder traversal of the merged tree'``)` `    ``for` `i ``in` `res:` `      ``print``(i, end ``=` `' '``)` `      `  `# This code is contributed by Flarow4`

## C#

 `// C# program to Merge Two Balanced Binary Search Trees` `using` `System;` `using` `System.Collections.Generic;`   `// A binary tree node ` `public` `class` `Node` `{`   `    ``public` `int` `data;` `    ``public` `Node left, right;`   `    ``public` `Node(``int` `d)` `    ``{` `        ``data = d;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `BinarySearchTree` `{`   `    ``// Root of BST ` `    ``public` `Node root;`   `    ``// Constructor ` `    ``public` `BinarySearchTree()` `    ``{` `        ``root = ``null``;` `    ``}`   `    ``// Inorder traversal of the tree ` `    ``public` `virtual` `void` `inorder()` `    ``{` `        ``inorderUtil(``this``.root);` `    ``}`   `// Utility function for inorder traversal of the tree ` `public` `virtual` `void` `inorderUtil(Node node)` `{` `    ``if` `(node == ``null``)` `    ``{` `        ``return``;` `    ``}`   `    ``inorderUtil(node.left);` `    ``Console.Write(node.data + ``" "``);` `    ``inorderUtil(node.right);` `}`     `    ``// A Utility Method that stores inorder traversal of a tree ` `    ``public` `virtual` `List<``int``> storeInorderUtil(Node node, List<``int``> list)` `    ``{` `        ``if` `(node == ``null``)` `        ``{` `            ``return` `list;` `        ``}`   `        ``//recur on the left child ` `        ``storeInorderUtil(node.left, list);`   `        ``// Adds data to the list ` `        ``list.Add(node.data);`   `        ``//recur on the right child ` `        ``storeInorderUtil(node.right, list);`   `        ``return` `list;` `    ``}`   `    ``// Method that stores inorder traversal of a tree ` `    ``public` `virtual` `List<``int``> storeInorder(Node node)` `    ``{` `        ``List<``int``> list1 = ``new` `List<``int``>();` `        ``List<``int``> list2 = storeInorderUtil(node,list1);` `        ``return` `list2;` `    ``}`   `    ``// Method that merges two ArrayLists into one.  ` `    ``public` `virtual` `List<``int``> merge(List<``int``> list1, List<``int``> list2, ``int` `m, ``int` `n)` `    ``{` `        ``// list3 will contain the merge of list1 and list2 ` `        ``List<``int``> list3 = ``new` `List<``int``>();` `        ``int` `i = 0;` `        ``int` `j = 0;`   `        ``//Traversing through both ArrayLists ` `        ``while` `(i < m && j < n)` `        ``{` `            ``// Smaller one goes into list3 ` `            ``if` `(list1[i] < list2[j])` `            ``{` `                ``list3.Add(list1[i]);` `                ``i++;` `            ``}` `            ``else` `            ``{` `                ``list3.Add(list2[j]);` `                ``j++;` `            ``}` `        ``}`   `        ``// Adds the remaining elements of list1 into list3 ` `        ``while` `(i < m)` `        ``{` `            ``list3.Add(list1[i]);` `            ``i++;` `        ``}`   `        ``// Adds the remaining elements of list2 into list3 ` `        ``while` `(j < n)` `        ``{` `            ``list3.Add(list2[j]);` `            ``j++;` `        ``}` `        ``return` `list3;` `    ``}`   `    ``// Method that converts an ArrayList to a BST ` `    ``public` `virtual` `Node ALtoBST(List<``int``> list, ``int` `start, ``int` `end)` `    ``{` `        ``// Base case ` `        ``if` `(start > end)` `        ``{` `            ``return` `null``;` `        ``}`   `        ``// Get the middle element and make it root      ` `        ``int` `mid = (start + end) / 2;` `        ``Node node = ``new` `Node(list[mid]);`   `        ``/* Recursively construct the left subtree and make it ` `        ``left child of root */` `        ``node.left = ALtoBST(list, start, mid - 1);`   `        ``/* Recursively construct the right subtree and make it ` `        ``right child of root */` `        ``node.right = ALtoBST(list, mid + 1, end);`   `    ``return` `node;` `    ``}`   `    ``// Method that merges two trees into a single one.  ` `    ``public` `virtual` `Node mergeTrees(Node node1, Node node2)` `    ``{` `        ``//Stores Inorder of tree1 to list1 ` `        ``List<``int``> list1 = storeInorder(node1);`   `        ``//Stores Inorder of tree2 to list2 ` `        ``List<``int``> list2 = storeInorder(node2);`   `        ``// Merges both list1 and list2 into list3 ` `        ``List<``int``> list3 = merge(list1, list2, list1.Count, list2.Count);`   `        ``//Eventually converts the merged list into resultant BST ` `        ``Node node = ALtoBST(list3, 0, list3.Count - 1);` `        ``return` `node;` `    ``}`   `    ``// Driver function ` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{`   `        ``/* Creating following tree as First balanced BST ` `                ``100 ` `                ``/ \ ` `                ``50 300 ` `                ``/ \ ` `               ``20 70 ` `        ``*/`   `        ``BinarySearchTree tree1 = ``new` `BinarySearchTree();` `        ``tree1.root = ``new` `Node(100);` `        ``tree1.root.left = ``new` `Node(50);` `        ``tree1.root.right = ``new` `Node(300);` `        ``tree1.root.left.left = ``new` `Node(20);` `        ``tree1.root.left.right = ``new` `Node(70);`   `        ``/* Creating following tree as second balanced BST ` `                ``80 ` `                ``/ \ ` `              ``40 120 ` `        ``*/`   `        ``BinarySearchTree tree2 = ``new` `BinarySearchTree();` `        ``tree2.root = ``new` `Node(80);` `        ``tree2.root.left = ``new` `Node(40);` `        ``tree2.root.right = ``new` `Node(120);`     `        ``BinarySearchTree tree = ``new` `BinarySearchTree();` `        ``tree.root = tree.mergeTrees(tree1.root, tree2.root);` `        ``Console.WriteLine(``"The Inorder traversal of the merged BST is: "``);` `        ``tree.inorder();` `    ``}` `}`   `  ``// This code is contributed by Shrikant13`

## Javascript

 ``

Output

```Following is Inorder traversal of the merged tree
20 40 50 70 80 100 120 300

```

Time complexity: O(m+n), where m and n are the numbers of elements in the two binary search trees.
Space complexity: O(m+n). This is because we need to allocate space for the two arrays that store the elements from the two binary search trees, as well as an array to store the merged elements.

Method 3 (In-Place Merge using DLL):

We can use a Doubly Linked List to merge trees in place. Following are the steps.

1. Convert the given two Binary Search Trees into a doubly linked list in place (Refer to this post for this step).
2. Merge the two sorted Linked Lists (Refer to this post for this step).
3. Build a Balanced Binary Search Tree from the merged list created in step 2. (Refer to this post for this step)

The time complexity of this method is also O(m+n) and this method does conversion in place.
Thanks to Dheeraj and Ronzii for suggesting this method.

## C++

 `// C++ Code for the above approach`   `#include ` `using` `namespace` `std;`   `/* A binary tree node has data,` `a pointer to left child` `and a pointer to right child */` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* left;` `    ``Node* right;` `};`   `// Function to return a new Node` `Node* newNode(``int` `data)` `{` `    ``Node* node = ``new` `Node();` `    ``node->data = data;` `    ``node->left = NULL;` `    ``node->right = NULL;`   `    ``return` `(node);` `}`   `// Function to convert bst to` `// a doubly linked list` `void` `bstTodll(Node* root, Node*& head)` `{` `    ``// if root is NULL` `    ``if` `(!root)` `        ``return``;`   `    ``// Convert right subtree recursively` `    ``bstTodll(root->right, head);`   `    ``// Update root` `    ``root->right = head;`   `    ``// if head is not NULL` `    ``if` `(head) {`   `        ``// Update left of the head` `        ``head->left = root;` `    ``}`   `    ``// Update head` `    ``head = root;`   `    ``// Convert left subtree recursively` `    ``bstTodll(root->left, head);` `}`   `// Function to merge two sorted linked list` `Node* mergeLinkedList(Node* head1, Node* head2)` `{`   `    ``/*Create head and tail for result list*/` `    ``Node* head = NULL;` `    ``Node* tail = NULL;`   `    ``while` `(head1 && head2) {`   `        ``if` `(head1->data < head2->data) {`   `            ``if` `(!head)` `                ``head = head1;` `            ``else` `{`   `                ``tail->right = head1;` `                ``head1->left = tail;` `            ``}`   `            ``tail = head1;` `            ``head1 = head1->right;` `        ``}`   `        ``else` `{`   `            ``if` `(!head)` `                ``head = head2;` `            ``else` `{` `                ``tail->right = head2;` `                ``head2->left = tail;` `            ``}`   `            ``tail = head2;` `            ``head2 = head2->right;` `        ``}` `    ``}`   `    ``while` `(head1) {` `        ``tail->right = head1;` `        ``head1->left = tail;` `        ``tail = head1;` `        ``head1 = head1->right;` `    ``}`   `    ``while` `(head2) {` `        ``tail->right = head2;` `        ``head2->left = tail;` `        ``tail = head2;` `        ``head2 = head2->right;` `    ``}`   `    ``// Return the created DLL` `    ``return` `head;` `}`   `// function to convert list to bst` `Node* sortedListToBST(Node*& head, ``int` `n)` `{` `    ``// if no element is left or head is null` `    ``if` `(n <= 0 || !head)` `        ``return` `NULL;`   `    ``// Create left part from the list recursively` `    ``Node* left = sortedListToBST(head, n / 2);`   `    ``Node* root = head;` `    ``root->left = left;` `    ``head = head->right;`   `    ``// Create left part from the list recursively` `    ``root->right = sortedListToBST(head, n - (n / 2) - 1);`   `    ``// Return the root of BST` `    ``return` `root;` `}`   `// This function merges two balanced BSTs` `Node* mergeTrees(Node* root1, Node* root2, ``int` `m, ``int` `n)` `{` `    ``// Convert BSTs into sorted Doubly Linked Lists`   `    ``Node* head1 = NULL;` `    ``bstTodll(root1, head1);` `    ``head1->left = NULL;`   `    ``Node* head2 = NULL;` `    ``bstTodll(root2, head2);` `    ``head2->left = NULL;`   `    ``// Merge the two sorted lists into one` `    ``Node* head = mergeLinkedList(head1, head2);`   `    ``// Construct a tree from the merged lists` `    ``return` `sortedListToBST(head, m + n);` `}`   `void` `printInorder(Node* node)` `{` `    ``// if current node is NULL` `    ``if` `(!node) {` `        ``return``;` `    ``}`   `    ``printInorder(node->left);`   `      ``// Print node of current data` `    ``cout << node->data << ``" "``;`   `    ``printInorder(node->right);` `}`   `/* Driver code*/` `int` `main()` `{` `    ``/* Create following tree as first balanced BST` `       ``100` `       ``/ \` `      ``50 300` `     ``/ \` `    ``20 70   */`   `    ``Node* root1 = newNode(100);` `    ``root1->left = newNode(50);` `    ``root1->right = newNode(300);` `    ``root1->left->left = newNode(20);` `    ``root1->left->right = newNode(70);`   `    ``/* Create following tree as second balanced BST` `             ``80` `            ``/ \` `           ``40 120` `    ``*/` `    ``Node* root2 = newNode(80);` `    ``root2->left = newNode(40);` `    ``root2->right = newNode(120);`   `      ``// Function Call` `    ``Node* mergedTree = mergeTrees(root1, root2, 5, 3);`   `    ``cout << ``"Following is Inorder traversal of the merged "` `            ``"tree \n"``;` `    ``printInorder(mergedTree);`   `    ``return` `0;` `}`   `// This code is contributed by Tapesh(tapeshdua420)`

## Java

 `// Java Code for the above approach` `import` `java.util.*;`   `/* A binary tree node has data,` `a pointer to left child` `and a pointer to right child */` `class` `Node {` `    ``int` `data;` `    ``Node left, right;`   `    ``Node(``int` `d)` `    ``{` `        ``data = d;` `        ``left = right = ``null``;` `    ``}` `}`   `// Function to return a new Node` `public` `class` `Main {`   `    ``Node newNode(``int` `data)` `    ``{` `        ``Node node = ``new` `Node(data);` `        ``node.left = ``null``;` `        ``node.right = ``null``;` `        ``return` `(node);` `    ``}`   `    ``// Function to convert bst to a doubly linked list` `    ``void` `bstTodll(Node root, Node[] head)` `    ``{`   `        ``// if root is NULL` `        ``if` `(root == ``null``)` `            ``return``;`   `        ``// Convert right subtree recursively` `        ``bstTodll(root.right, head);`   `        ``// Update root` `        ``root.right = head[``0``];`   `        ``// if head is not NULL` `        ``if` `(head[``0``] != ``null``) {`   `            ``// Update left of the head` `            ``head[``0``].left = root;` `        ``}`   `        ``// Update head` `        ``head[``0``] = root;`   `        ``// Convert left subtree recursively` `        ``bstTodll(root.left, head);` `    ``}`   `    ``// Function to merge two sorted linked list` `    ``Node mergeLinkedList(Node head1, Node head2)` `    ``{`   `        ``/*Create head and tail for result list*/` `        ``Node head = ``null``, tail = ``null``;` `        ``while` `(head1 != ``null` `&& head2 != ``null``) {` `            ``if` `(head1.data < head2.data) {` `                ``if` `(head == ``null``) {` `                    ``head = head1;` `                ``}` `                ``else` `{` `                    ``tail.right = head1;` `                    ``head1.left = tail;` `                ``}` `                ``tail = head1;` `                ``head1 = head1.right;` `            ``}` `            ``else` `{` `                ``if` `(head == ``null``) {` `                    ``head = head2;` `                ``}` `                ``else` `{` `                    ``tail.right = head2;` `                    ``head2.left = tail;` `                ``}` `                ``tail = head2;` `                ``head2 = head2.right;` `            ``}` `        ``}` `        ``while` `(head1 != ``null``) {` `            ``tail.right = head1;` `            ``head1.left = tail;` `            ``tail = head1;` `            ``head1 = head1.right;` `        ``}` `        ``while` `(head2 != ``null``) {` `            ``tail.right = head2;` `            ``head2.left = tail;` `            ``tail = head2;` `            ``head2 = head2.right;` `        ``}`   `        ``// Return the created DLL` `        ``return` `head;` `    ``}`   `    ``// function to convert list to bst` `    ``Node sortedListToBST(Node[] head, ``int` `n)` `    ``{`   `        ``// if no element is left or head is null` `        ``if` `(n <= ``0` `|| head[``0``] == ``null``)` `            ``return` `null``;`   `        ``// Create left part from the list recursively` `        ``Node left = sortedListToBST(head, n / ``2``);` `        ``Node root = head[``0``];` `        ``root.left = left;` `        ``head[``0``] = head[``0``].right;`   `        ``// Create left part from the list recursively` `        ``root.right = sortedListToBST(head, n - (n / ``2``) - ``1``);`   `        ``// Return the root of BST` `        ``return` `root;` `    ``}`   `    ``// This function merges two balanced BSTs` `    ``Node mergeTrees(Node root1, Node root2, ``int` `m, ``int` `n)` `    ``{`   `        ``// Convert BSTs into sorted Doubly Linked Lists`   `        ``Node[] head1 = ``new` `Node[``1``];` `        ``head1[``0``] = ``null``;` `        ``bstTodll(root1, head1);` `        ``head1[``0``].left = ``null``;`   `        ``Node[] head2 = ``new` `Node[``1``];` `        ``head2[``0``] = ``null``;` `        ``bstTodll(root2, head2);` `        ``head2[``0``].left = ``null``;`   `        ``// Merge the two sorted lists into one` `        ``Node head = mergeLinkedList(head1[``0``], head2[``0``]);`   `        ``// Construct a tree from the merged lists` `        ``return` `sortedListToBST(``new` `Node[] { head }, m + n);` `    ``}`   `    ``void` `printInorder(Node node)` `    ``{`   `        ``// if current node is NULL` `        ``if` `(node == ``null``) {` `            ``return``;` `        ``}` `        ``printInorder(node.left);`   `        ``// Print node of current data` `        ``System.out.print(node.data + ``" "``);`   `        ``printInorder(node.right);` `    ``}`   `    ``/* Driver code*/` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``Main obj = ``new` `Main();`   `        ``/* Create following tree as first balanced BST` `           ``100` `           ``/ \` `          ``50 300` `         ``/ \` `        ``20 70   */`   `        ``Node root1 = obj.newNode(``100``);` `        ``root1.left = obj.newNode(``50``);` `        ``root1.right = obj.newNode(``300``);` `        ``root1.left.left = obj.newNode(``20``);` `        ``root1.left.right = obj.newNode(``70``);`   `        ``/* Create following tree as second balanced BST` `                ``80` `               ``/ \` `              ``40 120` `       ``*/`   `        ``Node root2 = obj.newNode(``80``);` `        ``root2.left = obj.newNode(``40``);` `        ``root2.right = obj.newNode(``120``);`   `        ``// Function Call` `        ``Node mergedTree` `            ``= obj.mergeTrees(root1, root2, ``5``, ``3``);`   `        ``System.out.println(` `            ``"Following is Inorder traversal of the merged tree:"``);` `        ``obj.printInorder(mergedTree);` `    ``}` `}`

## Python

 `class` `TreeNode:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `class` `Solution:` `    ``def` `__init__(``self``):` `        ``self``.head1 ``=` `[``None``]` `        ``self``.head2 ``=` `[``None``]`   `    ``def` `newNode(``self``, data):` `        ``node ``=` `TreeNode(data)` `        ``node.left ``=` `None` `        ``node.right ``=` `None` `        ``return` `node`   `    ``def` `bstToDLL(``self``, root, head):` `        ``if` `not` `root:` `            ``return`   `        ``self``.bstToDLL(root.right, head)`   `        ``root.right ``=` `head[``0``]`   `        ``if` `head[``0``]:` `            ``head[``0``].left ``=` `root`   `        ``head[``0``] ``=` `root`   `        ``self``.bstToDLL(root.left, head)`   `    ``def` `mergeLinkedList(``self``, head1, head2):` `        ``head ``=` `None` `        ``tail ``=` `None`   `        ``while` `head1 ``and` `head2:` `            ``if` `head1.data < head2.data:` `                ``if` `not` `head:` `                    ``head ``=` `head1` `                ``else``:` `                    ``tail.right ``=` `head1` `                    ``head1.left ``=` `tail` `                ``tail ``=` `head1` `                ``head1 ``=` `head1.right` `            ``else``:` `                ``if` `not` `head:` `                    ``head ``=` `head2` `                ``else``:` `                    ``tail.right ``=` `head2` `                    ``head2.left ``=` `tail` `                ``tail ``=` `head2` `                ``head2 ``=` `head2.right`   `        ``while` `head1:` `            ``tail.right ``=` `head1` `            ``head1.left ``=` `tail` `            ``tail ``=` `head1` `            ``head1 ``=` `head1.right`   `        ``while` `head2:` `            ``tail.right ``=` `head2` `            ``head2.left ``=` `tail` `            ``tail ``=` `head2` `            ``head2 ``=` `head2.right`   `        ``return` `head`   `    ``def` `sortedListToBST(``self``, head, n):` `        ``if` `n <``=` `0` `or` `not` `head[``0``]:` `            ``return` `None`   `        ``left ``=` `self``.sortedListToBST(head, n ``/``/` `2``)` `        ``root ``=` `head[``0``]` `        ``root.left ``=` `left` `        ``head[``0``] ``=` `head[``0``].right`   `        ``root.right ``=` `self``.sortedListToBST(head, n ``-` `(n ``/``/` `2``) ``-` `1``)`   `        ``return` `root`   `    ``def` `mergeTrees(``self``, root1, root2, m, n):` `        ``self``.bstToDLL(root1, ``self``.head1)` `        ``self``.head1[``0``].left ``=` `None`   `        ``self``.bstToDLL(root2, ``self``.head2)` `        ``self``.head2[``0``].left ``=` `None`   `        ``merged_head ``=` `self``.mergeLinkedList(``self``.head1[``0``], ``self``.head2[``0``])`   `        ``merged_root ``=` `self``.sortedListToBST([merged_head], m ``+` `n)`   `        ``return` `merged_root`   `    ``def` `printInorder(``self``, node):` `        ``if` `not` `node:` `            ``return` `        ``self``.printInorder(node.left)` `        ``print``(node.data),` `        ``self``.printInorder(node.right)`   `# Create the first balanced BST` `root1 ``=` `TreeNode(``100``)` `root1.left ``=` `TreeNode(``50``)` `root1.right ``=` `TreeNode(``300``)` `root1.left.left ``=` `TreeNode(``20``)` `root1.left.right ``=` `TreeNode(``70``)`   `# Create the second balanced BST` `root2 ``=` `TreeNode(``80``)` `root2.left ``=` `TreeNode(``40``)` `root2.right ``=` `TreeNode(``120``)`   `solution ``=` `Solution()` `mergedTree ``=` `solution.mergeTrees(root1, root2, ``5``, ``3``)`   `print``(``"Inorder traversal of the merged tree:"``)` `solution.printInorder(mergedTree)`

## C#

 `// C# Code for the above approach` `using` `System;`   `/* A binary tree node has data,` `a pointer to left child` `and a pointer to right child */` `public` `class` `Node {` `  ``public` `int` `data;` `  ``public` `Node left;` `  ``public` `Node right;` `}`   `public` `class` `Program {` `  ``// Function to return a new Node` `  ``static` `Node newNode(``int` `data)` `  ``{` `    ``Node node = ``new` `Node();` `    ``node.data = data;` `    ``node.left = ``null``;` `    ``node.right = ``null``;`   `    ``return` `node;` `  ``}`   `  ``// Function to convert bst to` `  ``// a doubly linked list` `  ``static` `void` `bstTodll(Node root, ``ref` `Node head)` `  ``{` `    ``// if root is NUL` `    ``if` `(root == ``null``)` `      ``return``;`   `    ``// Convert right subtree recursively` `    ``bstTodll(root.right, ``ref` `head);`   `    ``// Update root` `    ``root.right = head;`   `    ``// if head is not NULL` `    ``if` `(head != ``null``)`   `      ``// Update left of the head` `      ``head.left = root;`   `    ``// Update head` `    ``head = root;`   `    ``// Convert left subtree recursively` `    ``bstTodll(root.left, ``ref` `head);` `  ``}`   `  ``// Function to merge two sorted linked list` `  ``static` `Node mergeLinkedList(Node head1, Node head2)` `  ``{` `    ``/*Create head and tail for result list*/` `    ``Node head = ``null``, tail = ``null``;`   `    ``while` `(head1 != ``null` `&& head2 != ``null``) {` `      ``if` `(head1.data < head2.data) {` `        ``if` `(head == ``null``)` `          ``head = head1;` `        ``else` `{` `          ``tail.right = head1;` `          ``head1.left = tail;` `        ``}`   `        ``tail = head1;` `        ``head1 = head1.right;` `      ``}` `      ``else` `{` `        ``if` `(head == ``null``)` `          ``head = head2;` `        ``else` `{` `          ``tail.right = head2;` `          ``head2.left = tail;` `        ``}`   `        ``tail = head2;` `        ``head2 = head2.right;` `      ``}` `    ``}`   `    ``while` `(head1 != ``null``) {` `      ``tail.right = head1;` `      ``head1.left = tail;` `      ``tail = head1;` `      ``head1 = head1.right;` `    ``}`   `    ``while` `(head2 != ``null``) {` `      ``tail.right = head2;` `      ``head2.left = tail;` `      ``tail = head2;` `      ``head2 = head2.right;` `    ``}`   `    ``// Return the created DLL` `    ``return` `head;` `  ``}`   `  ``// function to convert list to bst` `  ``static` `Node sortedListToBST(``ref` `Node head, ``int` `n)` `  ``{` `    ``// if no element is left or head is null` `    ``if` `(n <= 0 || head == ``null``)` `      ``return` `null``;` `    ``// Create left part from the list recursively` `    ``Node left = sortedListToBST(``ref` `head, n / 2);`   `    ``Node root = head;` `    ``root.left = left;` `    ``head = head.right;`   `    ``// Create left part from the list recursively` `    ``root.right` `      ``= sortedListToBST(``ref` `head, n - (n / 2) - 1);`   `    ``// Return the root of BST` `    ``return` `root;` `  ``}`   `  ``// This function merges two balanced BSTs`   `  ``static` `Node mergeTrees(Node root1, Node root2, ``int` `m,` `                         ``int` `n)` `  ``{` `    ``// Convert BSTs into sorted Doubly Linked Lists` `    ``Node head1 = ``null``;` `    ``bstTodll(root1, ``ref` `head1);` `    ``head1.left = ``null``;`   `    ``Node head2 = ``null``;` `    ``bstTodll(root2, ``ref` `head2);` `    ``head2.left = ``null``;`   `    ``// Merge the two sorted lists into one` `    ``Node head = mergeLinkedList(head1, head2);`   `    ``// Construct a tree from the merged lists` `    ``return` `sortedListToBST(``ref` `head, m + n);` `  ``}`   `  ``static` `void` `printInorder(Node node)` `  ``{` `    ``// if current node is NULL` `    ``if` `(node == ``null``)` `      ``return``;`   `    ``printInorder(node.left);`   `    ``// Print node of current data` `    ``Console.Write(node.data + ``" "``);` `    ``printInorder(node.right);` `  ``}`   `  ``/* Driver code*/` `  ``public` `static` `void` `Main()` `  ``{`   `    ``/* Create following tree as first balanced BST` `           ``100` `           ``/ \` `          ``50 300` `         ``/ \` `        ``20 70   */` `    ``Node root1 = newNode(100);` `    ``root1.left = newNode(50);` `    ``root1.right = newNode(300);` `    ``root1.left.left = newNode(20);` `    ``root1.left.right = newNode(70);`   `    ``/* Create following tree as second balanced BST` `                 ``80` `                ``/ \` `               ``40 120` `        ``*/` `    ``Node root2 = newNode(80);` `    ``root2.left = newNode(40);` `    ``root2.right = newNode(120);`   `    ``// Function Call` `    ``Node mergedTree = mergeTrees(root1, root2, 5, 3);`   `    ``Console.WriteLine(` `      ``"Following is Inorder traversal of the merged tree: "``);` `    ``printInorder(mergedTree);` `  ``}` `  ``// This code is contributed by rutikbhosale` `}`

## Javascript

 `// JavaScrpit Code for above approach`   `// A binary tree node has data,` `// a pointer to left child,` `// and a pointer to right child` `class Node {` `    ``constructor(data) {` `        ``this``.data = data;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `// Function to convert BST to a doubly linked list` `function` `bstToDll(root, headRef) {` `    ``if` `(!root) {` `        ``return``;` `    ``}`   `    ``// Convert right subtree recursively` `    ``bstToDll(root.right, headRef);`   `    ``// Update root` `    ``root.right = headRef.node;`   `    ``// Update left of the head if head is not null` `    ``if` `(headRef.node) {` `        ``headRef.node.left = root;` `    ``}`   `    ``// Update head` `    ``headRef.node = root;`   `    ``// Convert left subtree recursively` `    ``bstToDll(root.left, headRef);` `}`   `// Function to merge two sorted linked lists` `function` `mergeLinkedList(head1, head2) {` `    ``let head = ``null``;` `    ``let tail = ``null``;`   `    ``while` `(head1 && head2) {` `        ``if` `(head1.data < head2.data) {` `            ``if` `(!head) {` `                ``head = head1;` `            ``} ``else` `{` `                ``tail.right = head1;` `                ``head1.left = tail;` `            ``}` `            ``tail = head1;` `            ``head1 = head1.right;` `        ``} ``else` `{` `            ``if` `(!head) {` `                ``head = head2;` `            ``} ``else` `{` `                ``tail.right = head2;` `                ``head2.left = tail;` `            ``}` `            ``tail = head2;` `            ``head2 = head2.right;` `        ``}` `    ``}`   `    ``while` `(head1) {` `        ``tail.right = head1;` `        ``head1.left = tail;` `        ``tail = head1;` `        ``head1 = head1.right;` `    ``}`   `    ``while` `(head2) {` `        ``tail.right = head2;` `        ``head2.left = tail;` `        ``tail = head2;` `        ``head2 = head2.right;` `    ``}`   `    ``// Return the created DLL` `    ``return` `head;` `}`   `// Function to convert a sorted linked list to a BST` `function` `sortedListToBST(headRef, n) {` `    ``if` `(n <= 0 || !headRef.node) {` `        ``return` `null``;` `    ``}`   `    ``// Create the left part from the list recursively` `    ``const left = sortedListToBST(headRef, Math.floor(n / 2));`   `    ``const root = headRef.node;` `    ``root.left = left;` `    ``headRef.node = headRef.node.right;`   `    ``// Create the right part from the list recursively` `    ``root.right = sortedListToBST(headRef, n - Math.floor(n / 2) - 1);`   `    ``// Return the root of the BST` `    ``return` `root;` `}`   `// This function merges two balanced BSTs` `function` `mergeTrees(root1, root2, m, n) {` `    ``// Convert BSTs into sorted Doubly Linked Lists` `    ``const headRef1 = { node: ``null` `};` `    ``bstToDll(root1, headRef1);` `    ``headRef1.node.left = ``null``;`   `    ``const headRef2 = { node: ``null` `};` `    ``bstToDll(root2, headRef2);` `    ``headRef2.node.left = ``null``;`   `    ``// Merge the two sorted lists into one` `    ``const mergedHead = mergeLinkedList(headRef1.node, headRef2.node);`   `    ``// Construct a tree from the merged lists` `    ``return` `sortedListToBST({ node: mergedHead }, m + n);` `}`   `function` `printInorder(node) {` `    ``if` `(!node) {` `        ``return``;` `    ``}`   `    ``printInorder(node.left);` `    ``console.log(node.data);` `    ``printInorder(node.right);` `}`   `// Driver code` `// Create the first balanced BST` `const root1 = ``new` `Node(100);` `root1.left = ``new` `Node(50);` `root1.right = ``new` `Node(300);` `root1.left.left = ``new` `Node(20);` `root1.left.right = ``new` `Node(70);`   `// Create the second balanced BST` `const root2 = ``new` `Node(80);` `root2.left = ``new` `Node(40);` `root2.right = ``new` `Node(120);`   `// Function call to merge the trees` `const mergedTree = mergeTrees(root1, root2, 5, 3);`   `console.log(``"Following is Inorder traversal of the merged tree:"``);` `printInorder(mergedTree);`

Output

```Following is Inorder traversal of the merged tree
20 40 50 70 80 100 120 300
```

Time Complexity: O(N + M). where N and M are the numbers of nodes in the given trees.
Auxiliary Space: O(1), as constant extra space is used.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!