Question

I need the following merge-sort assignment completed using the "ArrayList<Comparable>" (the part I'm really stuck on) with comments:

import java.util.ArrayList;

public class Mergesort {
    /**
     * Sorts list given using the mergesort algorithm
     * @param list the list to be sorted
     * @param first the index of the first element of the list to be sorted
     * @param last the index of the last element of the list to be sorted
     */
    public static void mergesort(ArrayList<Comparable> list, int first, int last){
    }
    /**
     * Merges two ordered sublists.
     *
     * PRE-CONDITION: list from first to mid-1 is in order, list from mid to last is in order
     * POST-CONDITION: list from first to last is in order
     *
     * @param list the list containing the ordered sublist
     * @param first first element of the first sublist
     * @param mid first element of the second sublist
     * @param last last element of the second sublist
     */
    public static void merge(ArrayList<Comparable> list, int first, int mid, int last){
    }
    public static void main(String[] args) {
    }
    //================================================
    //======= HELPER METHODS FOR TESTING BELOW =======
    //================================================
    /**
     * Returns true if two lists have the same elements.
     *
     * @param orig the original list
     * @param copy the copy of the list
     *
     * @return true if orig and copy have the same number of each element, false otherwise
     */
    private static boolean sameElements(ArrayList<Comparable> orig, ArrayList<Comparable> copy){
    }
    /**
     * Returns true if list is in ascending order
     *
     * @param list the list to check for ordering
     *
     * @return true if list is in ascending order, false otherwise
     */
    private static boolean inOrder(ArrayList<Comparable> list){
    }
    /**
     * Returns a deep copy of the given list
     *
     * @param list the list to be copied and return
     *
     * @return deep copy of argument list
     */
    private static ArrayList<Comparable> copyList(ArrayList<Comparable> list){        
    }    
    /**
     * Returns a list of Strings
     *
     * @param length the number of elements the list is to have
     *
     * @return a list of String elements with length size
     */
    private static ArrayList<Comparable> listOfStrings(int length){   
    }
    /**
     * Returns a list of Integers
     *
     * @param low the minimum number in the range of elements
     * @param high the maximum number in the range of elements
     * @param length the number of elements the list is to have
     *
     * @return a list of Integer elements with length size
     */
    private static ArrayList<Comparable> listOfInts(int low, int high, int length){   
    }
}

And here is the Pseudocode:

1. If the array has only one element, do nothing.

2. If the array has two elements, swap them if necessary.

3. Split the array into two approximately equal values.

4. Sort the first half and the second half.

5 Merge both halves together.

Answer 1

MergeSort.java

import java.util.*;

public class MergeSort {
/**
* Sorts list given using the mergesort algorithm
* @param list the list to be sorted
* @param first the index of the first element of the list to be sorted
* @param last the index of the last element of the list to be sorted
*/
public static void mergesort(ArrayList<Comparable> list, int first, int last)
   {
       if( first < last )
       {
           int center = (first + last) / 2;
           mergesort(list, first, center);
           mergesort(list, center + 1, last);
           merge(list, first, center + 1, last);  
       }
}
/**
* Merges two ordered sublists.
*
* PRE-CONDITION: list from first to mid-1 is in order, list from mid to last is in order
* POST-CONDITION: list from first to last is in order
*
* @param list the list containing the ordered sublist
* @param first first element of the first sublist
* @param mid first element of the second sublist
* @param last last element of the second sublist
*/
public static void merge(ArrayList<Comparable> list, int first, int mid, int last)
   {
       int leftEnd = mid - 1;
int k = first;
int num = last - first + 1;
       ArrayList<Comparable> tmp = copyList(list);
while(first <= leftEnd && mid <= last)
if(list.get(first).compareTo(list.get(mid)) <= 0)
           {
               tmp.set(k, list.get(first));
               k++; first++;
           }
else
           {
               tmp.set(k, list.get(mid));
               k++; mid++;
           }
while(first <= leftEnd) // Copy rest of first half
       {
           tmp.set(k, list.get(first));
           k++; first++;
       }

while(mid <= last) // Copy rest of mid half
{
           tmp.set(k, list.get(mid));
           k++; mid++;
       }

// Copy tmp back
for(int i = 0; i < num; i++, last--)
list.set(last, tmp.get(last));
}
public static void main(String[] args)
   {
       MergeSort sort = new MergeSort();
       int count = 15;
       ArrayList<Comparable> ilist = MergeSort.listOfInts(10, 100, count);
       ArrayList<Comparable> slist = MergeSort.listOfStrings(count);
       for(int i=0; i<count; i++) System.out.print(ilist.get(i)+" ");
       System.out.println();
       for(int i=0; i<count; i++) System.out.print(slist.get(i)+" ");
       System.out.println();
       sort.mergesort(ilist, 0, count-1);
       sort.mergesort(slist, 0, count-1);
       for(int i=0; i<count; i++) System.out.print(ilist.get(i)+" ");
       System.out.println();
       System.out.println("integer array is sorted: "+ MergeSort.inOrder(ilist));
       for(int i=0; i<count; i++) System.out.print(slist.get(i)+" ");
       System.out.println();
       System.out.println("string array is sorted: "+ MergeSort.inOrder(slist));
}
//================================================
//======= HELPER METHODS FOR TESTING BELOW =======
//================================================
/**
* Returns true if two lists have the same elements.
*
* @param orig the original list
* @param copy the copy of the list
*
* @return true if orig and copy have the same number of each element, false otherwise
*/
private static boolean sameElements(ArrayList<Comparable> orig, ArrayList<Comparable> copy)
   {
       for(int i=1; i<orig.size(); i++)
       {
           if(orig.get(i).compareTo(copy.get(i))==0) return false;
       }
       return true;
}
/**
* Returns true if list is in ascending order
*
* @param list the list to check for ordering
*
* @return true if list is in ascending order, false otherwise
*/
private static boolean inOrder(ArrayList<Comparable> list)
   {
       for(int i=1; i<list.size(); i++)
       {
           if(list.get(i).compareTo(list.get(i-1))<0) return false;
       }
       return true;
}
/**
* Returns a deep copy of the given list
*
* @param list the list to be copied and return
*
* @return deep copy of argument list
*/
private static ArrayList<Comparable> copyList(ArrayList<Comparable> list)
   {
       ArrayList<Comparable> tmp = new ArrayList<Comparable>(list.size());
       for(int i=0; i<list.size(); i++)
           tmp.add(list.get(i));
       return tmp;  
}
/**
* Returns a list of Strings
*
* @param length the number of elements the list is to have
*
* @return a list of String elements with length size
*/
private static ArrayList<Comparable> listOfStrings(int length)
   {
       String AlphaNumericString = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvxyz";
       ArrayList<Comparable> list = new ArrayList<Comparable>(length);                          
       for(int j=0; j<length; j++)
       {
           StringBuilder sb = new StringBuilder(10);
           for (int i = 0; i < 10; i++)
           {
               // generate a random number between
               // 0 to AlphaNumericString variable length
               int index
                   = (int)(AlphaNumericString.length()
                           * Math.random());
               // add Character one by one in end of sb
               sb.append(AlphaNumericString
                           .charAt(index));
           }
           list.add(sb.toString());
       }
       return list;  
}
/**
* Returns a list of Integers
*
* @param low the minimum number in the range of elements
* @param high the maximum number in the range of elements
* @param length the number of elements the list is to have
*
* @return a list of Integer elements with length size
*/
private static ArrayList<Comparable> listOfInts(int low, int high, int length)
   {
       ArrayList<Comparable> list = new ArrayList<Comparable>(length);
       Random randomGenerator = new Random();
       for(int i=0; i<length; i++)
       list.add(low + randomGenerator.nextInt(high-low) + 1);
       return list;
}
}