快速排序思想及实现

    该算法为快速排序算法，从第二个位置也就是索引为1的位置开始存储排序的数据(第1位置不用)，大致思路如下：
    算法调用quickSort(A,p,r)对位于p到r之间的数据进行排序，quickSort首先判断区间[p, r]是否可以排序，如果可以则先调用 partion(A, p, r)产生一个划分q，然后再对[p, q-1]与[q+1, r]这两个区间进行递归调用进行排序。
     算法的重点在于对partion的实现，其大致思路为：[p, r]是要产生划分的区间，令指示器j = p，i在是p之前的一个位置，即i = j-1，最后一个元素key=A[r]则是划分主元，partion按如下过程进行

1. 比较key与A[j]的大小。
2.  如果A[j] < key，说明A[j]应该排在key的左边，于是把i右移一个位置使得i = i + 1，接着交换 i与j两个位置的元素。
3.  该过程一直进行到j = r - 1，然后交换i + 1与r位置处的元素，并返回i+1作为划分元素的位置;此时[p, i]之间的元素小于等于i+1处的元素，[i + 2， r]处的则大于等 于i + 1处的元素。

 

package com.zfang.testapp.process.blue;


import java.util.Random;




/**
 * 说明：该算法为快速排序算法，从第二个位置也就是索引为1的位置开始存储排序的数据(第1位置不用)，大致
 * 思路如下：
 * 算法调用quickSort(A,p,r)对位于p到r之间的数据进行排序，quickSort首先判断区间[p, r]是否
 * 可以排序，如果可以则先调用 partion(A, p, r)产生一个划分q，然后再对[p, q-1]与[q+1, r]这
 * 两个区间进行递归调用进行排序。
 *   算法的重点在于对partion的实现，其大致思路为：[p, r]是要产生划分的
 * 区间，令指示器j = p，i在是p之前的一个位置，即i = j-1，最后一个元素key=A[r]则是划分主元，
 * partion按如下过程进行：
 * 1 比较key与A[j]的大小。
 * 2 如果A[j] < key，说明A[j]应该排在key的左边，于是把i右移一个位置使得i = i + 1，接着交换
 * i与j两个位置的元素。
 * 3 该过程一直进行到j = r - 1，然后交换i + 1与r位置处的元素，并返回i+1作为划分元素的位置;
 * 此时[p, i]之间的元素小于等于i+1处的元素，[i + 2， r]处的则大于等 于i + 1处的元素。
 * @author
 *
 */
class Sort_QuickSort {


    
    private int [] arrayA = null;
    private int length = 1000 + 1;//1000个数字，第一个位置不用

    public static void main(String[] args) {
        new Sort_QuickSort().quickSort();
    }

    public void quickSort() {
        getData();
        System.out.println("quick sort begin");
        long now = System.nanoTime();
        doSort(arrayA);
        long last = System.nanoTime() - now;
        System.out.println("quick sort end, duration = " + last);
        printArray(arrayA);
    }


    private void getData() {
        arrayA = new int[length];
        Random random = new Random(System.currentTimeMillis());
        for (int i = 0; i < length; i++) {
            arrayA[i] = random.nextInt(1000) + 1;
        }
    }

    private void doSort(int[] array) {
        quickSort(array, 1, array.length - 1);
    }

    private void quickSort(int[] array, int start, int end) {
        if (start < end) {
            int q = partion(array, start, end);
            quickSort(array, start, q - 1);
            quickSort(array, q + 1, end);;
        }
    }

    private int partion(int[] array, int p, int r) {
        int i = p - 1;
        int key = array[r];
        for (int j = p; j <r; j++) {
            if (array[j] <= key) {
                i++;
                exchangeValue(array, i, j);
            }
        }
        exchangeValue(array, i + 1, r);
        return i + 1;
    }


    private void exchangeValue(int array[], int indexA, int indexB) {
        int temp = array[indexB];
        array[indexB] = array[indexA];
        array[indexA] = temp;
    }

    private void printArray(int array[]) {
        for (int i = 1; i < array.length; i++) {
            System.out.print("i = " + i + ", value = " + array[i] + "\n");
        }
    }
}