# 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 to 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 satisfy the given
condition, that is, values in the left subtree of
a node should be less than the values in the right
a subtree of the node. ```

Pre Requisites: Binary Search Tree | Heaps

Approach 1 :

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.

Implementation:

## C++

 `// 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

 `// 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

 `# 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`

## C#

 `// C# implementation to convert a given` `// BST to Max Heap` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG` `{`   `  ``static` `int` `i;` `  ``public` `class` `Node` `  ``{` `    ``public` `int` `data;` `    ``public` `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, List<``int``> 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, List<``int``> 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[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` `    ``List<``int``> arr = ``new` `List<``int``>();` `    ``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` `    ``Console.Write(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);` `    ``Console.Write(``"Postorder Traversal of Tree:"` `+``"\n"``);` `    ``postorderTraversal(root);`   `  ``}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

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

Complexity Analysis:

• Time Complexity: O(n)
• Auxiliary Space: O(n)

Approach 2 : (Using Heapify Up/Max Heap)

1. Create an array q[] of size n, where n is the number of nodes in the given BST.
2. Traverse the BST and append each node into the array using level order traversal.
3. Call heapify_up to create max-heap for each element in array q[] from 1 to n so that the array q[] will be arranged in descending order using max-heap.
4. Update the root and child of each node of the tree using array q[] like creating a new tree from array q[].

Implementation:

## C++

 `#include ` `using` `namespace` `std;`   `// Defining the structure of the Node class` `class` `Node {` `public``:` `int` `data;` `Node *left, *right;` `  ``Node(``int` `data) {` `    ``this``->data = data;` `    ``left = right = NULL;` `}` `};`   `// Function to find the parent index of a node` `int` `parent(``int` `i) {` `return` `(i - 1) / 2;` `}`   `// Function to heapify up the node to arrange in max-heap order` `void` `heapify_up(vector& q, ``int` `i) {` `while` `(i > 0 && q[parent(i)]->data < q[i]->data) {` `swap(q[i], q[parent(i)]);` `i = parent(i);` `}` `}`   `// Function to convert BST to max heap` `Node* convertToMaxHeapUtil(Node* root) {` `if` `(root == NULL) {` `return` `root;` `}` `  ``// Creating a vector for storing the nodes of BST` `vector q;` `q.push_back(root);` `int` `i = 0;` `while` `(q.size() != i) {` `    ``if` `(q[i]->left != NULL) {` `        ``q.push_back(q[i]->left);` `    ``}` `    ``if` `(q[i]->right != NULL) {` `        ``q.push_back(q[i]->right);` `    ``}` `    ``i++;` `}`   `// Calling heapify_up for each node in the vector` `for` `(``int` `i = 1; i < q.size(); i++) {` `    ``heapify_up(q, i);` `}`   `// Updating the root as the maximum value in heap` `root = q[0];` `i = 0;`   `// Updating left and right nodes of BST using vector` `while` `(i < q.size()) {` `    ``if` `(2 * i + 1 < q.size()) {` `        ``q[i]->left = q[2 * i + 1];` `    ``} ``else` `{` `        ``q[i]->left = NULL;` `    ``}` `    ``if` `(2 * i + 2 < q.size()) {` `        ``q[i]->right = q[2 * i + 2];` `    ``} ``else` `{` `        ``q[i]->right = NULL;` `    ``}` `    ``i++;` `}` `return` `root;` `}`   `// Function to print postorder traversal of the tree` `void` `postorderTraversal(Node* root) {` `if` `(root == NULL) {` `return``;` `}` `  ``// Recurring on left subtree` `postorderTraversal(root->left);`   `// Recurring on right subtree` `postorderTraversal(root->right);`   `// Printing the root's data` `cout << root->data << ``" "``;` `}`   `// Driver code` `int` `main() {` `// Creating the BST` `Node* root = ``new` `Node(4);` `root->left = ``new` `Node(2);` `root->right = ``new` `Node(6);` `root->left->left = ``new` `Node(1);` `root->left->right = ``new` `Node(3);` `root->right->left = ``new` `Node(5);` `root->right->right = ``new` `Node(7);` `// Converting the BST to max heap` `root = convertToMaxHeapUtil(root);`   `// Printing the postorder traversal of the tree` `cout << ``"Postorder Traversal of Tree: "``;` `postorderTraversal(root);`   `return` `0;` `}`

## Java

 `// Java code implementation:`   `import` `java.io.*;` `import` `java.util.*;`   `// Defining the structure of the Node class` `class` `Node {` `    ``int` `data;` `    ``Node left, right;` `    ``Node(``int` `data)` `    ``{` `        ``this``.data = data;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `GFG {`   `    ``// Function to find the parent index of a node` `    ``static` `int` `parent(``int` `i) { ``return` `(i - ``1``) / ``2``; }`   `    ``// Function to heapify up the node to arrange in` `    ``// max-heap order` `    ``static` `void` `heapify_up(List q, ``int` `i)` `    ``{` `        ``while` `(i > ``0` `               ``&& q.get(parent(i)).data < q.get(i).data) {` `            ``Collections.swap(q, i, parent(i));` `            ``i = parent(i);` `        ``}` `    ``}`   `    ``// Function to convert BST to max heap` `    ``static` `Node convertToMaxHeapUtil(Node root)` `    ``{` `        ``if` `(root == ``null``) {` `            ``return` `root;` `        ``}` `        ``// Creating a list for storing the nodes of BST` `        ``List q = ``new` `ArrayList();` `        ``q.add(root);` `        ``int` `i = ``0``;` `        ``while` `(q.size() != i) {` `            ``if` `(q.get(i).left != ``null``) {` `                ``q.add(q.get(i).left);` `            ``}` `            ``if` `(q.get(i).right != ``null``) {` `                ``q.add(q.get(i).right);` `            ``}` `            ``i++;` `        ``}`   `        ``// Calling heapify_up for each node in the list` `        ``for` `(``int` `j = ``1``; j < q.size(); j++) {` `            ``heapify_up(q, j);` `        ``}`   `        ``// Updating the root as the maximum value in heap` `        ``root = q.get(``0``);` `        ``i = ``0``;`   `        ``// Updating left and right nodes of BST using list` `        ``while` `(i < q.size()) {` `            ``if` `(``2` `* i + ``1` `< q.size()) {` `                ``q.get(i).left = q.get(``2` `* i + ``1``);` `            ``}` `            ``else` `{` `                ``q.get(i).left = ``null``;` `            ``}` `            ``if` `(``2` `* i + ``2` `< q.size()) {` `                ``q.get(i).right = q.get(``2` `* i + ``2``);` `            ``}` `            ``else` `{` `                ``q.get(i).right = ``null``;` `            ``}` `            ``i++;` `        ``}` `        ``return` `root;` `    ``}`   `    ``// Function to print postorder traversal of the tree` `    ``static` `void` `postorderTraversal(Node root)` `    ``{` `        ``if` `(root == ``null``) {` `            ``return``;` `        ``}` `        ``// Recurring on left subtree` `        ``postorderTraversal(root.left);` `        ``// Recurring on right subtree` `        ``postorderTraversal(root.right);`   `        ``// Printing the root's data` `        ``System.out.print(root.data + ``" "``);` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Creating the BST` `        ``Node root = ``new` `Node(``4``);` `        ``root.left = ``new` `Node(``2``);` `        ``root.right = ``new` `Node(``6``);` `        ``root.left.left = ``new` `Node(``1``);` `        ``root.left.right = ``new` `Node(``3``);` `        ``root.right.left = ``new` `Node(``5``);` `        ``root.right.right = ``new` `Node(``7``);` `        ``// Converting the BST to max heap` `        ``root = convertToMaxHeapUtil(root);`   `        ``// Printing the postorder traversal of the tree` `        ``System.out.println(``"Postorder Traversal of Tree: "``);` `        ``postorderTraversal(root);` `    ``}` `}`   `// This code is contributed by karthik.`

## Python3

 `# User function Template for python3` `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`   `# To find parent index` `def` `parent(i):` `    ``return` `(i ``-` `1``) ``/``/` `2`   `# heapify_up to arrange like max-heap` `def` `heapify_up(q, i):` `    ``while` `i > ``0` `and` `q[parent(i)].data < q[i].data:` `        ``q[parent(i)], q[i] ``=` `q[i], q[parent(i)]` `        ``i ``=` `parent(i)`     `def` `convertToMaxHeapUtil(root):` `    ``if` `root ``is` `None``:` `        ``return` `root`   `    ``# creating list for BST nodes` `    ``q ``=` `[]` `    ``q.append(root)` `    ``i ``=` `0` `    ``while` `len``(q) !``=` `i:` `        ``if` `q[i].left ``is` `not` `None``:` `            ``q.append(q[i].left)` `        ``if` `q[i].right ``is` `not` `None``:` `            ``q.append(q[i].right)` `        ``i ``+``=` `1` `    ``# calling max-heap for each iteration` `    ``for` `i ``in` `range``(``1``, ``len``(q)):` `        ``heapify_up(q, i)`   `    ``# updating root as max value in heap` `    ``root ``=` `q[``0``]` `    ``i ``=` `0`   `    ``# updating left and right nodes of BST using list` `    ``while` `i < ``len``(q):` `        ``if` `2` `*` `i ``+` `1` `< ``len``(q):` `            ``q[i].left ``=` `q[``2` `*` `i ``+` `1``]` `        ``else``:` `            ``q[i].left ``=` `None` `        ``if` `2` `*` `i ``+` `2` `< ``len``(q):` `            ``q[i].right ``=` `q[``2` `*` `i ``+` `2``]` `        ``else``:` `            ``q[i].right ``=` `None` `        ``i ``+``=` `1` `    ``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 Anvesh Govind Saxena`

## C#

 `// C# code implementation for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `// Defining the structure of the Node class` `public` `class` `Node {` `  ``public` `int` `data;` `  ``public` `Node left, right;` `  ``public` `Node(``int` `data)` `  ``{` `    ``this``.data = data;` `    ``left = right = ``null``;` `  ``}` `}`   `public` `class` `GFG {`   `  ``// Function to find the parent index of a node` `  ``static` `int` `parent(``int` `i) { ``return` `(i - 1) / 2; }`   `  ``// Function to heapify up the node to arrange in` `  ``// max-heap order` `  ``static` `void` `heapify_up(List q, ``int` `i)` `  ``{` `    ``while` `(i > 0 && q[parent(i)].data < q[i].data) {` `      ``Node temp = q[i];` `      ``q[i] = q[parent(i)];` `      ``q[parent(i)] = temp;` `      ``i = parent(i);` `    ``}` `  ``}`   `  ``// Function to convert BST to max heap` `  ``static` `Node convertToMaxHeapUtil(Node root)` `  ``{` `    ``if` `(root == ``null``) {` `      ``return` `root;` `    ``}`   `    ``// Creating a list for storing the nodes of BST` `    ``List q = ``new` `List();` `    ``q.Add(root);` `    ``int` `i = 0;`   `    ``while` `(q.Count != i) {` `      ``if` `(q[i].left != ``null``) {` `        ``q.Add(q[i].left);` `      ``}` `      ``if` `(q[i].right != ``null``) {` `        ``q.Add(q[i].right);` `      ``}` `      ``i++;` `    ``}`   `    ``// Calling heapify_up for each node in the list` `    ``for` `(``int` `j = 1; j < q.Count; j++) {` `      ``heapify_up(q, j);` `    ``}`   `    ``// Updating the root as the maximum value in heap` `    ``root = q[0];` `    ``i = 0;`   `    ``// Updating left and right nodes of BST using list` `    ``while` `(i < q.Count) {` `      ``if` `(2 * i + 1 < q.Count) {` `        ``q[i].left = q[2 * i + 1];` `      ``}` `      ``else` `{` `        ``q[i].left = ``null``;` `      ``}` `      ``if` `(2 * i + 2 < q.Count) {` `        ``q[i].right = q[2 * i + 2];` `      ``}` `      ``else` `{` `        ``q[i].right = ``null``;` `      ``}` `      ``i++;` `    ``}` `    ``return` `root;` `  ``}`   `  ``// Function to print postorder traversal of the tree` `  ``static` `void` `postorderTraversal(Node root)` `  ``{` `    ``if` `(root == ``null``) {` `      ``return``;` `    ``}` `    ``// Recurring on left subtree` `    ``postorderTraversal(root.left);` `    ``// Recurring on right subtree` `    ``postorderTraversal(root.right);`   `    ``// Printing the root's data` `    ``Console.Write(root.data + ``" "``);` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``// Creating the BST` `    ``Node root = ``new` `Node(4);` `    ``root.left = ``new` `Node(2);` `    ``root.right = ``new` `Node(6);` `    ``root.left.left = ``new` `Node(1);` `    ``root.left.right = ``new` `Node(3);` `    ``root.right.left = ``new` `Node(5);` `    ``root.right.right = ``new` `Node(7);`   `    ``// Converting the BST to max heap` `    ``root = convertToMaxHeapUtil(root);`   `    ``// Printing the postorder traversal of the tree` `    ``Console.WriteLine(``"Postorder Traversal of Tree: "``);` `    ``postorderTraversal(root);` `  ``}` `}`   `// This code is contributed by sankar.`

## Javascript

 `// User function Template for javascript` `class Node {` `constructor() {` `this``.data = 0;` `this``.left = ``null``;` `this``.right = ``null``;` `}` `}`   `// Helper function that allocates a new node` `// with the given data and None left and right` `// pointers.` `function` `getNode(data) {` `let newNode = ``new` `Node();` `newNode.data = data;` `newNode.left = newNode.right = ``null``;` `return` `newNode;` `}`   `// To find parent index` `function` `parent(i) {` `return` `Math.floor((i - 1) / 2);` `}`   `// heapify_up to arrange like max-heap` `function` `heapify_up(q, i) {` `while` `(i > 0 && q[parent(i)].data < q[i].data) {` `[q[parent(i)], q[i]] = [q[i], q[parent(i)]];` `i = parent(i);` `}` `}`   `function` `convertToMaxHeapUtil(root) {` `if` `(root == ``null``) {` `return` `root;` `}`     `// creating list for BST nodes` `let q = [];` `q.push(root);` `let i = 0;` `while` `(q.length != i) {` `    ``if` `(q[i].left != ``null``) {` `        ``q.push(q[i].left);` `    ``}` `    ``if` `(q[i].right != ``null``) {` `        ``q.push(q[i].right);` `    ``}` `    ``i++;` `}`   `// calling max-heap for each iteration` `for` `(let i = 1; i < q.length; i++) {` `    ``heapify_up(q, i);` `}`   `// updating root as max value in heap` `root = q[0];` `i = 0;`   `// updating left and right nodes of BST using list` `while` `(i < q.length) {` `    ``if` `(2 * i + 1 < q.length) {` `        ``q[i].left = q[2 * i + 1];` `    ``} ``else` `{` `        ``q[i].left = ``null``;` `    ``}` `    ``if` `(2 * i + 2 < q.length) {` `        ``q[i].right = q[2 * i + 2];` `    ``} ``else` `{` `        ``q[i].right = ``null``;` `    ``}` `    ``i++;` `}` `return` `root;` `}`   `// Function to Print Postorder Traversal of the tree` `function` `postorderTraversal(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` `document.write(root.data + ``" "``);` `}`   `// Driver Code`   `// BST formation` `let 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);` `document.write(``"Postorder Traversal of Tree:"``);` `postorderTraversal(root);`

Output

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

Complexity Analysis:

Time Complexity: O(n)
Auxiliary Space: O(n)

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!