TestSequentialMergeSort.java

package object_in;

public class SequentialMergeSort {

	private int[] listToSort;

	/**
	 * Construct a new MergeSort object that will
	 * sort the specified array of integers.
	 *
	 * @param listToSort the array of integers to be sorted.
	 */
	public SequentialMergeSort(int[] listToSort) {
		this.listToSort = listToSort;
	}

	/**
	 * Get a reference to the array of integers in this
	 * MergeSort object.
	 *
	 * @return a reference to the array of integers.
	 */
	public int[] getList() {
		return listToSort;
	}

	/**
	 * Recursive helper method which sorts the array referred to 
	 * by whole using the merge sort algorithm.
	 *
	 * @param whole the array to be sorted.
	 * @return a reference to an array that holds the elements
	 *         of whole sorted into non-decreasing order.
	 */
	private int[] sort(int[] whole) {
		if (whole.length == 1) {
			return whole;
		}
		else {
			// Create an array to hold the left half of the whole array
			// and copy the left half of whole into the new array.
			int[] left = new int[whole.length/2];
			System.arraycopy(whole, 0, left, 0, left.length);

			// Create an array to hold the right half of the whole array
			// and copy the right half of whole into the new array.
			int[] right = new int[whole.length-left.length];
			System.arraycopy(whole, left.length, right, 0, right.length);

			// Sort the left and right halves of the array.
			left = sort(left);
			right = sort(right);

			// Merge the results back together.
			merge(left, right, whole);

			return whole;
		}
	}

	/**
	 * Merge the two sorted arrays left and right into the
	 * array whole.
	 *
	 * @param left a sorted array.
	 * @param right a sorted array.
	 * @param whole the array to hold the merged left and right arrays.
	 */
	private void merge(int[] left, int[] right, int[] whole) {
		int leftIndex = 0;
		int rightIndex = 0;
		int wholeIndex = 0;

		// As long as neither the left nor the right array has
		// been used up, keep taking the smaller of left[leftIndex]
		// or right[rightIndex] and adding it at both[bothIndex].
		while (leftIndex < left.length &&
				rightIndex < right.length) {
			if (left[leftIndex] < right[rightIndex]) {
				whole[wholeIndex] = left[leftIndex];
				leftIndex++;
			}
			else {
				whole[wholeIndex] = right[rightIndex];
				rightIndex++;
			}
			wholeIndex++;
		}

		int[] rest;
		int restIndex;
		if (leftIndex >= left.length) {
			// The left array has been use up...
			rest = right;
			restIndex = rightIndex;
		}
		else {
			// The right array has been used up...
			rest = left;
			restIndex = leftIndex;
		}

		// Copy the rest of whichever array (left or right) was
		// not used up.
		for (int i=restIndex; i<rest.length; i++) {
			whole[wholeIndex] = rest[i];
			wholeIndex++;
		}
	}

	/**
	 * Sort the values in the array of integers in this
	 * MergeSort object into non-decreasing order.
	 */
	public void sort() {
		listToSort = sort(listToSort);
	}

	public static void main(String[] args) {

		int[] arrayToSort = ArrayUtil.randomArray(25,50);

		System.out.println("Unsorted:");
		ArrayUtil.printArray(arrayToSort, 5);

		SequentialMergeSort sortObj = new SequentialMergeSort(arrayToSort);
		sortObj.sort();

		System.out.println("Sorted:");
		ArrayUtil.printArray(sortObj.getList(), 5);
	}
}