Java Merge Sort mergeSort(Object[] src, Object[] dest, int low, int high, int off)

Description

Src is the source array that starts at index 0 Dest is the (possibly larger) array destination with a possible offset low is the index in dest to start sorting high is the end index in dest to end sorting off is the offset to generate corresponding low, high in src

License

Open Source License

Declaration

@SuppressWarnings({ "unchecked", "rawtypes" })
public static void mergeSort(Object[] src, Object[] dest, int low, int high, int off) 

Method Source Code

//package com.java2s;
/*//from  www  .  jav  a2  s.  c o m
   Leola Programming Language
   Author: Tony Sparks
   See license.txt
*/

public class Main {
    /**
    * Tuning parameter: list size at or below which insertion sort will be
    * used in preference to mergesort or quicksort.
    */
    private static final int INSERTIONSORT_THRESHOLD = 7;

    /**
     * Src is the source array that starts at index 0 Dest is the (possibly
     * larger) array destination with a possible offset low is the index in dest
     * to start sorting high is the end index in dest to end sorting off is the
     * offset to generate corresponding low, high in src
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static void mergeSort(Object[] src, Object[] dest, int low, int high, int off) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i = low; i < high; i++)
                for (int j = i; j > low && ((Comparable) dest[j - 1]).compareTo(dest[j]) > 0; j--)
                    swap(dest, j, j - 1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow = low;
        int destHigh = high;
        low += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

        // If list is already sorted, just copy from src to dest. This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable) src[mid - 1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // Merge sorted halves (now in src) into dest
        for (int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable) src[p]).compareTo(src[q]) <= 0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

    /**
     * Swaps x[a] with x[b].
     */
    private static void swap(Object[] x, int a, int b) {
        Object t = x[a];
        x[a] = x[b];
        x[b] = t;
    }
}

Related

1. mergesort(double[] a, int[] b, int p, int r)
2. mergeSort(int[] a)
3. mergeSort(int[] array)
4. mergeSort(long[] theArray, int nElems)
5. mergeSort(T[] src, T[] dst, int start, int end)
6. mergeSorted(float[] a, int alen, float b[], int blen)
7. mergeSortedAaary(int[] a, int[] b)
8. mergeSortedArrays(double[] a, double[] b)