快速排序的两种代码实现

      快速排序实现的重点在于数组的拆分，通常我们将数组的第一个元素定义为比较元素，然后将数组中小于比较元素的数放到左边，将大于比较元素的放到右边，

      这样我们就将数组拆分成了左右两部分：小于比较元素的数组；大于比较元素的数组。我们再对这两个数组进行同样的拆分，直到拆分到不能再拆分，数组就自然而然地以升序排列了。

 

不难看出，拆分算法是整个快速排序中的核心，快速排序拥有非常多的拆分方式，在本篇文章中我们介绍其中的两种，我个人将它称作：单指针遍历法与双指针遍历法（在下文中用英文单词split和partition称呼）

     split算法使用一个单向的指针来对数组进行遍历，首先将数组首元素设置为比较元素，然后将第二个开始的元素依次与比较元素比较，如果大于比较元素则跳过，如果小于比较元素，则将其与前面较大的元素进行交换，将数组中所有元素交换完毕后，再将比较元素放到中间位置。

      

//快速排序split实现方法
public class T1 {
    public static void main(String args[])
    {
        int a[] = {5,7,1,6,4,8,3,2};
        quickSort(a, 0, a.length-1);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println();
    }
    
    //交换方法
    public static void swap(int a[], int i, int j)
    {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    
    //划分数组
    public static int split(int a[], int low, int high)
    {
        int i = low;    //i指向比较元素的期望位置
        int x = a[low];    //将该组的第一个元素作为比较元素
        //从第二个元素开始，若当前元素大于比较元素，将其跳过
        for(int j = low+1; j <= high; j++)
            //若找到了小于比较元素的元素，将其与前面较大的元素进行交换
            if(a[j] <= x)
            {
                i++;
                if(i != j)
                    swap(a, i, j);
                
            }
        swap(a, i, low);     //将比较元素交换到正确的位置上
        return i;    //返回比较元素的位置
    }
    
    public static void quickSort(int a[], int low, int high)
    {
        if(low < high)
        {
            int i = split(a, low, high);    //划分并获取比较元素的位置
            quickSort(a, low, i-1);     //对比较元素左边的数组进行排序
            quickSort(a, i+1, high);     //对比较元素右边的数字进行排序
        }
    }
}

partition算法使用头尾两个方向相反的指针进行遍历，先将数组第一个元素设置为比较元素，头指针从左至右找到第一个大于比较元素的数，尾指针从右至左找到第一个小于比较元素的数，全部交换完毕后将比较元素放到中间位置。

 

//快速排序partition实现方法
public class T2 {
    public static void main(String args[])
    {
        int a[] = {5,7,1,6,4,8,3,2};
        quicksort(a, 0, a.length-1);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println();
    }
    
    public static void swap(int a[], int i, int j)
    {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    
    //划分数组
    public static int partition(int a[], int low, int high)
    {
        int x = a[low];    //将该数组第一个元素设置为比较元素
        int i=low;
        int j=high;
        while(i < j)
        {
            while(i<j && a[j] >= x)
                j--;     //从右至左找到第一个小于比较元素的数
            while(i<j && a[i] <= x)
                i++;     //从左至右找到第一个大于比较元素的数
            /*需要注意的是，这里的j--与i++的顺序不可以调换！
             *如果调换了顺序，i会走过头，以至于将后面较大的元素交换到数组开头*/
            
            //将大数与小数交换
            if(i!=j)
                swap(a, i, j);
        }
        swap(a, i, low);    //将比较元素交换到期望位置
        return i;     //返回比较元素的位置
    }
    
    public static void quicksort(int a[], int low, int high)
    {
        if(low < high)
        {
            int i = partition(a, low, high);    //划分数组并获取比较元素的位置
            quicksort(a, low, i-1);     //对比较元素左边进行排序
            quicksort(a, i+1, high);     //对比较元素右边进行排序
        }
    }
}