# Convert BST into a Min-Heap without using array

• Difficulty Level : Hard
• Last Updated : 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++

 `//C++ Program to convert a BST into a Min-Heap``// in O(n) time and in-place``#include ``using` `namespace` `std;` `// Node for BST/Min-Heap``struct` `Node``{``    ``int` `data;``    ``Node *left, *right;``};` `// Utility function for allocating node for BST``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``void` `printLevelOrder(Node *root)``{``    ``// Base Case``    ``if` `(root == NULL)  ``return``;` `    ``// Create an empty queue for level order traversal``    ``queue 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 list``void` `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 list``void` `SortedLLToMinHeap(Node* &root, Node* head)``{``    ``// Base Case``    ``if` `(head == NULL)``        ``return``;` `    ``// queue to store the parent nodes``    ``queue 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 space``Node* 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 code``int` `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

 `// Java Program to convert a BST into a Min-Heap``// in O(n) time and in-place``import` `java.util.*;` `class` `GFG``{``    ` `// Node for BST/Min-Heap``static` `class` `Node``{``    ``int` `data;``    ``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 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 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 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 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 andrew1234`

## Python3

 `# Python3 program to construct all unique``# BSTs for keys from 1 to n` `# Binary Tree Node``""" A utility function to create a``new 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 level``def` `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 Tree``def` `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 of Min-Heap``# head -. Pointer to head node of``#          sorted linked list``def` `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 space``def` `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 Code``if` `__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#

 `// C# Program to convert a BST into a Min-Heap``// in O(n) time and in-place``using` `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 q = ``new` `Queue();``    ``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 q = ``new` `Queue();` `    ``// 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`

## Javascript

 ``

Output

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

My Personal Notes arrow_drop_up