Convert BST to Max Heap - GeeksforGeeks

01 Feb, 2022
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 Search 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++
Java
Python3
C#
Javascript
// C++ implementation to convert a given// BST to Max Heap#include <bits/stdc++.h>using namespace std; struct Node {    int data;    Node *left, *right;}; /* Helper function that allocates a new nodewith the given data and NULL left and rightpointers. */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 treevoid postorderTraversal(Node*); // Function for the inorder traversal of the tree// so as to store the node values in 'arr' in// sorted ordervoid 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 HEAPvoid 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 treevoid 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 Codeint 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 Heapimport java.util.*; class GFG{ static int i;static class Node{    int data;    Node left, right;}; /* Helper function that allocates a new nodewith the given data and null left and rightpointers. */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 orderstatic void inorderTraversal(Node root, Vector<Integer> 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<Integer> 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 HEAPstatic void convertToMaxHeapUtil(Node root){    // vector to store the data of all the    // nodes of the BST    Vector<Integer> arr = new Vector<Integer>();    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 treestatic 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 Codepublic 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 Heapi = 0class 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 orderdef 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 HEAPdef 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 treedef 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 formationroot = 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# implementation to convert a given// BST to Max Heapusing 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 nodewith the given data and null left and rightpointers. */  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
<script>// Javascript implementation to convert a given// BST to Max Heap let i = 0; class Node{    constructor()    {        this.data = 0;        this.left = this.right = null;    }} /* Helper function that allocates a new node   with the given data and null left and right   pointers. */function getNode(data){    let 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 orderfunction inorderTraversal(root, arr){    if (root == null)        return;        // first recur on left subtree    inorderTraversal(root.left, arr);        // then copy the data of the node    arr.push(root.data);        // now recur for right subtree    inorderTraversal(root.right, arr);} function BSTToMaxHeap(root,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 HEAPfunction convertToMaxHeapUtil(root){    // vector to store the data of all the    // nodes of the BST    let arr = [];             // inorder traversal to populate 'arr'    inorderTraversal(root, arr);        // BST to MAX HEAP conversion    BSTToMaxHeap(root, arr);     } // Function to Print Postorder Traversal of the treefunction 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 formationlet 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);document.write("Postorder Traversal of Tree:" +"\n");postorderTraversal(root); // This code is contributed by rag2127</script>
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 
29AjayKumar
andrew1234
rag2127
simmytarika5
pratikkumarintern
Rajput-Ji
Binary Search Tree
Heap
Binary Search Tree
Heap
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Construct a Binary Search Tree from given postorder
set vs unordered_set in C++ STL
Red Black Tree vs AVL Tree
Convert BST to Min Heap
Construct BST from given preorder traversal | Set 2
HeapSort
Binary Heap
Huffman Coding | Greedy Algo-3
K'th Smallest/Largest Element in Unsorted Array | Set 1
k largest(or smallest) elements in an array