diff --git a/Binary Tree Algorithms/Merge two BSTs/README.md b/Binary Tree Algorithms/Merge two BSTs/README.md new file mode 100644 index 00000000..278235a0 --- /dev/null +++ b/Binary Tree Algorithms/Merge two BSTs/README.md @@ -0,0 +1,90 @@ + Merge Two Binary Search Trees + +Description + +This project provides a solution to merge two Binary Search Trees (BSTs) into a single balanced BST. Merging two BSTs is a common operation in data structures, allowing the combination of two ordered datasets while maintaining efficient search properties. + +The algorithm involves: +1. Performing in-order traversal on each BST to obtain sorted arrays of values. +2. Merging the two sorted arrays into one sorted array. +3. Building a balanced BST from the merged sorted array. +This solution ensures that the final merged tree remains balanced, allowing efficient operations such as search, insertion, and deletion. + +Problem Statement + +Given two Binary Search Trees, we aim to merge them into a single BST that: +- Contains all elements from both trees. +- Maintains the properties of a Binary Search Tree. +- Is balanced to optimize search efficiency. +This solution is useful for applications where merging ordered data structures is required while preserving search efficiency. + +Approach and Solution + +Steps to Merge Two BSTs +1. In-Order Traversal: + - Perform an in-order traversal on both BSTs to extract elements in sorted order. + - This gives two sorted arrays of values from the two trees. + +2. Merge Sorted Arrays: + - Merge the two sorted arrays into one single sorted array. + - This ensures that all elements from both trees are combined in sorted order. + +3. Build a Balanced BST: + - Convert the merged sorted array into a balanced BST. + - We achieve this by choosing the middle element of the array as the root and recursively building left and right subtrees, ensuring the tree is height-balanced. + + +Algorithm Complexity + +- Time Complexity: + - O(m + n) for in-order traversal (where m and n are the sizes of the two BSTs). + - O(m + n) for merging two sorted arrays. + - O(m + n) for building the balanced BST from a sorted array. + - Overall Complexity: O(m + n). + +- Space Complexity: O(m + n), as we store values in arrays and construct a new BST. + + +Example +This example demonstrates the merging process of two BSTs, showing the trees before merging and the structure of the final merged BST. + +Input: +1. BST 1: + 3 + / \ +1 5 + - In-order traversal of BST 1: 1 3 5 + +2. BST 2: + 4 + / \ +2 6 + - In-order traversal of BST 2: 2 4 6 + + +Process: +1. In-order Traversal: + - First, we perform in-order traversal on both BSTs to obtain sorted arrays. + - BST 1 in-order traversal gives: [1, 3, 5] + - BST 2 in-order traversal gives: [2, 4, 6] + +2. Merge Sorted Arrays: + - Next, we merge the two sorted arrays from the BSTs. + - Merged array: [1, 2, 3, 4, 5, 6] + +3. Build Balanced BST: +- We use the merged array to create a balanced BST: + - Middle element 3 becomes the root. + - Elements [1, 2] are on the left subtree, with 2 as the right child of 1. + - Elements [4, 5, 6] are on the right subtree, with 5 as the right child of 4. +-The final balanced BST is: + 3 + / \ + 1 5 + \ / \ + 2 4 6 + +Output: +After merging, the final in-order traversal of the balanced merged BST is: + +1 2 3 4 5 6 diff --git a/Binary Tree Algorithms/Merge two BSTs/mergeBSTs.c b/Binary Tree Algorithms/Merge two BSTs/mergeBSTs.c new file mode 100644 index 00000000..eab835e9 --- /dev/null +++ b/Binary Tree Algorithms/Merge two BSTs/mergeBSTs.c @@ -0,0 +1,123 @@ +#include +#include + +typedef struct TreeNode { + int value; + struct TreeNode *left, *right; +} TreeNode; + +// Create a new tree node +TreeNode* createNode(int value) { + TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode)); + newNode->value = value; + newNode->left = newNode->right = NULL; + return newNode; +} + +// In-order traversal to store values in a sorted array +void inorderTraversal(TreeNode* root, int* arr, int* index) { + if (root == NULL) return; + inorderTraversal(root->left, arr, index); + arr[(*index)++] = root->value; + inorderTraversal(root->right, arr, index); +} + +// Merge two sorted arrays into one +int* mergeSortedArrays(int* arr1, int size1, int* arr2, int size2, int* mergedSize) { + *mergedSize = size1 + size2; + int* mergedArr = (int*)malloc(*mergedSize * sizeof(int)); + int i = 0, j = 0, k = 0; + + while (i < size1 && j < size2) { + if (arr1[i] < arr2[j]) { + mergedArr[k++] = arr1[i++]; + } else { + mergedArr[k++] = arr2[j++]; + } + } + + // Copy any remaining elements from arr1 + while (i < size1) { + mergedArr[k++] = arr1[i++]; + } + + // Copy any remaining elements from arr2 + while (j < size2) { + mergedArr[k++] = arr2[j++]; + } + + return mergedArr; +} + +// Convert a sorted array to a balanced BST +TreeNode* sortedArrayToBST(int* arr, int start, int end) { + if (start > end) return NULL; + + int mid = (start + end) / 2; + TreeNode* root = createNode(arr[mid]); + + root->left = sortedArrayToBST(arr, start, mid - 1); + root->right = sortedArrayToBST(arr, mid + 1, end); + + return root; +} + +// Merge two BSTs into a single balanced BST +TreeNode* mergeTwoBSTs(TreeNode* root1, TreeNode* root2) { + int arr1[100], arr2[100]; // Assuming max 100 nodes in each tree + int index1 = 0, index2 = 0; + + // Get in-order traversal of both trees + inorderTraversal(root1, arr1, &index1); + inorderTraversal(root2, arr2, &index2); + + // Merge the two sorted arrays + int mergedSize; + int* mergedArr = mergeSortedArrays(arr1, index1, arr2, index2, &mergedSize); + + // Convert the merged sorted array into a balanced BST + TreeNode* mergedBST = sortedArrayToBST(mergedArr, 0, mergedSize - 1); + + // Free the merged array after use + free(mergedArr); + + return mergedBST; +} + +// Utility function to print in-order traversal of a BST +void printInOrder(TreeNode* root) { + if (root == NULL) return; + printInOrder(root->left); + printf("%d ", root->value); + printInOrder(root->right); +} + +// Driver code to test the merge function +int main() { + // Creating two sample BSTs + + // BST 1: + // 3 + // / \ + // 1 5 + TreeNode* root1 = createNode(3); + root1->left = createNode(1); + root1->right = createNode(5); + + // BST 2: + // 4 + // / \ + // 2 6 + TreeNode* root2 = createNode(4); + root2->left = createNode(2); + root2->right = createNode(6); + + // Merge the two BSTs + TreeNode* mergedBST = mergeTwoBSTs(root1, root2); + + // Print the in-order traversal of the merged BST + printf("In-order traversal of the merged BST: "); + printInOrder(mergedBST); + + return 0; +}