In place, convert BST into a Min-Heap

Problem Statement:

Transform a Binary Search Tree into a Min-Heap with the same elements, utilizing an in-place approach and achieving this conversion in linear time complexity (O(n)).

Input:

        15
       /      \
    10       20
  /   \     /   \
 8     12  17    25

Output:

       8
     /    \
   10       17
 /   \     /   \
15   12   20    25

Likewise, the answer might be anything that follows the principles of Min-Heap.

Note: Before looking into the solution, try to come up with an approach first

Method 1: Naive approach:

Using extra space:

Create an array arr of size N, where N represents the number of nodes in the given BST.
Execute an inorder traversal of the BST, storing the node values in the array arr in sorted order.
Proceed with the preorder traversal of the tree.
While traversing the root during the preorder traversal, systematically assign values from the array arr to the nodes of the BST, ensuring that each node's value follows the necessary order for a Min-Heap.

Pseudo Code:

Node structure:
    data
    left
    right

Function: getNode
    Create a new node with the given data
    Set left and right pointers to NULL
    Return the newly created node

Function: inorderTraversal
    if the root is NULL, return
    inorderTraversal(root->left)
    Append root's data to arr
    inorderTraversal(root->right)

Function: BSTToMinHeap
    if the root is NULL, return
    Set root's data to arr[i]
    Increment i
    BSTToMinHeap(root->left)
    BSTToMinHeap(root->right)

Function: convertToMinHeapUtil
    Create an empty array are
    Initialize i to -1
    Perform inorderTraversal(root, arr)
    Perform BSTToMinHeap(root, arr, &i)

Function: preorderTraversal
    if root is NULL, return
    Print root's data
    preorderTraversal(root->left)
    preorderTraversal(root->right)

Note: Try to implement without looking into the original code to improve your standards of coding by referring to the above-mentioned pseudo code if it got stuck in between and cross-check the solution provided to review the multiple ways of writing the code.

By employing this approach, we ensure that the Binary Search Tree is transformed into a Min-Heap with the specified conditions, maintaining the integrity and order of elements accordingly.

Java Implementation of the above approach

import java.util.ArrayList;

// Class representing a node in the BST
class Node {
    int data;
    Node left, right;

    Node(int data) {
        this.data = data;
        left = right = null;
    }
}

// Main class to convert the given BST to Min Heap
public class BSTToMinHeapConversion {

    // Helper function to do inorder traversal and store the values in the array
    private static void inorderTraversal(Node root, ArrayList<Integer> arr) {
        if (root == null)
            return;

        // Recur on the left subtree
        inorderTraversal(root.left, arr);

        // Copy the data of the node
        arr.add(root.data);

        // Recur on the right subtree
        inorderTraversal(root.right, arr);
    }

    // Helper function to convert the BST to Min Heap
    private static void BSTToMinHeap(Node root, ArrayList<Integer> arr, int[] i) {
        if (root == null)
            return;

        // First, copy data at index 'i' of 'arr' to the node
        root.data = arr.get(++i[0]);

        // Recur on the left subtree
        BSTToMinHeap(root.left, arr, i);

        // Recur on the right subtree
        BSTToMinHeap(root.right, arr, i);
    }

    // Utility function to convert the given BST to Min Heap
    private static void convertToMinHeapUtil(Node root) {
        // ArrayList to store the data of all the nodes of the BST
        ArrayList<Integer> arr = new ArrayList<>();
        int[] i = {-1};

        // Inorder traversal to populate 'arr'
        inorderTraversal(root, arr);

        // BST to Min Heap conversion
        BSTToMinHeap(root, arr, i);
    }

    // Function for preorder traversal of the tree
    private static void preorderTraversal(Node root) {
        if (root == null)
            return;

        // First, print the root's data
        System.out.print(root.data + " ");

        // Recur on the left subtree
        preorderTraversal(root.left);

        // Recur on the right subtree
        preorderTraversal(root.right);
    }

    // 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);

        // Function call
        convertToMinHeapUtil(root);
        System.out.println("Preorder Traversal:");
        preorderTraversal(root);
    }
}

Output:

Explanation:

The BSTToMinHeap method recursively transforms the BST into a Min Heap using preorder traversal.
It first assigns the value at index i of the ArrayList arr to the current node, updating the index afterwards (i[0] is an array to maintain a mutable index across recursive calls).
It then recursively processes the left and right subtrees.
The convertToMinHeapUtil method acts as a utility function that initializes an ArrayList to store node values and starts the conversion process by calling inorderTraversal to populate the ArrayList and BSTToMinHeap to perform the conversion.

Time Complexity: O(N)

Space Complexity: O(N)

Since the above approach makes use of auxiliary space, you need to optimize the solution further.

Method 2: (Optimal)

When permitted to utilize additional memory, we can execute an inorder traversal of the tree and record the keys in a separate array. This array will naturally be sorted due to the properties of the BST. Subsequently, we can create a complete binary tree by traversing the sorted array and constructing nodes level by level, from left to right. By selecting the next minimum element from the sorted array, we guarantee that the resultant binary tree adheres to the min-Heap property. This method achieves a time complexity of O(n) but necessitates extra space for array storage, making it a non-in-place solution."

