Java--快速排序

**快速排序(Quicksort)是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。**

输入为：

public static void main(String[] args) {
        // TODO Auto-generated method stub
            int[] array ={12,3,43,5,65,7};
            Quick(array,0,array.length-1);//递归实现
            System.out.println(Arrays.toString(array));
        }

输出为：

我们来走一遍代码：

public static int partion(int[] array,int low,int high){//一次快排，将一个数的位置确定
            int tmp = array[low];

    while(low < high){//当low和high没有交叉之前

                while(low < high && array[high] >= tmp){//从后遍历，若该元素比tmp大
                    --high;
                }
                if(low >= high){//若相交，break出来
                    break;
                }else{//从后遍历，若该元素比tmp小
                    array[low] = array[high];//将array[high] 给 array[low]
                }

                while(low < high && array[low] < tmp){//从前遍历，若该元素比tmp小
                    ++low;
                }
                if(low >= high){//若相交，break出来
                    break;
                }else{
                    array[high]=array[low];//将array[low] 给 array[high]
                }
            }
            array[low]=tmp;//low 不小于 high 的时候，tmp 给array[low]
            return low;//此时返回值为Quick()方法中的基准 par
        }

以上是一次快排；
接下来，进行递归快排：

public static void Quick(int array[],int start,int end){
            int par = partion(array,start,end);//将partion()方法的返回值low给par:基准的位置
            if(par>start+1){//基准左边进行快排
                partion(array,start,par-1);
            }
            if(par<end-1){//基准右边进行快排
                partion(array,par+1,end);
            }           
        }

递归快排的方法还可以被非递归代替，起到同样的效果：

public static void Quicksort(int[] array){
            int[] stack = new int [array.length];//new 一个栈
            int top = 0;
            int low = 0;//对 low 初始化
            int high = array.length-1;//对 high 初始化
            int par = partion(array,low,high);//基准
            //入栈
            if(par>low+1){//左
                stack[top++]=low;
                stack[top++]=par-1;
            }
            if(par<high-1){//右
                stack[top++]=par+1;
                stack[top++]=high;
            }
            //出栈
            while(top>0){//top > 0 时
                high = stack[--top];
                low = stack[--top];
                par = partion(array,low,high);
                if(par>low+1){
                    stack[top++]=low;
                    stack[top++]= par-1;
                }
                if(par<high-1){
                    stack[top++]=par+1;
                    stack[top++]= high;
                }
            }
        }

输入：

public static void main(String[] args) {
        // TODO Auto-generated method stub
            int[] array ={12,3,43,5,65,7};
            Quicksort(array);//非递归实现
            System.out.println(Arrays.toString(array));
        }
    }

输出结果：