Sorted Array to Balanced BST
Last Updated : 07 Oct, 2024
Given a sorted array. The task is to convert it into a Balanced Binary Search Tree (BST). Return the root of the BST.
Examples:
Input: arr[] = {10, 20, 30}
Output:
Explanation: The above sorted array converted to Balanced Binary Search Tree.
Input: arr[] = {1, 2, 3, 4, 5, 6, 7}
Output:
Explanation: The above sorted array converted to Balanced Binary Search Tree.
[Expected Approach – 1] Using Recursion – O(n) Time and O(n) Space
The idea is to use recursion to traverse the tree. First find the middle element of the array and make it the root of the tree, then perform the same operation on the left subarray for the root’s left child and the same operation on the right subarray for the root’s right child.
Follow the steps mentioned below to implement the approach:
- Set The middle element of the array as root.
- Recursively do the same for the left half and right half.
- Get the middle of the left half and make it the left child of the root created in step 1.
- Get the middle of the right half and make it the right child of the root created in step 1.
- Print the preorder of the tree.
Below is the implementation of the above approach:
C++ // C++ program to convert sorted // array to BST. #include<bits/stdc++.h> using namespace std; class Node { public: int data; Node* left; Node* right; Node(int data) { this->data = data; this->left = nullptr; this->right = nullptr; } }; // Recursive function to construct BST Node* sortedArrayToBSTRecur(vector<int>& arr, int start, int end) { if(start > end) return nullptr; // Find the middle element int mid = start + (end - start) / 2; // Create root node Node* root = new Node(arr[mid]); // Create left subtree root->left = sortedArrayToBSTRecur(arr, start, mid - 1); // Create right subtree root->right = sortedArrayToBSTRecur(arr, mid + 1, end); return root; } Node* sortedArrayToBST(vector<int> &arr) { int n = arr.size(); return sortedArrayToBSTRecur(arr, 0, n-1); } void preOrder(Node* root) { if(root == nullptr) return; cout << root->data << " "; preOrder(root->left); preOrder(root->right); } int main(){ vector<int> arr = {1, 2, 3, 4}; Node* root = sortedArrayToBST(arr); preOrder(root); return 0; } // C program to convert sorted // array to BST. #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* left; struct Node* right; }; struct Node* createNode(int data); // Recursive function to construct BST struct Node* sortedArrayToBSTRecur(int arr[], int start, int end) { if (start > end) return NULL; // Find the middle element int mid = start + (end - start) / 2; // Create root node struct Node* root = createNode(arr[mid]); // Create left subtree root->left = sortedArrayToBSTRecur(arr, start, mid - 1); // Create right subtree root->right = sortedArrayToBSTRecur(arr, mid + 1, end); return root; } struct Node* sortedArrayToBST(int arr[], int n) { return sortedArrayToBSTRecur(arr, 0, n - 1); } void preOrder(struct Node* root) { if (root == NULL) return; printf("%d ", root->data); preOrder(root->left); preOrder(root->right); } struct Node* createNode(int data) { struct Node* node = (struct Node*)malloc(sizeof(struct Node)); node->data = data; node->left = NULL; node->right = NULL; return node; } int main() { int nums[] = {1, 2, 3, 4}; int n = sizeof(nums) / sizeof(nums[0]); struct Node* root = sortedArrayToBST(nums, n); preOrder(root); return 0; } // Java program to convert sorted // array to BST. import java.util.ArrayList; class Node { int data; Node left, right; Node(int data) { this.data = data; this.left = null; this.right = null; } } class GfG { // Recursive function to construct BST static Node sortedArrayToBSTRecur(int[] arr, int start, int end) { if (start > end) return null; // Find the middle element int mid = start + (end - start) / 2; // Create root node Node root = new Node(arr[mid]); // Create left subtree root.left = sortedArrayToBSTRecur(arr, start, mid - 1); // Create right subtree root.right = sortedArrayToBSTRecur(arr, mid + 1, end); return root; } static Node sortedArrayToBST(int[] arr) { return sortedArrayToBSTRecur(arr, 0, arr.length - 1); } static void preOrder(Node root) { if (root == null) return; System.out.print(root.data + " "); preOrder(root.left); preOrder(root.right); } public static void main(String[] args) { int[] arr = {1,2,3,4}; Node root = sortedArrayToBST(arr); preOrder(root); } } # Python program to convert sorted # array to BST. class Node: def __init__(self, data): self.data = data self.left = None self.right = None # Recursive function to construct BST def sortedArrayToBSTRecur(arr, start, end): if start > end: return None # Find the middle element mid = start + (end - start) // 2 # Create root node root = Node(arr[mid]) # Create left subtree root.left = sortedArrayToBSTRecur(arr, start, mid - 1) # Create right subtree root.right = sortedArrayToBSTRecur(arr, mid + 1, end) return root def sortedArrayToBST(arr): return sortedArrayToBSTRecur(arr, 0, len(arr) - 1) def preOrder(root): if root is None: return print(root.data, end=" ") preOrder(root.left) preOrder(root.right) if __name__ == "__main__": arr = [1, 2, 3, 4] root = sortedArrayToBST(arr) preOrder(root)
// C# program to convert sorted // array to BST. using System; using System.Collections.Generic; class Node { public int data; public Node left, right; public Node(int data) { this.data = data; this.left = null; this.right = null; } } class GfG { // Recursive function to construct BST static Node SortedArrayToBSTRecur(List<int> arr, int start, int end) { if (start > end) return null; // Find the middle element int mid = start + (end - start) / 2; // Create root node Node root = new Node(arr[mid]); // Create left subtree root.left = SortedArrayToBSTRecur(arr, start, mid - 1); // Create right subtree root.right = SortedArrayToBSTRecur(arr, mid + 1, end); return root; } static Node SortedArrayToBST(List<int> arr) { return SortedArrayToBSTRecur(arr, 0, arr.Count - 1); } static void PreOrder(Node root) { if (root == null) return; Console.Write(root.data + " "); PreOrder(root.left); PreOrder(root.right); } static void Main(string[] args) { List<int> arr = new List<int> { 1, 2, 3, 4 }; Node root = SortedArrayToBST(arr); PreOrder(root); } } // JavaScript program to convert sorted // array to BST. class Node { constructor(data) { this.data = data; this.left = null; this.right = null; } } // Recursive function to construct BST function sortedArrayToBSTRecur(arr, start, end) { if (start > end) return null; // Find the middle element let mid = start + Math.floor((end - start) / 2); // Create root node let root = new Node(arr[mid]); // Create left subtree root.left = sortedArrayToBSTRecur(arr, start, mid - 1); // Create right subtree root.right = sortedArrayToBSTRecur(arr, mid + 1, end); return root; } function sortedArrayToBST(arr) { return sortedArrayToBSTRecur(arr, 0, arr.length - 1); } function preOrder(root) { if (root === null) return; console.log(root.data); preOrder(root.left); preOrder(root.right); } const arr = [1, 2, 3, 4]; const root = sortedArrayToBST(arr); preOrder(root); Time Complexity: O(n), where n is the number of elements in the input array.
Auxiliary Space: O(n), because we create one node for each element in the input array.
[Expected Approach – 2] Using queue – O(n) Time and O(n) Space
The idea is to traverse the tree in level order manner, starting from root node. Check for each node, if left subtree exists, then create the left node and push it into queue. Similarly, if right subtree exists, then create the right node and push it into queue.
Step-by-step approach:
- First initialize a queue with root node (which the mid of initial array) and two variables. Lets say start and end which will describe the range of the root (set to 0 and n-1 for root node). Loop until the queue is empty.
- Remove first node from the queue along with its start and end range and find middle index of the range. Elements present in the range [start, middle-1] will be present in its left subtree and elements in the range [middle+1, end] will be present in the right subtree.
- If left subtree exists, that is, if start is less than middle index. Then create the left node with the value equal to middle of range [start, middle-1]. Link the root node and left node and push the left node along withrange into the queue.
- If right subtree exists, that is, if end is greater than middle index. Then create the right node with the value equal to middle of range [middle+1, end]. Link the root node and right node and push the right node along range into the queue.
- Return the root node.
Below is the implementation of the above approach:
C++ // C++ program to convert sorted // array to BST. #include <bits/stdc++.h> using namespace std; class Node { public: int data; Node *left; Node *right; Node(int data) { this->data = data; this->left = nullptr; this->right = nullptr; } }; Node *sortedArrayToBST(vector<int> &arr) { int n = arr.size(); if (n == 0) return nullptr; // create the root node. int mid = (n - 1) / 2; Node *root = new Node(arr[mid]); queue<pair<Node *, pair<int, int>>> q; q.push({root, {0, n - 1}}); while (!q.empty()) { pair<Node *, pair<int, int>> front = q.front(); q.pop(); Node *curr = front.first; int s = front.second.first, e = front.second.second; int index = s + (e - s) / 2; // if left subtree exists if (s < index) { int mid = s + (index - 1 - s) / 2; Node *left = new Node(arr[mid]); curr->left = left; q.push({left, {s, index - 1}}); } // if right subtree exists if (e > index) { int mid = index + 1 + (e - index - 1) / 2; Node *right = new Node(arr[mid]); curr->right = right; q.push({right, {index + 1, e}}); } } return root; } void preOrder(Node *root) { if (root == nullptr) return; cout << root->data << " "; preOrder(root->left); preOrder(root->right); } int main() { vector<int> arr = {1, 2, 3, 4}; Node *root = sortedArrayToBST(arr); preOrder(root); return 0; } // Java program to convert sorted // array to BST. import java.util.LinkedList; import java.util.Queue; class Node { int data; Node left, right; Node(int data) { this.data = data; this.left = null; this.right = null; } } class Data { Node node; int start, end; Data(Node node, int start, int end) { this.node = node; this.start = start; this.end = end; } } class GfG { static Node sortedArrayToBST(int[] arr) { int n = arr.length; if (n == 0) return null; // create the root node. int mid = (n - 1) / 2; Node root = new Node(arr[mid]); Queue<Data> q = new LinkedList<>(); q.add(new Data(root, 0, n - 1)); while (!q.isEmpty()) { Data d = q.poll(); Node curr = d.node; int s = d.start, e = d.end; int index = s + (e - s) / 2; // if left subtree exists if (s < index) { mid = s + (index - 1 - s) / 2; Node left = new Node(arr[mid]); curr.left = left; q.add(new Data(left, s, index - 1)); } // if right subtree exists if (e > index) { mid = index + 1 + (e - index - 1) / 2; Node right = new Node(arr[mid]); curr.right = right; q.add(new Data(right, index + 1, e)); } } return root; } static void preOrder(Node root) { if (root == null) return; System.out.print(root.data + " "); preOrder(root.left); preOrder(root.right); } public static void main(String[] args) { int[] arr = { 1, 2, 3, 4 }; Node root = sortedArrayToBST(arr); preOrder(root); } } # Python program to convert sorted # array to BST. class Node: def __init__(self, data): self.data = data self.left = None self.right = None def sortedArrayToBST(arr): n = len(arr) if n == 0: return None # create the root node mid = (n - 1) // 2 root = Node(arr[mid]) q = [(root, (0, n - 1))] while q: curr, (s, e) = q.pop(0) index = s + (e - s) // 2 # if left subtree exists if s < index: mid_left = s + (index - 1 - s) // 2 left = Node(arr[mid_left]) curr.left = left q.append((left, (s, index - 1))) # if right subtree exists if e > index: mid_right = index + 1 + (e - index - 1) // 2 right = Node(arr[mid_right]) curr.right = right q.append((right, (index + 1, e))) return root def preOrder(root): if root is None: return print(root.data, end=" ") preOrder(root.left) preOrder(root.right) arr = [1, 2, 3, 4] root = sortedArrayToBST(arr) preOrder(root)
// C# program to convert sorted // array to BST. using System; using System.Collections.Generic; class Node { public int data; public Node left, right; public Node(int data) { this.data = data; this.left = null; this.right = null; } } class GfG { static Node sortedArrayToBST(List<int> nums) { int n = nums.Count; if (n == 0) return null; // create the root node int mid = (n - 1) / 2; Node root = new Node(nums[mid]); Queue<KeyValuePair<Node, KeyValuePair<int, int> > > q = new Queue<KeyValuePair< Node, KeyValuePair<int, int> > >(); q.Enqueue( new KeyValuePair<Node, KeyValuePair<int, int> >( root, new KeyValuePair<int, int>(0, n - 1))); while (q.Count > 0) { var front = q.Dequeue(); Node curr = front.Key; int s = front.Value.Key; int e = front.Value.Value; int index = s + (e - s) / 2; // if left subtree exists if (s < index) { int midLeft = s + (index - 1 - s) / 2; Node left = new Node(nums[midLeft]); curr.left = left; q.Enqueue(new KeyValuePair< Node, KeyValuePair<int, int> >( left, new KeyValuePair<int, int>( s, index - 1))); } // if right subtree exists if (e > index) { int midRight = index + 1 + (e - index - 1) / 2; Node right = new Node(nums[midRight]); curr.right = right; q.Enqueue(new KeyValuePair< Node, KeyValuePair<int, int> >( right, new KeyValuePair<int, int>( index + 1, e))); } } return root; } static void preOrder(Node root) { if (root == null) return; Console.Write(root.data + " "); preOrder(root.left); preOrder(root.right); } static void Main() { List<int> nums = new List<int>{ 1, 2, 3, 4 }; Node root = sortedArrayToBST(nums); preOrder(root); } } // JavaScript program to convert sorted // array to BST. class Node { constructor(data) { this.data = data; this.left = null; this.right = null; } } function sortedArrayToBST(arr) { let n = arr.length; if (n === 0) return null; // Create the root node let mid = Math.floor((n - 1) / 2); let root = new Node(arr[mid]); let q = [ {node : root, range : [ 0, n - 1 ]} ]; let frontIndex = 0; while (frontIndex < q.length) { let front = q[frontIndex]; let curr = front.node; let [s, e] = front.range; let index = s + Math.floor((e - s) / 2); // If left subtree exists if (s < index) { let midLeft = s + Math.floor((index - 1 - s) / 2); let left = new Node(arr[midLeft]); curr.left = left; q.push({node : left, range : [ s, index - 1 ]}); } // If right subtree exists if (e > index) { let midRight = index + 1 + Math.floor((e - index - 1) / 2); let right = new Node(arr[midRight]); curr.right = right; q.push( {node : right, range : [ index + 1, e ]}); } frontIndex++; } return root; } function preOrder(root) { if (root === null) return; console.log(root.data + " "); preOrder(root.left); preOrder(root.right); } let arr = [ 1, 2, 3, 4 ]; let root = sortedArrayToBST(arr); preOrder(root); Time Complexity: O(n), where n is the number of elements in array.
Auxiliary Space: O(n)
Similar Reads
Binary Search Tree
A Binary Search Tree (or BST) is a data structure used in computer science for organizing and storing data in a sorted manner. Each node in a Binary Search Tree has at most two children, a left child and a right child, with the left child containing values less than the parent node and the right chi
3 min read
Introduction to Binary Search Tree
Binary Search Tree is a data structure used in computer science for organizing and storing data in a sorted manner. Binary search tree follows all properties of binary tree and for every nodes, its left subtree contains values less than the node and the right subtree contains values greater than the
3 min read
Applications of BST
Binary Search Tree (BST) is a data structure that is commonly used to implement efficient searching, insertion, and deletion operations along with maintaining sorted sequence of data. Please remember the following properties of BSTs before moving forward. The left subtree of a node contains only nod
2 min read
Applications, Advantages and Disadvantages of Binary Search Tree
A Binary Search Tree (BST) is a data structure used to storing data in a sorted manner. Each node in a Binary Search Tree has at most two children, a left child and a right child, with the left child containing values less than the parent node and the right child containing values greater than the p
2 min read
Insertion in Binary Search Tree (BST)
Given a BST, the task is to insert a new node in this BST. Example: How to Insert a value in a Binary Search Tree:A new key is always inserted at the leaf by maintaining the property of the binary search tree. We start searching for a key from the root until we hit a leaf node. Once a leaf node is f
15+ min read
Searching in Binary Search Tree (BST)
Given a BST, the task is to search a node in this BST. For searching a value in BST, consider it as a sorted array. Now we can easily perform search operation in BST using Binary Search Algorithm. Input: Root of the below BST Output: TrueExplanation: 8 is present in the BST as right child of rootInp
7 min read
Deletion in Binary Search Tree (BST)
Given a BST, the task is to delete a node in this BST, which can be broken down into 3 scenarios: Case 1. Delete a Leaf Node in BST Case 2. Delete a Node with Single Child in BST Deleting a single child node is also simple in BST. Copy the child to the node and delete the node. Case 3. Delete a Node
10 min read
Binary Search Tree (BST) Traversals – Inorder, Preorder, Post Order
Given a Binary Search Tree, The task is to print the elements in inorder, preorder, and postorder traversal of the Binary Search Tree. Input: Output: Inorder Traversal: 10 20 30 100 150 200 300Preorder Traversal: 100 20 10 30 200 150 300Postorder Traversal: 10 30 20 150 300 200 100 Input: Output:
11 min read
Balance a Binary Search Tree
Given a BST (Binary Search Tree) that may be unbalanced, the task is to convert it into a balanced BST that has the minimum possible height. Examples: Input: Output: Explanation: The above unbalanced BST is converted to balanced with the minimum possible height. Input: Output: Explanation: The above
10 min read
Self-Balancing Binary Search Trees
Self-Balancing Binary Search Trees are height-balanced binary search trees that automatically keep the height as small as possible when insertion and deletion operations are performed on the tree. The height is typically maintained in order of logN so that all operations take O(logN) time on average
4 min read