"To achieve an in-place transformation of a binary search tree into a sorted linked list, we employ a reverse inorder traversal. This involves traversing the BST in a manner that prioritizes the right subtree before the left subtree. As we traverse, we insert nodes at the beginning of the existing linked list and adjust the head pointer accordingly. By performing this reverse inorder traversal and carefully managing node insertions, we maintain the sorted order of the linked list. This method ensures an efficient use of memory without relying on additional data structures."

"Subsequently, we proceed to convert the sorted linked list into a min-Heap. This transformation involves carefully adjusting the left and right pointers of the nodes to adhere to the min-Heap properties. To accomplish this, we conduct a level order traversal of the partially constructed min-Heap Tree. Simultaneously, we traverse the linked list in sync with this traversal. At each step, we designate the parent node from the queue, assigning the next two nodes from the linked list as its children. These newly assigned nodes are then enqueued for further processing. This process, supported by the sorted nature of the linked list, guarantees the preservation of the min-heap property."

Hope you understand this approach; below is the detailed algorithm for your logical understanding

Algorithm to Convert BST to Min-Heap In-Place:

Step 1: Define Node Structure

Define a structure Node with integer data and pointers to left and right children.

Step 2: Define Utility Functions

Define a utility function newNode(data) to create a new node with the given data, initializing left and right pointers to NULL.

Step 3: Convert BST to Sorted Linked List

Define a function BSTToSortedLL(root, head_ref) to convert the BST to a sorted linked list using reverse inorder traversal.

Base Case: If root is NULL, return.

Recursively call BSTToSortedLL(root.right, head_ref).

Update pointers to convert the tree to a linked list.

Step 4: Convert Sorted Linked List to Min-Heap

Define a function SortedLLToMinHeap(root, head) to convert the sorted linked list to a Min-Heap using a queue.

Base Case: If the head is NULL, return.

Initialize a queue.

Start with the first node as the root of the Min-Heap.

Traverse the linked list and use a queue to set the left and right child pointers.

Java Implementation of the above approach

import java.util.LinkedList;
import java.util.Queue;

class TreeNode {
    int value;
    TreeNode left, right;

    // Constructor to initialize a TreeNode
    public TreeNode(int item) {
        value = item;
        left = right = null;
    }
}

public class BSTToMinHeapConverter {

    // Utility function to print the level order of a tree
    private static void printLevelOrder(TreeNode root) {
        if (root == null)
            return;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            int nodeCount = queue.size();
            while (nodeCount > 0) {
                TreeNode node = queue.poll();
                System.out.print(node.value + " ");
                if (node.left != null)
                    queue.add(node.left);
                if (node.right != null)
                    queue.add(node.right);
                nodeCount--;
            }
            System.out.println();
        }
    }

    // Convert the given BST to a sorted linked list
    private static void BSTToSortedLinkedList(TreeNode root, TreeNode[] headRef) {
        if (root == null)
            return;

        // Traverse the right subtree
        BSTToSortedLinkedList(root.right, headRef);

        // Insert the root into the linked list
        root.right = headRef[0];

        if (headRef[0] != null)
            headRef[0].left = null;

        // Update the head of the linked list
        headRef[0] = root;

        // Traverse the left subtree
        BSTToSortedLinkedList(root.left, headRef);
    }

    // Convert a sorted linked list to a min-heap
    private static void SortedLinkedListToMinHeap(TreeNode root, TreeNode head) {
        if (head == null)
            return;

        Queue<TreeNode> queue = new LinkedList<>();
        root = head;
        head = head.right;
        root.right = null;
        queue.add(root);

        while (head != null) {
            TreeNode parent = queue.poll();
            TreeNode leftChild = head;
            head = head.right;
            leftChild.right = null;
            queue.add(leftChild);
            parent.left = leftChild;

            if (head != null) {
                TreeNode rightChild = head;
                head = head.right;
                rightChild.right = null;
                queue.add(rightChild);
                parent.right = rightChild;
            }
        }
    }

    // Convert BST to Min-Heap in-place
    private static TreeNode BSTToMinHeap(TreeNode root) {
        TreeNode[] head = {null};
        BSTToSortedLinkedList(root, head);
        root = null;
        SortedLinkedListToMinHeap(root, head[0]);
        return head[0];
    }

    public static void main(String[] args) {
        /* Constructing below tree
                8
               / \
             4  12
            / \ / \
          2 6 10 14
        */

        TreeNode root = new TreeNode(8);
        root.left = new TreeNode(4);
        root.right = new TreeNode(12);
        root.right.left = new TreeNode(10);
        root.right.right = new TreeNode(14);
        root.left.left = new TreeNode(2);
        root.left.right = new TreeNode(6);

        // Convert the BST to a Min-Heap
        TreeNode minHeapRoot = BSTToMinHeap(root);

        /* Output - Min Heap
                2
               / \
              4  6
             / \ / \
          8 10 12 14
        */

        // Print the min-heap in level order
        printLevelOrder(minHeapRoot);
    }
}

Output: