Question

In Java

1. Write merge method for mergeSort method.

2. Write MaxheapPriorityQueue constructor, which takes an array of data, and construct the max

heap priority queue using bottom-up algorithm. Assuming bubbleDown method is provided.

Answer 1

Answer :

Step 1 : MergeSort method. in java

Mergesort is a divide and conquer algorithm., Divide and conquer algorithms divide the original data into smaller sets of data to solve the problem. Steps to implement Merge Sort:

• Divide the unsorted array into n partitions, each partition contains 1 element. Here the one element is considered as sorted.
• Repeatedly merge partitioned units to produce new sublists until there is only 1 sublist remaining. This will be the sorted list at the end
• Merge sort is a fast, stable sorting routine with guaranteed O(n*log(n)) efficiency.

Algorithm

• Step 1: [INITIALIZE] SET I = BEG, J = MID + 1, INDEX = 0
• Step 2: Repeat while (I <= MID) AND (J<=END)
  IF ARR[I] < ARR[J]
  SET TEMP[INDEX] = ARR[I]
  SET I = I + 1
  ELSE
  SET TEMP[INDEX] = ARR[J]
  SET J = J + 1
  [END OF IF]
  SET INDEX = INDEX + 1
  [END OF LOOP]
  Step 3: [Copy the remaining
  elements of right sub-array, if
  any]
  IF I > MID
  Repeat while J <= END
  SET TEMP[INDEX] = ARR[J]
  SET INDEX = INDEX + 1, SET J = J + 1
  [END OF LOOP]
  [Copy the remaining elements of
  left sub-array, if any]
  ELSE
  Repeat while I <= MID
  SET TEMP[INDEX] = ARR[I]
  SET INDEX = INDEX + 1, SET I = I + 1
  [END OF LOOP]
  [END OF IF]
• Step 4: [Copy the contents of TEMP back to ARR] SET K = 0
• Step 5: Repeat while K < INDEX
  SET ARR[K] = TEMP[K]
  SET K = K + 1
  [END OF LOOP]
• Step 6: Exit

Java Program :

import java.util.*;

public class MergerSort

{

    public static void main(String[] args)

    {

        //Unsorted array

        Integer[] a = { 2, 6, 3, 5, 1 };

         

        //Call merge sort

        mergeSort(a);

System.out.println(Arrays.toString(a));

    }

    @SuppressWarnings("rawtypes")

    public static Comparable[] mergeSort(Comparable[] list)

    {

        //If list is empty; no need to do anything

        if (list.length <= 1) {

            return list;

        }

         

        //Split the array in half in two parts

        Comparable[] first = new Comparable[list.length / 2];

        Comparable[] second = new Comparable[list.length - first.length];

        System.arraycopy(list, 0, first, 0, first.length);

        System.arraycopy(list, first.length, second, 0, second.length);

         

        //Sort each half recursively

        mergeSort(first);

        mergeSort(second);

         

        //Merge both halves together, overwriting to original array

        merge(first, second, list);

        return list;

    }

     

    @SuppressWarnings({ "rawtypes", "unchecked" })

    private static void merge(Comparable[] first, Comparable[] second, Comparable[] result)

    {

        //Index Position in first array - starting with first element

        int iFirst = 0;

         

        //Index Position in second array - starting with first element

        int iSecond = 0;

         

        //Index Position in merged array - starting with first position

        int iMerged = 0;

         

        //Compare elements at iFirst and iSecond,

        //and move smaller element at iMerged

        while (iFirst < first.length && iSecond < second.length)

        {

            if (first[iFirst].compareTo(second[iSecond]) < 0)

            {

                result[iMerged] = first[iFirst];

                iFirst++;

            }

            else

            {

                result[iMerged] = second[iSecond];

                iSecond++;

            }

            iMerged++;

        }

        //copy remaining elements from both halves - each half will have already sorted elements

        System.arraycopy(first, iFirst, result, iMerged, first.length - iFirst);

        System.arraycopy(second, iSecond, result, iMerged, second.length - iSecond);

    }

}

Step 2 :Write MaxheapPriorityQueue constructor, which takes an array of data, and construct the max

heap priority queue using bottom-up algorithm. Assuming bubbleDown method is provided

Answer : In this type of heap, the value of parent node will always be greater than or equal to the value of child node across the tree and the node with highest value will be the root node of the tree.

void max_heapify (int Arr[ ], int i, int N)
{
    int left = 2*i                   //left child
    int right = 2*i +1           //right child
    if(left<= N and Arr[left] > Arr[i] )
          largest = left;
    else
         largest = i;
    if(right <= N and Arr[right] > Arr[largest] )
        largest = right;
    if(largest != i )
    {
        swap (Ar[i] , Arr[largest]);
        max_heapify (Arr, largest,N);
    } 
 }