Convert Min Heap To Max Heap
You are given an array of size ‘n’ which is an array representation of min-heap. You need to convert this min-heap array representation to a max-heap array representation.

For Example- Corresponding to given min heap :-[1,2,3,6,7,8]

It can be converted to the following max heap:[8,7,3,6,2,1]

Input Format:

The first line of input contains an integer ‘T’ denoting the number of test cases. The next 2*T lines represent test cases. The first line contains a single integer ‘n’ denoting the size of the array. The next line contains ‘n’ space-separated integers denoting the min-heap.

Output Format

There can be many possible max-heaps. Return any possible max-heap for given input min-heap. Output for each query is printed in a separate line.

Note

The output max-heap will be checked from the given function:-

If the output array is max-heap it will return true else it will return false.

Constraints:

1

Question

Convert Min Heap To Max Heap

You are given an array of size ‘n’ which is an array representation of min-heap. You need to convert this min-heap array representation to a max-heap array representation.

For Example- Corresponding to given min heap :-[1,2,3,6,7,8]

It can be converted to the following max heap:[8,7,3,6,2,1]

Input Format:

The first line of input contains an integer ‘T’ denoting the number of test cases.

The next 2*T lines represent test cases.

The first line contains a single integer ‘n’ denoting the size of the array.

The next line contains ‘n’ space-separated integers denoting the min-heap.

Output Format

There can be many possible max-heaps. Return any possible max-heap for given input min-heap.

Output for each query is printed in a separate line.

Note

The output max-heap will be checked from the given function:-

If the output array is max-heap it will return true else it will return false.

Constraints:

1 <= ’T' <= 10
1 <= ’n’ <= 5000
1 <= arr[ i ] <= 10^5

where 'T' denotes the number of test cases, 'n' denotes the size of the array and arr[i] denotes the elements of the input array.

Time Limit : 1 sec

Accepted Answer

Simply build Max Heap without caring about the input. Start from the bottom-most and rightmost internal node of min Heap and heapify all internal nodes in the bottom-up way to build the Max heap.
Time Complexity : O(N)

Accepted Answer

Sorting Approach

The main idea is that when an array is sorted in descending order it becomes max heap as for every ‘i’ from i=0 to n/2 it is greater than equal to arr[2*i+1] and arr[2*i+2].

Space Complexity: O(1)Explanation:

O(1)

We are using constant space to solve this.

Time Complexity: O(nlogn)Explanation:

O(n*log(n)), where n is the size of the array.

Sorting an array takes O(n*log(n)) time complexity.

Python (3.5)

"""
   Time Complexity:O(n*log(n))
   Space Complexity:O(1)

   where 'n' is the number of elements in the array
"""


def MinToMaxHeap(n, arr):

    # Sorting in descending order.
   arr.sort(reverse=True)
   return arr

C++ (g++ 5.4)

/*
   Time Complexity:O(n*log(n))
   Space Complexity:O(1)

   where 'n' is the number of elements in the array
*/

vectorMinToMaxHeap(int n, vector&arr)
{
	// Sorting in descending order.
	sort(arr.begin(), arr.end(), greater());

	return arr;
}

Java (SE 1.8)

/*
   Time Complexity:O(n*log(n))
   Space Complexity:O(1)

   where 'n' is the number of elements in the array
*/
import java.util.ArrayList;
import java.util.Collections;

public class Solution 
{
    public static ArrayList MinToMaxHeap(int n, int[] arr)
    {
        ArrayList al = new ArrayList();
        for (int i = 0; i < n; i++)
        {
            al.add(arr[i]);
        }
        // Sorting in reverse order
        Collections.sort(al, Collections.reverseOrder());
        return al;
		
    }

}

Accepted Answer

Heapify Approach

The main idea is to build max-heap for the given input array just like in heapsort. It will convert the input array into a max heap. We will perform the heapify(Refer Heap Sort Algorithm) process to the given input array to build the heap. In a max heap, if arr[ i ] is less than it’s it children node arr[2*i+1] and arr[2*i+2] then replace it with children and call heapfiy on the corresponding child node.Heapify can only be applied to a node only when its children are heapified. Hence it must be performed in bottom-up order.