Java Quick Sort quickSort( float[] array, int[] index, int left, int right)

Description

Implements quicksort according to Manber's "Introduction to Algorithms".

License

Open Source License

Parameter

Parameter	Description
array	the array of doubles to be sorted
index	the index into the array of doubles
left	the first index of the subset to be sorted
right	the last index of the subset to be sorted

Declaration

private static void quickSort( float[] array,  int[] index, int left, int right) 

Method Source Code

//package com.java2s;
/*//  ww w.  j av  a2 s  .  c  om
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

public class Main {
    /**
     * Implements quicksort according to Manber's "Introduction to
     * Algorithms".
     *
     * @param array the array of doubles to be sorted
     * @param index the index into the array of doubles
     * @param left the first index of the subset to be sorted
     * @param right the last index of the subset to be sorted
     */
    //@ requires 0 <= first && first <= right && right < array.length;
    //@ requires (\forall int i; 0 <= i && i < index.length; 0 <= index[i] && index[i] < array.length);
    //@ requires array != index;
    //  assignable index;
    private static void quickSort(/*@non_null@*/ float[] array, /*@non_null@*/ int[] index, int left, int right) {

        if (left < right) {
            int middle = partition(array, index, left, right);
            quickSort(array, index, left, middle);
            quickSort(array, index, middle + 1, right);
        }
    }

    /**
     * Partitions the instances around a pivot. Used by quicksort and
     * kthSmallestValue.
     *
     * @param array the array of doubles to be sorted
     * @param index the index into the array of doubles
     * @param l the first index of the subset 
     * @param r the last index of the subset 
     *
     * @return the index of the middle element
     */
    private static int partition(float[] array, int[] index, int l, int r) {

        double pivot = array[index[(l + r) / 2]];
        int help;

        while (l < r) {
            while ((array[index[l]] < pivot) && (l < r)) {
                l++;
            }
            while ((array[index[r]] > pivot) && (l < r)) {
                r--;
            }
            if (l < r) {
                help = index[l];
                index[l] = index[r];
                index[r] = help;
                l++;
                r--;
            }
        }
        if ((l == r) && (array[index[r]] > pivot)) {
            r--;
        }

        return r;
    }
}

Related

1. quickSort( double[] array, int[] index, int left, int right)
2. quickSort( double[] array, int[] index, int left, int right)
3. quicksort(Comparable[] a)
4. quicksort(double lista1[], int lista2[], int izq, int der)
5. quickSort(double[] array, int low, int high)
6. quickSort(double[] array, int[] idx, int from, int to)