快速排序

package com.study.sort;

/**
 * 快速排序O（nlogn）效率高于线性排序（插入，选择冒泡）
 * 1.在待排序的N个记录中任取一个元素(通常取第一个记录)作为基准，称为基准记录；
 * 2.定义两个索引 left 和 right 分别表示“首索引” 和 “尾索引”，key 表示“基准值”；
 * 3.首先，尾索引向前扫描，直到找到比基准值小的记录(left != righ)，并替换首索引对应的值；
 * 4.然后，首索引向后扫描，直到找到比基准值大于的记录(left != righ)，并替换尾索引对应的值；
 * 5.若在扫描过程中首索引等于尾索引(left = right),则一趟排序结束；将基准值(key)替换首索引所对应的值；
 * 6.再进行下一趟排序时，待排序列被分成两个区:[0,left-1],[righ+1,end]
 * 7.对每一个分区重复步骤2~6，直到所有分区中的记录都有序，排序成功。
 */
public class QuickSort extends BaseSort{
    public static void main(String[] args) {
        isPrint=true;
        int len=10;
        int []array=genArray(len);
        p(array);
        System.out.println("quickSortStart:");
        long start=System.currentTimeMillis();

        quickSort(array,0,array.length-1);

        System.out.println("quickSortEnd==len:"+array.length+"============Cost:"+(System.currentTimeMillis()-start)+"\n\n");
    }

    /**
     *
     * 51  15  27  47  14  61  87  60  80  57
     * quickSortStart:
     * key:51
     * 14  15  27  47  51  61  87  60  80  57
     * key:14
     * 14  15  27  47  51  61  87  60  80  57
     * key:15
     * 14  15  27  47  51  61  87  60  80  57
     * key:27
     * 14  15  27  47  51  61  87  60  80  57
     * key:61
     * 14  15  27  47  51  57  60  61  80  87
     * key:57
     * 14  15  27  47  51  57  60  61  80  87
     * key:80
     * 14  15  27  47  51  57  60  61  80  87
     * quickSortEnd==len:10============Cost:4
     *
     * @param array 数组是同一个数组，使用leftIndex,rightIndex控制每次递归处理的范围
     * @param leftIndex
     * @param rightIndex
     */
    public static  void quickSort(int array[],int leftIndex ,int rightIndex){
        if(array==null|| array.length==0){
            return ;
        }
        if(leftIndex>=rightIndex){
            return;
        }
        int left=leftIndex;
        int right=rightIndex;

        int key=array[left];  //待排序的第一个元素作为基准值
        System.out.println("key:"+key);
        //从左右两边交替扫描，直到left = right
        while (left<right){
            while(right>left&&array[right]>=key){//此处是>=防止相等的数无法继续移动
                //从右往左扫描，找到第一个比基准值小的元素
                right--;
            }
            array[left]=array[right];
            while (left<right&&array[left]<=key){
                //从左往右扫描，找到第一个比基准值大的元素
                left++;
            }
            array[right]=array[left];
        }
        array[left]=key;
        p(array);
        quickSort(array,leftIndex,left-1);
        quickSort(array,right+1,rightIndex);
    }



}