Convert BST into a Min-Heap without using array

01 Jul, 2022
Given a Binary Search Tree, convert it into a Min-Heap containing the same elements in O(n) time. Do this in-place. 
Input: Binary Search Tree
        8
     /    \
    4      12
  /  \     /  \
 2    6   10  14


Output - Min Heap
       2
     /    \
   4        6
 /  \     /   \
8    10  12   14
[Or any other tree that follows Min Heap
 properties and has same keys]
If we are allowed to use extra space, we can perform inorder traversal of the tree and store the keys in an auxiliary array. As we’re doing inorder traversal on a BST, array will be sorted. Finally, we construct a complete binary tree from the sorted array. We construct the binary tree level by level and from left to right by taking next minimum element from sorted array. The constructed binary tree will be a min-Heap. This solution works in O(n) time, but is not in-place.
How to do it in-place? The idea is to convert the binary search tree into a sorted linked list first. We can do this by traversing the BST in inorder fashion. We add nodes at the beginning of current linked list and update head of the list using pointer to head pointer. Since we insert at the beginning, to maintain sorted order, we first traverse the right subtree before the left subtree. i.e. do a reverse inorder traversal.
Finally we convert the sorted linked list into a min-Heap by setting the left and right pointers appropriately. We can do this by doing a Level order traversal of the partially built Min-Heap Tree using queue and traversing the linked list at the same time. At every step, we take the parent node from queue, make next two nodes of linked list as children of the parent node, and enqueue the next two nodes to queue. As the linked list is sorted, the min-heap property is maintained.
Below is the implementation of above idea:
C++
Java
Python3
C#
Javascript
//C++ Program to convert a BST into a Min-Heap// in O(n) time and in-place#include <bits/stdc++.h>using namespace std; // Node for BST/Min-Heapstruct Node{    int data;    Node *left, *right;}; // Utility function for allocating node for BSTNode* newNode(int data){    Node* node = new Node;    node->data = data;    node->left = node->right = NULL;    return node;} // Utility function to print Min-heap level by levelvoid printLevelOrder(Node *root){    // Base Case    if (root == NULL)  return;     // Create an empty queue for level order traversal    queue<Node *> q;    q.push(root);     while (!q.empty())    {        int nodeCount = q.size();        while (nodeCount > 0)        {            Node *node = q.front();            cout << node->data << " ";            q.pop();            if (node->left)                q.push(node->left);            if (node->right)                q.push(node->right);            nodeCount--;        }        cout << endl;    }} // A simple recursive function to convert a given// Binary Search tree to Sorted Linked List// root     --> Root of Binary Search Tree// head_ref --> Pointer to head node of created//              linked listvoid BSTToSortedLL(Node* root, Node** head_ref){    // Base cases    if(root == NULL)        return;     // Recursively convert right subtree    BSTToSortedLL(root->right, head_ref);     // insert root into linked list    root->right = *head_ref;     // Change left pointer of previous head    // to point to NULL    if (*head_ref != NULL)        (*head_ref)->left = NULL;     // Change head of linked list    *head_ref = root;     // Recursively convert left subtree    BSTToSortedLL(root->left, head_ref);} // Function to convert a sorted Linked// List to Min-Heap.// root --> Root of Min-Heap// head --> Pointer to head node of sorted//              linked listvoid SortedLLToMinHeap(Node* &root, Node* head){    // Base Case    if (head == NULL)        return;     // queue to store the parent nodes    queue<Node *> q;     // The first node is always the root node    root = head;     // advance the pointer to the next node    head = head->right;     // set right child to NULL    root->right = NULL;     // add first node to the queue    q.push(root);     // run until the end of linked list is reached    while (head)    {        // Take the parent node from the q and remove it from q        Node* parent = q.front();        q.pop();         // Take next two nodes from the linked list and        // Add them as children of the current parent node        // Also in push them into the queue so that        // they will be parents to the future nodes        Node *leftChild = head;        head = head->right;        // advance linked list to next node        leftChild->right = NULL; // set its right child to NULL        q.push(leftChild);         // Assign the left child of parent        parent->left = leftChild;         if (head)        {            Node *rightChild = head;            head = head->right; // advance linked list to next node            rightChild->right = NULL; // set its right child to NULL            q.push(rightChild);             // Assign the right child of parent            parent->right = rightChild;        }    }} // Function to convert BST into a Min-Heap// without using any extra spaceNode* BSTToMinHeap(Node* &root){    // head of Linked List    Node *head = NULL;     // Convert a given BST to Sorted Linked List    BSTToSortedLL(root, &head);     // set root as NULL    root = NULL;     // Convert Sorted Linked List to Min-Heap    SortedLLToMinHeap(root, head);} // Driver codeint main(){    /* Constructing below tree                8              /   \             4     12           /  \   /  \          2    6 10   14     */     Node* root = newNode(8);    root->left = newNode(4);    root->right = newNode(12);    root->right->left = newNode(10);    root->right->right = newNode(14);    root->left->left = newNode(2);    root->left->right = newNode(6);     BSTToMinHeap(root);     /* Output - Min Heap                2              /   \             4     6           /  \   /  \          8   10 12   14     */     printLevelOrder(root);     return 0;}
// Java Program to convert a BST into a Min-Heap// in O(n) time and in-placeimport java.util.*; class GFG{     // Node for BST/Min-Heapstatic class Node{    int data;    Node left, right;}; // Utility function for allocating node for BSTstatic Node newNode(int data){    Node node = new Node();    node.data = data;    node.left = node.right = null;    return node;} // Utility function to print Min-heap level by levelstatic void printLevelOrder(Node root){    // Base Case    if (root == null) return;     // Create an empty queue for level order traversal    Queue<Node> q = new LinkedList<>();    q.add(root);     while (q.size() > 0)    {        int nodeCount = q.size();        while (nodeCount > 0)        {            Node node = q.peek();            System.out.print( node.data + " ");            q.remove();            if (node.left != null)                q.add(node.left);            if (node.right != null)                q.add(node.right);            nodeCount--;        }        System.out.println();    }} // A simple recursive function to convert a given// Binary Search tree to Sorted Linked List// root     -. Root of Binary Search Tree// head_ref -. Pointer to head node of created//             linked liststatic Node BSTToSortedLL(Node root, Node head_ref){    // Base cases    if(root == null)        return head_ref;     // Recursively convert right subtree    head_ref = BSTToSortedLL(root.right, head_ref);     // insert root into linked list    root.right = head_ref;     // Change left pointer of previous head    // to point to null    if (head_ref != null)        (head_ref).left = null;     // Change head of linked list    head_ref = root;     // Recursively convert left subtree    head_ref = BSTToSortedLL(root.left, head_ref);    return head_ref;} // Function to convert a sorted Linked// List to Min-Heap.// root -. Root of Min-Heap// head -. Pointer to head node of sorted//             linked liststatic Node SortedLLToMinHeap(Node root, Node head){    // Base Case    if (head == null)        return null;     // queue to store the parent nodes    Queue<Node > q = new LinkedList<>();     // The first node is always the root node    root = head;     // advance the pointer to the next node    head = head.right;     // set right child to null    root.right = null;     // add first node to the queue    q.add(root);     // run until the end of linked list is reached    while (head != null)    {        // Take the parent node from the q and remove it from q        Node parent = q.peek();        q.remove();         // Take next two nodes from the linked list and        // Add them as children of the current parent node        // Also in add them into the queue so that        // they will be parents to the future nodes        Node leftChild = head;        head = head.right;     // advance linked list to next node        leftChild.right = null; // set its right child to null        q.add(leftChild);         // Assign the left child of parent        parent.left = leftChild;         if (head != null)        {            Node rightChild = head;            head = head.right; // advance linked list to next node            rightChild.right = null; // set its right child to null            q.add(rightChild);             // Assign the right child of parent            parent.right = rightChild;        }    }    return root;} // Function to convert BST into a Min-Heap// without using any extra spacestatic Node BSTToMinHeap(Node root){    // head of Linked List    Node head = null;     // Convert a given BST to Sorted Linked List    head = BSTToSortedLL(root, head);         // set root as null    root = null;     // Convert Sorted Linked List to Min-Heap    root = SortedLLToMinHeap(root, head);    return root;} // Driver codepublic static void main(String args[]){    /* Constructing below tree                8            / \            4     12        / \ / \        2 6 10 14    */     Node root = newNode(8);    root.left = newNode(4);    root.right = newNode(12);    root.right.left = newNode(10);    root.right.right = newNode(14);    root.left.left = newNode(2);    root.left.right = newNode(6);     root = BSTToMinHeap(root);     /* Output - Min Heap                2            / \            4     6        / \ / \        8 10 12 14    */     printLevelOrder(root);}} // This code is contributed by andrew1234
# Python3 program to construct all unique# BSTs for keys from 1 to n # Binary Tree Node""" A utility function to create anew BST node """class newNode:     # Construct to create a newNode    def __init__(self, data):        self.data = data        self.left = None        self.right = None # Utility function to print Min-heap# level by leveldef printLevelOrder(root):         # Base Case    if (root == None):        return     # Create an empty queue for level    # order traversal    q = []    q.append(root)     while (len(q)):        nodeCount = len(q)        while (nodeCount > 0) :                     node = q[0]            print(node.data, end = " " )            q.pop(0)            if (node.left) :                q.append(node.left)            if (node.right) :                q.append(node.right)            nodeCount -= 1        print() # A simple recursive function to convert a# given Binary Search tree to Sorted Linked# List root     -. Root of Binary Search Treedef BSTToSortedLL(root, head_ref):     # Base cases    if(root == None) :        return     # Recursively convert right subtree    BSTToSortedLL(root.right, head_ref)     # insert root into linked list    root.right = head_ref[0]     # Change left pointer of previous    # head to point to None    if (head_ref[0] != None):        (head_ref[0]).left = None     # Change head of linked list    head_ref[0] = root     # Recursively convert left subtree    BSTToSortedLL(root.left, head_ref) # Function to convert a sorted Linked# List to Min-Heap.# root -. root[0] of Min-Heap# head -. Pointer to head node of#          sorted linked listdef SortedLLToMinHeap( root, head) :     # Base Case    if (head == None) :        return     # queue to store the parent nodes    q = []     # The first node is always the    # root node    root[0] = head[0]     # advance the pointer to the next node    head[0] = head[0].right     # set right child to None    root[0].right = None     # add first node to the queue    q.append(root[0])     # run until the end of linked list    # is reached    while (head[0] != None) :             # Take the parent node from the q        # and remove it from q        parent = q[0]        q.pop(0)         # Take next two nodes from the linked        # list and Add them as children of the        # current parent node. Also in push them        # into the queue so that they will be        # parents to the future nodes        leftChild = head[0]        head[0] = head[0].right     # advance linked list to next node        leftChild.right = None # set its right child to None        q.append(leftChild)         # Assign the left child of parent        parent.left = leftChild         if (head) :            rightChild = head[0]            head[0] = head[0].right # advance linked list to next node            rightChild.right = None # set its right child to None            q.append(rightChild)             # Assign the right child of parent            parent.right = rightChild # Function to convert BST into a Min-Heap# without using any extra spacedef BSTToMinHeap(root):     # head of Linked List    head = [None]     # Convert a given BST to Sorted Linked List    BSTToSortedLL(root, head)         # set root as None    root = [None]     # Convert Sorted Linked List to Min-Heap    SortedLLToMinHeap(root, head)    return root # Driver Codeif __name__ == '__main__':     """ Constructing below tree                8            / \            4     12        / \ / \        2 6 10 14    """    root = newNode(8)    root.left = newNode(4)    root.right = newNode(12)    root.right.left = newNode(10)    root.right.right = newNode(14)    root.left.left = newNode(2)    root.left.right = newNode(6)     root = BSTToMinHeap(root)         """ Output - Min Heap                2            / \            4     6        / \ / \        8 10 12 14    """    printLevelOrder(*root) # This code is contributed by# Shubham Singh(SHUBHAMSINGH10)
// C# Program to convert a BST into a Min-Heap// in O(n) time and in-placeusing System;using System.Collections.Generic;public class GFG{   // Node for BST/Min-Heap  public    class Node    {      public        int data;      public        Node left, right;    };   // Utility function for allocating node for BST  static Node newNode(int data)  {    Node node = new Node();    node.data = data;    node.left = node.right = null;    return node;  }   // Utility function to print Min-heap level by level  static void printLevelOrder(Node root)  {     // Base Case    if (root == null) return;     // Create an empty queue for level order traversal    Queue<Node> q = new Queue<Node>();    q.Enqueue(root);     while (q.Count > 0)    {      int nodeCount = q.Count;      while (nodeCount > 0)      {        Node node = q.Peek();        Console.Write( node.data + " ");        q.Dequeue();        if (node.left != null)          q.Enqueue(node.left);        if (node.right != null)          q.Enqueue(node.right);        nodeCount--;      }      Console.WriteLine();    }  }   // A simple recursive function to convert a given  // Binary Search tree to Sorted Linked List  // root     -. Root of Binary Search Tree  // head_ref -. Pointer to head node of created  //             linked list  static Node BSTToSortedLL(Node root, Node head_ref)  {     // Base cases    if(root == null)      return head_ref;     // Recursively convert right subtree    head_ref = BSTToSortedLL(root.right, head_ref);     // insert root into linked list    root.right = head_ref;     // Change left pointer of previous head    // to point to null    if (head_ref != null)      (head_ref).left = null;     // Change head of linked list    head_ref = root;     // Recursively convert left subtree    head_ref = BSTToSortedLL(root.left, head_ref);    return head_ref;  }   // Function to convert a sorted Linked  // List to Min-Heap.  // root -. Root of Min-Heap  // head -. Pointer to head node of sorted  //             linked list  static Node SortedLLToMinHeap(Node root, Node head)  {    // Base Case    if (head == null)      return null;     // queue to store the parent nodes    Queue<Node > q = new Queue<Node>();     // The first node is always the root node    root = head;     // advance the pointer to the next node    head = head.right;     // set right child to null    root.right = null;     // add first node to the queue    q.Enqueue(root);     // run until the end of linked list is reached    while (head != null)    {       // Take the parent node from the q and remove it from q      Node parent = q.Peek();      q.Dequeue();       // Take next two nodes from the linked list and      // Add them as children of the current parent node      // Also in add them into the queue so that      // they will be parents to the future nodes      Node leftChild = head;      head = head.right;     // advance linked list to next node      leftChild.right = null; // set its right child to null      q.Enqueue(leftChild);       // Assign the left child of parent      parent.left = leftChild;      if (head != null)      {        Node rightChild = head;        head = head.right; // advance linked list to next node        rightChild.right = null; // set its right child to null        q.Enqueue(rightChild);         // Assign the right child of parent        parent.right = rightChild;      }    }    return root;  }   // Function to convert BST into a Min-Heap  // without using any extra space  static Node BSTToMinHeap(Node root)  {     // head of Linked List    Node head = null;     // Convert a given BST to Sorted Linked List    head = BSTToSortedLL(root, head);     // set root as null    root = null;     // Convert Sorted Linked List to Min-Heap    root = SortedLLToMinHeap(root, head);    return root;  }   // Driver code  public static void Main(String []args)  {     /* Constructing below tree                8            / \            4     12        / \ / \        2 6 10 14    */     Node root = newNode(8);    root.left = newNode(4);    root.right = newNode(12);    root.right.left = newNode(10);    root.right.right = newNode(14);    root.left.left = newNode(2);    root.left.right = newNode(6);     root = BSTToMinHeap(root);     /* Output - Min Heap                2            / \            4     6        / \ / \        8 10 12 14    */    printLevelOrder(root);  }} // This code is contributed by aashish1995
<script>  // Javascript Program to convert a BST into a Min-Heap// in O(n) time and in-place// Node for BST/Min-Heapclass Node{    constructor()    {        this.data = 0;        this.left = null;        this.right = null;    }}; // Utility function for allocating node for BSTfunction newNode(data){  var node = new Node();  node.data = data;  node.left = node.right = null;  return node;}// Utility function to print Min-heap level by levelfunction printLevelOrder(root){  // Base Case  if (root == null) return;  // Create an empty queue for level order traversal  var q = [];  q.push(root);  while (q.length > 0)  {    var nodeCount = q.length;    while (nodeCount > 0)    {      var node = q[0];      document.write( node.data + " ");      q.shift();      if (node.left != null)        q.push(node.left);      if (node.right != null)        q.push(node.right);      nodeCount--;    }    document.write("<br>");  }}// A simple recursive function to convert a given// Binary Search tree to Sorted Linked List// root     -. Root of Binary Search Tree// head_ref -. Pointer to head node of created//             linked listfunction BSTToSortedLL(root, head_ref){  // Base cases  if(root == null)    return head_ref;  // Recursively convert right subtree  head_ref = BSTToSortedLL(root.right, head_ref);  // insert root into linked list  root.right = head_ref;  // Change left pointer of previous head  // to point to null  if (head_ref != null)    (head_ref).left = null;  // Change head of linked list  head_ref = root;  // Recursively convert left subtree  head_ref = BSTToSortedLL(root.left, head_ref);  return head_ref;}// Function to convert a sorted Linked// List to Min-Heap.// root -. Root of Min-Heap// head -. Pointer to head node of sorted//             linked listfunction SortedLLToMinHeap( root, head){  // Base Case  if (head == null)    return null;  // queue to store the parent nodes  var q = [];  // The first node is always the root node  root = head;  // advance the pointer to the next node  head = head.right;  // set right child to null  root.right = null;  // add first node to the queue  q.push(root);  // run until the end of linked list is reached  while (head != null)  {    // Take the parent node from the q and remove it from q    var parent = q[0];    q.shift();    // Take next two nodes from the linked list and    // Add them as children of the current parent node    // Also in add them into the queue so that    // they will be parents to the future nodes    var leftChild = head;    head = head.right;     // advance linked list to next node    leftChild.right = null; // set its right child to null    q.push(leftChild);    // Assign the left child of parent    parent.left = leftChild;    if (head != null)    {      var rightChild = head;      head = head.right; // advance linked list to next node      rightChild.right = null; // set its right child to null      q.push(rightChild);      // Assign the right child of parent      parent.right = rightChild;    }  }  return root;}// Function to convert BST into a Min-Heap// without using any extra spacefunction BSTToMinHeap(root){  // head of Linked List  var head = null;  // Convert a given BST to Sorted Linked List  head = BSTToSortedLL(root, head);  // set root as null  root = null;  // Convert Sorted Linked List to Min-Heap  root = SortedLLToMinHeap(root, head);  return root;}// Driver code/* Constructing below tree            8        / \        4     12    / \ / \    2 6 10 14*/var root = newNode(8);root.left = newNode(4);root.right = newNode(12);root.right.left = newNode(10);root.right.right = newNode(14);root.left.left = newNode(2);root.left.right = newNode(6);root = BSTToMinHeap(root);/* Output - Min Heap            2        / \        4     6    / \ / \    8 10 12 14*/printLevelOrder(root);  </script>
2 
4 6 
8 10 12 14 

Time Complexity: O(n)Auxiliary Space: O(n)
This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
SHUBHAMSINGH10
andrew1234
Rushikesh Deshpande
aashish1995
rutvik_56
surinderdawra388
simmytarika5
geekygirl2001
hardikkoriintern
Binary Search Tree
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Find postorder traversal of BST from preorder traversal
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
Optimal Binary Search Tree | DP-24
Lowest Common Ancestor in a Binary Search Tree.
Inorder Successor in Binary Search Tree
Merge Two Balanced Binary Search Trees
Inorder predecessor and successor for a given key in BST
set vs unordered_set in C++ STL
Find the node with minimum value in a Binary Search Tree
Find k-th smallest element in BST (Order Statistics in BST)