Open In App

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