This is a generic version of C.A.R Hoare's Quick Sort algorithm. - Java Collection Framework

Java examples for Collection Framework:Array Sort

  1. HOME
  2. Java
  3. Collection Framework
  4. Array Sort

Description

This is a generic version of C.A.R Hoare's Quick Sort algorithm.

Demo Code



public class Main{

    /**/*from   w  w w .  j av  a 2 s  . c  o m*/
     * This is a generic version of C.A.R Hoare's Quick Sort
     * algorithm.  This will handle arrays that are already
     * sorted, and arrays with duplicate keys.<BR>
     * <p/>
     * If you think of a one dimensional array as going from
     * the lowest index on the left to the highest index on the right
     * then the parameters to this function are lowest index or
     * left and highest index or right.  The first time you call
     * this function it will be with the parameters 0, a.length - 1.
     * (taken out of a code by James Gosling and Kevin A. Smith provided
     * with Sun's JDK 1.1.7)
     *
     * @param a   an integer array
     * @param lo0 left boundary of array partition (inclusive).
     * @param hi0 right boundary of array partition (inclusive).
     */
    private static void quickSortMaxToMin(int a[], int lo0, int hi0) {
        int lo = lo0;
        int hi = hi0;
        int mid;

        if (hi0 > lo0) {

            /* Arbitrarily establishing partition element as the midpoint of
             * the array.
             */
            mid = a[(int) Math.round((lo0 + hi0) / 2.0)];

            // loop through the array until indices cross
            while (lo <= hi) {
                /* find the first element that is greater than or equal to
                 * the partition element starting from the left Index.
                 */
                while ((lo < hi0) && (a[lo] > mid))
                    ++lo;

                /* find an element that is smaller than or equal to
                 * the partition element starting from the right Index.
                 */
                while ((hi > lo0) && (a[hi] < mid))
                    --hi;

                // if the indexes have not crossed, swap
                if (lo <= hi) {
                    swap(a, lo, hi);
                    ++lo;
                    --hi;
                }
            }

            /* If the right index has not reached the left side of array
             * must now sort the left partition.
             */
            if (lo0 < hi)
                quickSortMaxToMin(a, lo0, hi);

            /* If the left index has not reached the right side of array
             * must now sort the right partition.
             */
            if (lo < hi0)
                quickSortMaxToMin(a, lo, hi0);

        }
    }
    /**
     * This is a generic version of C.A.R Hoare's Quick Sort
     * algorithm.  This will handle arrays that are already
     * sorted, and arrays with duplicate keys.<BR>
     * <p/>
     * If you think of a one dimensional array as going from
     * the lowest index on the left to the highest index on the right
     * then the parameters to this function are lowest index or
     * left and highest index or right.  The first time you call
     * this function it will be with the parameters 0, a.length - 1.
     * (taken out of a code by James Gosling and Kevin A. Smith provided
     * with Sun's JDK 1.1.7)
     *
     * @param a   a double array
     * @param lo0 left boundary of array partition (inclusive).
     * @param hi0 right boundary of array partition (inclusive).
     */
    private static void quickSortMaxToMin(double a[], int lo0, int hi0) {
        int lo = lo0;
        int hi = hi0;
        double mid;

        if (hi0 > lo0) {

            /* Arbitrarily establishing partition element as the midpoint of
             * the array.
             */
            mid = a[(int) Math.round((lo0 + hi0) / 2.0)];

            // loop through the array until indices cross
            while (lo <= hi) {
                /* find the first element that is greater than or equal to
                 * the partition element starting from the left Index.
                 */
                while ((lo < hi0) && (a[lo] > mid))
                    ++lo;

                /* find an element that is smaller than or equal to
                 * the partition element starting from the right Index.
                 */
                while ((hi > lo0) && (a[hi] < mid))
                    --hi;

                // if the indexes have not crossed, swap
                if (lo <= hi) {
                    swap(a, lo, hi);
                    ++lo;
                    --hi;
                }
            }

            /* If the right index has not reached the left side of array
             * must now sort the left partition.
             */
            if (lo0 < hi)
                quickSortMaxToMin(a, lo0, hi);

            /* If the left index has not reached the right side of array
             * must now sort the right partition.
             */
            if (lo < hi0)
                quickSortMaxToMin(a, lo, hi0);

        }
    }
    /**
     * Used by the quick sort and quick select algorithms.
     */
    private static void swap(final int a[], final int i, final int j) {
        final int T;
        T = a[i];
        a[i] = a[j];
        a[j] = T;
    }
    /**
     * Used by the quick sort and quick select algorithms.
     */
    private static void swap(final double a[], final int i, final int j) {
        final double T;
        T = a[i];
        a[i] = a[j];
        a[j] = T;

    }
}

Related Tutorials