Convert BST to Min Heap

14 Mar, 2022
Given a binary search tree which is also a complete binary tree. The problem is to convert the given BST into a Min 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 Min Heap. Examples:  
Input :          4
               /   \
              2     6
            /  \   /  \
           1   3  5    7  

Output :        1
              /   \
             2     5
           /  \   /  \
          3   4  6    7 

The given BST has been transformed into a
Min Heap.
All the nodes in the Min 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. 
 
 
Create an array arr[] of size n, where n is the number of nodes in the given BST.Perform the inorder traversal of the BST and copy the node values in the arr[] in sorted order.Now perform the preorder traversal of the tree.While traversing the root during the preorder traversal, one by one copy the values from the array arr[] to the nodes.
Create an array arr[] of size n, where n is the number of nodes in the given BST.
Perform the inorder traversal of the BST and copy the node values in the arr[] in sorted order.
Now perform the preorder traversal of the tree.
While traversing the root during the preorder traversal, one by one copy the values from the array arr[] to the nodes.
 
C++
Java
Python3
C#
Javascript
// C++ implementation to convert the given// BST to Min Heap#include <bits/stdc++.h>using namespace std; // structure of a node of BSTstruct 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 preorder traversal// of the given treevoid preorderTraversal(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);} // function to convert the given BST to MIN HEAP// performs preorder traversal of the treevoid BSTToMinHeap(Node* root, vector<int> arr, int* i){    if (root == NULL)        return;     // first copy data at index 'i' of 'arr' to    // the node    root->data = arr[++*i];     // then recur on left subtree    BSTToMinHeap(root->left, arr, i);     // now recur on right subtree    BSTToMinHeap(root->right, arr, i);} // utility function to convert the given BST to// MIN HEAPvoid convertToMinHeapUtil(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 MIN HEAP conversion    BSTToMinHeap(root, arr, &i);} // function for the preorder traversal of the treevoid preorderTraversal(Node* root){    if (!root)        return;     // first print the root's data    cout << root->data << " ";     // then recur on left subtree    preorderTraversal(root->left);     // now recur on right subtree    preorderTraversal(root->right);} // Driver program to test aboveint 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);     convertToMinHeapUtil(root);    cout << "Preorder Traversal:" << endl;    preorderTraversal(root);     return 0;}
// Java implementation to convert the given// BST to Min Heapimport java.util.ArrayList; class Gfg {     static class Node {         int data;        Node left, right;         // Constructor        Node()        {            this.data = 0;            this.left = this.right = null;        }         Node(int data)        {            this.data = data;            this.left = this.right = null;        }    }     private static void preOrder(Node root)    {        if (root == null)            return;        System.out.print(root.data + " ");        preOrder(root.left);        preOrder(root.right);    }     private static void bstToArray(Node root,                                   ArrayList<Integer> arr)    {        // ArrayLIst stores elements in inorder fashion        if (root == null)            return;         bstToArray(root.left, arr);         arr.add(root.data);         bstToArray(root.right, arr);    }         static int index;    private static void arrToMinHeap(Node root,                                     ArrayList<Integer> arr)    {        if (root == null)            return;        root.data = arr.get(index++);         arrToMinHeap(root.left, arr);        arrToMinHeap(root.right, arr);    }    static void convertToMinHeap(Node root)    {          //initialize static index to zero          index = 0;        ArrayList<Integer> arr = new ArrayList<Integer>();        bstToArray(root, arr);         arrToMinHeap(root, arr);    }     // Driver program to test above    public static void main(String[] args)    {         // BST formation        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);         System.out.print(            "Preorder Traversal Before Conversion :"            + "\n");        preOrder(root);        convertToMinHeap(root);         System.out.print(            "\nPreorder Traversal After Conversion :"            + "\n");        preOrder(root);    }} // Contributed by : @mahi_07 /*Tip : If interviewer ask not to use global index variableyou can use LinkedList Instead of ArrayList and  useLinkedList's removeFirst() method So instead of this        root.data = arr.get(index++);    you can write        root.data = list.removeFirst();    Do not forget to initialize list in converttoMinHeapfunction*/
# C++ implementation to convert the# given BST to Min Heap # structure of a node of BST  class Node:     # Constructor to create a new node    def __init__(self, data):        self.data = data        self.left = None        self.right = None # function for the inorder traversal# of the tree so as to store the node# values in 'arr' in sorted order  def inorderTraversal(root, arr):    if root == None:        return     # first recur on left subtree    inorderTraversal(root.left, arr)     # then copy the data of the node    arr.append(root.data)     # now recur for right subtree    inorderTraversal(root.right, arr) # function to convert the given# BST to MIN HEAP performs preorder# traversal of the tree  def BSTToMinHeap(root, arr, i):    if root == None:        return     # first copy data at index 'i' of    # 'arr' to the node    i[0] += 1    root.data = arr[i[0]]     # then recur on left subtree    BSTToMinHeap(root.left, arr, i)     # now recur on right subtree    BSTToMinHeap(root.right, arr, i) # utility function to convert the# given BST to MIN HEAP  def convertToMinHeapUtil(root):     # vector to store the data of    # all the nodes of the BST    arr = []    i = [-1]     # inorder traversal to populate 'arr'    inorderTraversal(root, arr)     # BST to MIN HEAP conversion    BSTToMinHeap(root, arr, i) # function for the preorder traversal# of the tree  def preorderTraversal(root):    if root == None:        return     # first print the root's data    print(root.data, end=" ")     # then recur on left subtree    preorderTraversal(root.left)     # now recur on right subtree    preorderTraversal(root.right)  # Driver Codeif __name__ == '__main__':     # BST formation    root = Node(4)    root.left = Node(2)    root.right = Node(6)    root.left.left = Node(1)    root.left.right = Node(3)    root.right.left = Node(5)    root.right.right = Node(7)     convertToMinHeapUtil(root)    print("Preorder Traversal:")    preorderTraversal(root) # This code is contributed# by PranchalK
// C# implementation to convert the given// BST to Min Heapusing System;using System.Collections.Generic;public class GFG {     // structure of a node of BST    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 prototype for preorder traversal    // of the given tree     // 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)    {        if (root == null)            return;         // first recur on left subtree        inorderTraversal(root.left);         // then copy the data of the node        arr.Add(root.data);         // now recur for right subtree        inorderTraversal(root.right);    }     // function to convert the given BST to MIN HEAP    // performs preorder traversal of the tree    static void BSTToMinHeap(Node root)    {        if (root == null)            return;         // first copy data at index 'i' of 'arr' to        // the node        root.data = arr[++i];         // then recur on left subtree        BSTToMinHeap(root.left);         // now recur on right subtree        BSTToMinHeap(root.right);    }    static List<int> arr = new List<int>();    static int i;     // utility function to convert the given BST to    // MIN HEAP    static void convertToMinHeapUtil(Node root)    {         // vector to store the data of all the        // nodes of the BST        i = -1;         // inorder traversal to populate 'arr'        inorderTraversal(root);         // BST to MIN HEAP conversion        BSTToMinHeap(root);    }     // function for the preorder traversal of the tree    static void preorderTraversal(Node root)    {        if (root == null)            return;         // first print the root's data        Console.Write(root.data + " ");         // then recur on left subtree        preorderTraversal(root.left);         // now recur on right subtree        preorderTraversal(root.right);    }     // Driver program to test above    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);         convertToMinHeapUtil(root);        Console.Write("Preorder Traversal:"                      + "\n");        preorderTraversal(root);    }} // This code contributed by Rajput-Ji
<script>       // JavaScript implementation to convert the given      // BST to Min Heap      // structure of a node of BST      class Node {        constructor() {          this.data = 0;          this.left = null;          this.right = null;        }      }       /* Helper function that allocates a new node      with the given data and null left and right      pointers. */      function getNode(data) {        var newNode = new Node();        newNode.data = data;        newNode.left = newNode.right = null;        return newNode;      }       // function prototype for preorder traversal      // of the given tree       // function for the inorder traversal of the tree      // so as to store the node values in 'arr' in      // sorted order      function inorderTraversal(root) {        if (root == null) return;         // first recur on left subtree        inorderTraversal(root.left);         // then copy the data of the node        arr.push(root.data);         // now recur for right subtree        inorderTraversal(root.right);      }       // function to convert the given BST to MIN HEAP      // performs preorder traversal of the tree      function BSTToMinHeap(root) {        if (root == null) return;         // first copy data at index 'i' of 'arr' to        // the node        root.data = arr[++i];         // then recur on left subtree        BSTToMinHeap(root.left);         // now recur on right subtree        BSTToMinHeap(root.right);      }      var arr = [];      var i;       // utility function to convert the given BST to      // MIN HEAP      function convertToMinHeapUtil(root) {        // vector to store the data of all the        // nodes of the BST        i = -1;         // inorder traversal to populate 'arr'        inorderTraversal(root);         // BST to MIN HEAP conversion        BSTToMinHeap(root);      }       // function for the preorder traversal of the tree      function preorderTraversal(root) {        if (root == null) {          return;        }         // first print the root's data        document.write(root.data + " ");         // then recur on left subtree        preorderTraversal(root.left);         // now recur on right subtree        preorderTraversal(root.right);      }       // Driver program to test above      // BST formation      var 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);       convertToMinHeapUtil(root);      document.write("Preorder Traversal:" + "<br>");      preorderTraversal(root);       </script>
Output:  
Preorder Traversal:
1 2 3 4 5 6 7
Time Complexity: O(n) Auxiliary Space: O(n)   This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
PranchalKatiyar
aashish1995
Rajput-Ji
mahi_07
rdtank
rahulchintawar
Binary Search Tree
Heap
Binary Search Tree
Heap
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Binary Search Tree | Set 1 (Search and Insertion)
AVL Tree | Set 1 (Insertion)
Binary Search Tree | Set 2 (Delete)
Find postorder traversal of BST from preorder traversal
A program to check if a binary tree is BST or not
HeapSort
K'th Smallest/Largest Element in Unsorted Array | Set 1
Introduction to Data Structures
Huffman Coding | Greedy Algo-3
Sliding Window Maximum (Maximum of all subarrays of size k)