# Convert BST to Max Heap

Given a Binary Search Tree which is also a Complete Binary Tree. The problem is to convert a given BST into a Special Max Heap with the condition that all the values in the left subtree of a node should be less than all the values in the right subtree of the node. This condition is applied on all the nodes in the so converted Max Heap.

Examples:

```Input :          4
/   \
2     6
/  \   /  \
1   3  5    7

Output :       7
/   \
3     6
/   \  /   \
1    2 4     5
The given BST has been transformed into a
Max Heap.
All the nodes in the Max Heap satisfies the given
condition, that is, values in the left subtree of
a node should be less than the values in the right
subtree of the node.

```

Pre Requisites: Binary Seach Tree | Heaps

Approach
1. Create an array arr[] of size n, where n is the number of nodes in the given BST.
2. Perform the inorder traversal of the BST and copy the node values in the arr[] in sorted
order.
3. Now perform the postorder traversal of the tree.
4. While traversing the root during the postorder traversal, one by one copy the values from the array arr[] to the nodes.

 `// C++ implementation to convert a given ` `// BST to Max Heap ` `#include ` `using` `namespace` `std; ` ` `  `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `/* Helper function that allocates a new node ` `   ``with the given data and NULL left and right ` `   ``pointers. */` `struct` `Node* getNode(``int` `data) ` `{ ` `    ``struct` `Node* newNode = ``new` `Node; ` `    ``newNode->data = data; ` `    ``newNode->left = newNode->right = NULL; ` `    ``return` `newNode; ` `} ` ` `  `// Function prototype for postorder traversal ` `// of the given tree ` `void` `postorderTraversal(Node*); ` ` `  `// Function for the inorder traversal of the tree ` `// so as to store the node values in 'arr' in ` `// sorted order ` `void` `inorderTraversal(Node* root, vector<``int``>& arr) ` `{ ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``// first recur on left subtree ` `    ``inorderTraversal(root->left, arr); ` ` `  `    ``// then copy the data of the node ` `    ``arr.push_back(root->data); ` ` `  `    ``// now recur for right subtree ` `    ``inorderTraversal(root->right, arr); ` `} ` ` `  `void` `BSTToMaxHeap(Node* root, vector<``int``> arr, ``int``* i) ` `{ ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``// recur on left subtree ` `    ``BSTToMaxHeap(root->left, arr, i); ` ` `  `    ``// recur on right subtree ` `    ``BSTToMaxHeap(root->right, arr, i); ` ` `  `    ``// copy data at index 'i' of 'arr' to ` `    ``// the node ` `    ``root->data = arr[++*i]; ` `} ` ` `  `// Utility function to convert the given BST to ` `// MAX HEAP ` `void` `convertToMaxHeapUtil(Node* root) ` `{ ` `    ``// vector to store the data of all the ` `    ``// nodes of the BST ` `    ``vector<``int``> arr; ` `    ``int` `i = -1; ` ` `  `    ``// inorder traversal to populate 'arr' ` `    ``inorderTraversal(root, arr); ` ` `  `    ``// BST to MAX HEAP conversion ` `    ``BSTToMaxHeap(root, arr, &i); ` `} ` ` `  `// Function to Print Postorder Traversal of the tree ` `void` `postorderTraversal(Node* root) ` `{ ` `    ``if` `(!root) ` `        ``return``; ` ` `  `    ``// recur on left subtree ` `    ``postorderTraversal(root->left); ` ` `  `    ``// then recur on right subtree ` `    ``postorderTraversal(root->right); ` ` `  `    ``// print the root's data ` `    ``cout << root->data << ``" "``; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// BST formation ` `    ``struct` `Node* root = getNode(4); ` `    ``root->left = getNode(2); ` `    ``root->right = getNode(6); ` `    ``root->left->left = getNode(1); ` `    ``root->left->right = getNode(3); ` `    ``root->right->left = getNode(5); ` `    ``root->right->right = getNode(7); ` ` `  `    ``convertToMaxHeapUtil(root); ` `    ``cout << ``"Postorder Traversal of Tree:"` `<< endl; ` `    ``postorderTraversal(root); ` ` `  `    ``return` `0; ` `} `

 `// Java implementation to convert a given ` `// BST to Max Heap ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `static` `int` `i; ` `static` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}; ` `  `  `/* Helper function that allocates a new node ` `   ``with the given data and null left and right ` `   ``pointers. */` `static` `Node getNode(``int` `data) ` `{ ` `    ``Node newNode = ``new` `Node(); ` `    ``newNode.data = data; ` `    ``newNode.left = newNode.right = ``null``; ` `    ``return` `newNode; ` `} ` ` `  `  `  `// Function for the inorder traversal of the tree ` `// so as to store the node values in 'arr' in ` `// sorted order ` `static` `void` `inorderTraversal(Node root, Vector arr) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return``; ` `  `  `    ``// first recur on left subtree ` `    ``inorderTraversal(root.left, arr); ` `  `  `    ``// then copy the data of the node ` `    ``arr.add(root.data); ` `  `  `    ``// now recur for right subtree ` `    ``inorderTraversal(root.right, arr); ` `} ` `  `  `static` `void` `BSTToMaxHeap(Node root, Vector arr) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return``; ` `  `  `    ``// recur on left subtree ` `    ``BSTToMaxHeap(root.left, arr); ` `  `  `    ``// recur on right subtree ` `    ``BSTToMaxHeap(root.right, arr); ` `  `  `    ``// copy data at index 'i' of 'arr' to ` `    ``// the node ` `    ``root.data = arr.get(i++); ` `} ` `  `  `// Utility function to convert the given BST to ` `// MAX HEAP ` `static` `void` `convertToMaxHeapUtil(Node root) ` `{ ` `    ``// vector to store the data of all the ` `    ``// nodes of the BST ` `    ``Vector arr = ``new` `Vector(); ` `    ``int` `i = -``1``; ` `  `  `    ``// inorder traversal to populate 'arr' ` `    ``inorderTraversal(root, arr); ` `  `  `    ``// BST to MAX HEAP conversion ` `    ``BSTToMaxHeap(root, arr); ` `} ` `  `  `// Function to Print Postorder Traversal of the tree ` `static` `void` `postorderTraversal(Node root) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return``; ` `  `  `    ``// recur on left subtree ` `    ``postorderTraversal(root.left); ` `  `  `    ``// then recur on right subtree ` `    ``postorderTraversal(root.right); ` `  `  `    ``// print the root's data ` `    ``System.out.print(root.data + ``" "``); ` `} ` `  `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// BST formation ` `    ``Node root = getNode(``4``); ` `    ``root.left = getNode(``2``); ` `    ``root.right = getNode(``6``); ` `    ``root.left.left = getNode(``1``); ` `    ``root.left.right = getNode(``3``); ` `    ``root.right.left = getNode(``5``); ` `    ``root.right.right = getNode(``7``); ` `  `  `    ``convertToMaxHeapUtil(root); ` `    ``System.out.print(``"Postorder Traversal of Tree:"` `+``"\n"``); ` `    ``postorderTraversal(root); ` ` `  `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

 `# Python3 implementation to convert a given ` `# BST to Max Heap ` `i ``=` `0` `class` `Node: ` `    ``def` `__init__(``self``): ` `        ``self``.data ``=` `0` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Helper function that allocates a new node ` `# with the given data and None left and right ` `# pointers.  ` `def` `getNode(data): ` ` `  `    ``newNode ``=` `Node() ` `    ``newNode.data ``=` `data ` `    ``newNode.left ``=` `newNode.right ``=` `None` `    ``return` `newNode ` ` `  `arr ``=` `[]  ` ` `  `# Function for the inorder traversal of the tree ` `# so as to store the node values in 'arr' in ` `# sorted order ` `def` `inorderTraversal( root): ` ` `  `    ``if` `(root ``=``=` `None``): ` `        ``return` `arr ` ` `  `    ``# first recur on left subtree ` `    ``inorderTraversal(root.left) ` ` `  `    ``# then copy the data of the node ` `    ``arr.append(root.data) ` ` `  `    ``# now recur for right subtree ` `    ``inorderTraversal(root.right) ` ` `  `def` `BSTToMaxHeap(root): ` ` `  `    ``global` `i ` `    ``if` `(root ``=``=` `None``): ` `        ``return` `None` ` `  `    ``# recur on left subtree ` `    ``root.left ``=` `BSTToMaxHeap(root.left) ` ` `  `    ``# recur on right subtree ` `    ``root.right ``=` `BSTToMaxHeap(root.right) ` ` `  `    ``# copy data at index 'i' of 'arr' to ` `    ``# the node ` `    ``root.data ``=` `arr[i] ` `    ``i ``=` `i ``+` `1` `    ``return` `root ` ` `  `# Utility function to convert the given BST to ` `# MAX HEAP ` `def` `convertToMaxHeapUtil( root): ` `    ``global` `i ` `     `  `    ``# vector to store the data of all the ` `    ``# nodes of the BST ` `    ``i ``=` `0` ` `  `    ``# inorder traversal to populate 'arr' ` `    ``inorderTraversal(root) ` ` `  `    ``# BST to MAX HEAP conversion ` `    ``root ``=` `BSTToMaxHeap(root) ` `    ``return` `root ` ` `  `# Function to Print Postorder Traversal of the tree ` `def` `postorderTraversal(root): ` ` `  `    ``if` `(root ``=``=` `None``): ` `        ``return` ` `  `    ``# recur on left subtree ` `    ``postorderTraversal(root.left) ` ` `  `    ``# then recur on right subtree ` `    ``postorderTraversal(root.right) ` ` `  `    ``# print the root's data ` `    ``print``(root.data ,end``=` `" "``) ` ` `  `# Driver Code ` ` `  `# BST formation ` `root ``=` `getNode(``4``) ` `root.left ``=` `getNode(``2``) ` `root.right ``=` `getNode(``6``) ` `root.left.left ``=` `getNode(``1``) ` `root.left.right ``=` `getNode(``3``) ` `root.right.left ``=` `getNode(``5``) ` `root.right.right ``=` `getNode(``7``) ` ` `  `root ``=` `convertToMaxHeapUtil(root) ` `print``(``"Postorder Traversal of Tree:"` `) ` `postorderTraversal(root) ` ` `  `# This code is contributed by Arnab Kundu `

Output:

```Postorder Traversal of Tree:
1 2 3 4 5 6 7 ```

Time Complexity: O(n)
Auxiliary Space: O(n)
where, n is the number of nodes in the tree

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : 29AjayKumar, andrew1234

Article Tags :
Practice Tags :