Skip to content
Related Articles

Related Articles

Improve Article

Convert BST to Min Heap

  • Difficulty Level : Medium
  • Last Updated : 07 Jul, 2021
Geek Week

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. 

 

 

  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 preorder traversal of the tree.
  4. While traversing the root during the preorder traversal, one by one copy the values from the array arr[] to the nodes.

 

C++




// C++ implementation to convert the given
// BST to Min Heap
#include <bits/stdc++.h>
using namespace std;
 
// structure of a node of BST
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 preorder traversal
// of the given tree
void preorderTraversal(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);
}
 
// function to convert the given BST to MIN HEAP
// performs preorder traversal of the tree
void 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 HEAP
void 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 tree
void 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 above
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);
 
    convertToMinHeapUtil(root);
    cout << "Preorder Traversal:" << endl;
    preorderTraversal(root);
 
    return 0;
}

Java




// Java implementation to convert the given
// BST to Min Heap
import 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 = 0;
    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)
    {
        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 variable you can use LinkedList Instead of ArrayList
    and  use LinkedList'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 converttoMinHeap function
*/

Python3




# 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 Code
if __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#




// C# implementation to convert the given
// BST to Min Heap
using 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

Javascript




<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.
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :