Convert BST to Max Heap

// Java implementation to convert a given
// BST to Max Heap
import java.util.*;

class GFG
{

static int i;
static class Node
{
    int data;
    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 for the inorder traversal of the tree
// so as to store the node values in 'arr' in
// sorted order
static void inorderTraversal(Node root, Vector<Integer> arr)
{
    if (root == null)
        return;

    // first recur on left subtree
    inorderTraversal(root.left, arr);

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

    // now recur for right subtree
    inorderTraversal(root.right, arr);
}

static void BSTToMaxHeap(Node root, Vector<Integer> arr)
{
    if (root == null)
        return;

    // recur on left subtree
    BSTToMaxHeap(root.left, arr);

    // recur on right subtree
    BSTToMaxHeap(root.right, arr);

    // copy data at index 'i' of 'arr' to
    // the node
    root.data = arr.get(i++);
}

// Utility function to convert the given BST to
// MAX HEAP
static void convertToMaxHeapUtil(Node root)
{
    // vector to store the data of all the
    // nodes of the BST
    Vector<Integer> arr = new Vector<Integer>();
    int i = -1;

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

    // BST to MAX HEAP conversion
    BSTToMaxHeap(root, arr);
}

// Function to Print Postorder Traversal of the tree
static void postorderTraversal(Node root)
{
    if (root == null)
        return;

    // recur on left subtree
    postorderTraversal(root.left);

    // then recur on right subtree
    postorderTraversal(root.right);

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

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

    convertToMaxHeapUtil(root);
    System.out.print("Postorder Traversal of Tree:" +"\n");
    postorderTraversal(root);

}
}

// This code is contributed by 29AjayKumar

// Java code implementation:

import java.io.*;
import java.util.*;

// Defining the structure of the Node class
class Node {
    int data;
    Node left, right;
    Node(int data)
    {
        this.data = data;
        left = right = null;
    }
}

class GFG {

    // Function to find the parent index of a node
    static int parent(int i) { return (i - 1) / 2; }

    // Function to heapify up the node to arrange in
    // max-heap order
    static void heapify_up(List<Node> q, int i)
    {
        while (i > 0
               && q.get(parent(i)).data < q.get(i).data) {
            Collections.swap(q, i, parent(i));
            i = parent(i);
        }
    }

    // Function to convert BST to max heap
    static Node convertToMaxHeapUtil(Node root)
    {
        if (root == null) {
            return root;
        }
        // Creating a list for storing the nodes of BST
        List<Node> q = new ArrayList<Node>();
        q.add(root);
        int i = 0;
        while (q.size() != i) {
            if (q.get(i).left != null) {
                q.add(q.get(i).left);
            }
            if (q.get(i).right != null) {
                q.add(q.get(i).right);
            }
            i++;
        }

        // Calling heapify_up for each node in the list
        for (int j = 1; j < q.size(); j++) {
            heapify_up(q, j);
        }

        // Updating the root as the maximum value in heap
        root = q.get(0);
        i = 0;

        // Updating left and right nodes of BST using list
        while (i < q.size()) {
            if (2 * i + 1 < q.size()) {
                q.get(i).left = q.get(2 * i + 1);
            }
            else {
                q.get(i).left = null;
            }
            if (2 * i + 2 < q.size()) {
                q.get(i).right = q.get(2 * i + 2);
            }
            else {
                q.get(i).right = null;
            }
            i++;
        }
        return root;
    }

    // Function to print postorder traversal of the tree
    static void postorderTraversal(Node root)
    {
        if (root == null) {
            return;
        }
        // Recurring on left subtree
        postorderTraversal(root.left);
        // Recurring on right subtree
        postorderTraversal(root.right);

        // Printing the root's data
        System.out.print(root.data + " ");
    }

    public static void main(String[] args)
    {
        // Creating the BST
        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);
        // Converting the BST to max heap
        root = convertToMaxHeapUtil(root);

        // Printing the postorder traversal of the tree
        System.out.println("Postorder Traversal of Tree: ");
        postorderTraversal(root);
    }
}

// This code is contributed by karthik.