# Sorted Array to Balanced BST

• Difficulty Level : Easy
• Last Updated : 25 Oct, 2022

Given a sorted array. Write a function that creates a Balanced Binary Search Tree using array elements.

Examples:

Input: arr[] = {1, 2, 3}
Output: A Balanced BST
2
/  \
1     3
Explanation: all elements less than 2 are on the left side of 2 , and all the elements greater then 2 are on the right side

Input: arr[] = {1, 2, 3, 4}
Output: A Balanced BST
3
/  \
2    4
/
1

## Sorted Array to Balanced BST By Finding The middle element

The idea is to 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 print BST in given range``#include``using` `namespace` `std;` `/* A Binary Tree node */``class` `TNode``{``    ``public``:``    ``int` `data;``    ``TNode* left;``    ``TNode* right;``};` `TNode* newNode(``int` `data);` `/* A function that constructs Balanced``Binary Search Tree from a sorted array */``TNode* 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;``    ``TNode *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;``}` `/* Helper function that allocates a new node``with the given data and NULL left and right``pointers. */``TNode* newNode(``int` `data)``{``    ``TNode* node = ``new` `TNode();``    ``node->data = data;``    ``node->left = NULL;``    ``node->right = NULL;` `    ``return` `node;``}` `/* A utility function to print``preorder traversal of BST */``void` `preOrder(TNode* node)``{``    ``if` `(node == NULL)``        ``return``;``    ``cout << node->data << ``" "``;``    ``preOrder(node->left);``    ``preOrder(node->right);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = {1, 2, 3, 4, 5, 6, 7};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``/* Convert List to BST */``    ``TNode *root = sortedArrayToBST(arr, 0, n-1);``    ``cout << ``"PreOrder Traversal of constructed BST \n"``;``    ``preOrder(root);` `    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `#include``#include` `/* A Binary Tree node */``struct` `TNode``{``    ``int` `data;``    ``struct` `TNode* left;``    ``struct` `TNode* right;``};` `struct` `TNode* newNode(``int` `data);` `/* A function that constructs Balanced Binary Search Tree from a sorted array */``struct` `TNode* 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` `TNode *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;``}` `/* Helper function that allocates a new node with the``   ``given data and NULL left and right pointers. */``struct` `TNode* newNode(``int` `data)``{``    ``struct` `TNode* node = (``struct` `TNode*)``                         ``malloc``(``sizeof``(``struct` `TNode));``    ``node->data = data;``    ``node->left = NULL;``    ``node->right = NULL;` `    ``return` `node;``}` `/* A utility function to print preorder traversal of BST */``void` `preOrder(``struct` `TNode* node)``{``    ``if` `(node == NULL)``        ``return``;``    ``printf``(``"%d "``, node->data);``    ``preOrder(node->left);``    ``preOrder(node->right);``}` `/* Driver program to test above functions */``int` `main()``{``    ``int` `arr[] = {1, 2, 3, 4, 5, 6, 7};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);` `    ``/* Convert List to BST */``    ``struct` `TNode *root = sortedArrayToBST(arr, 0, n-1);``    ``printf``(``"n PreOrder Traversal of constructed BST "``);``    ``preOrder(root);` `    ``return` `0;``}`

## Java

 `// Java program to print BST in given range` `// A binary tree node``class` `Node {``    ` `    ``int` `data;``    ``Node left, right;``    ` `    ``Node(``int` `d) {``        ``data = d;``        ``left = right = ``null``;``    ``}``}` `class` `BinaryTree {``    ` `    ``static` `Node root;` `    ``/* A function that constructs Balanced Binary Search Tree``     ``from a sorted array */``    ``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 node = ``new` `Node(arr[mid]);` `        ``/* Recursively construct the left subtree and make it``         ``left child of root */``        ``node.left = sortedArrayToBST(arr, start, mid - ``1``);` `        ``/* Recursively construct the right subtree and make it``         ``right child of root */``        ``node.right = sortedArrayToBST(arr, mid + ``1``, end);``        ` `        ``return` `node;``    ``}` `    ``/* A utility function to print preorder traversal of BST */``    ``void` `preOrder(Node node) {``        ``if` `(node == ``null``) {``            ``return``;``        ``}``        ``System.out.print(node.data + ``" "``);``        ``preOrder(node.left);``        ``preOrder(node.right);``    ``}``    ` `    ``public` `static` `void` `main(String[] args) {``        ``BinaryTree tree = ``new` `BinaryTree();``        ``int` `arr[] = ``new` `int``[]{``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``};``        ``int` `n = arr.length;``        ``root = tree.sortedArrayToBST(arr, ``0``, n - ``1``);``        ``System.out.println(``"Preorder traversal of constructed BST"``);``        ``tree.preOrder(root);``    ``}``}` `// This code has been contributed by Mayank Jaiswal`

## Python

 `# Python code to convert a sorted array``# to a balanced Binary Search Tree` `# binary tree node``class` `Node:``    ``def` `__init__(``self``, d):``        ``self``.data ``=` `d``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `# function to convert sorted array to a``# balanced BST``# input : sorted array of integers``# output: root node of balanced BST``def` `sortedArrayToBST(arr):``    ` `    ``if` `not` `arr:``        ``return` `None` `    ``# find middle index``    ``mid ``=` `(``len``(arr)) ``/``/` `2``    ` `    ``# make the middle element the root``    ``root ``=` `Node(arr[mid])``    ` `    ``# left subtree of root has all``    ``# values arr[mid]``    ``root.right ``=` `sortedArrayToBST(arr[mid``+``1``:])``    ``return` `root` `# A utility function to print the preorder``# traversal of the BST``def` `preOrder(node):``    ``if` `not` `node:``        ``return``    ` `    ``print` `node.data,``    ``preOrder(node.left)``    ``preOrder(node.right)` `# driver program to test above function``"""``Constructed balanced BST is``    ``4``/ \``2 6``/ \ / \``1 3 5 7``"""` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``]``root ``=` `sortedArrayToBST(arr)``print` `"PreOrder Traversal of constructed BST "``,``preOrder(root)` `# This code is contributed by Ishita Tripathi`

## C#

 `using` `System;` `// C# program to print BST in given range` `// 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` `BinaryTree``{` `    ``public` `static` `Node root;` `    ``/* A function that constructs Balanced Binary Search Tree ``     ``from a sorted array */``    ``public` `virtual` `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 node = ``new` `Node(arr[mid]);` `        ``/* Recursively construct the left subtree and make it``         ``left child of root */``        ``node.left = sortedArrayToBST(arr, start, mid - 1);` `        ``/* Recursively construct the right subtree and make it``         ``right child of root */``        ``node.right = sortedArrayToBST(arr, mid + 1, end);` `        ``return` `node;``    ``}` `    ``/* A utility function to print preorder traversal of BST */``    ``public` `virtual` `void` `preOrder(Node node)``    ``{``        ``if` `(node == ``null``)``        ``{``            ``return``;``        ``}``        ``Console.Write(node.data + ``" "``);``        ``preOrder(node.left);``        ``preOrder(node.right);``    ``}` `    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``int``[] arr = ``new` `int``[]{1, 2, 3, 4, 5, 6, 7};``        ``int` `n = arr.Length;``        ``root = tree.sortedArrayToBST(arr, 0, n - 1);``        ``Console.WriteLine(``"Preorder traversal of constructed BST"``);``        ``tree.preOrder(root);``    ``}``}` `  ``// This code is contributed by Shrikant13`

## Javascript

 ``

Output

```PreOrder Traversal of constructed BST
4 2 1 3 6 5 7 ```

Time Complexity: O(N)
Auxiliary Space: O(H) ~= O(log(N)), for recursive stack space where H is the height of the tree.

My Personal Notes arrow_drop_up