快排序

快排序与归并排序类似，都用到了分治加递归。

快排序的基本思路：

1.从数组a中选取一个枢纽元flag。
2.然后调整数组，使得flag左边的值全是小于flag的，右边的值都是大于flag的。
3.递归flag左边和右边。

快排序的步骤：

1.选枢纽元
2.分割

1.选取枢纽元
随机从数组选取枢纽元的方法虽然可行，但是对于预排序的输入这种做法效果很差。
这里，我们选择数组的开头，中间，以及结尾，三个值的中值作为枢纽元。

代码：

public int getmid(int[] a, int left, int right)
    {
        int midpos = (left+right)/2;
        //在找的同时将这三个值排好位置
        if(a[right]<a[left])
            swap(a,left,right);
        if(a[midpos]<a[left])
            swap(a,midpos,left);
        if(a[midpos]<a[right])
            swap(a,midpos,right);

        //将枢纽元置于数组末尾
        swap(a,midpos,right);
        return a[right];
    }

2.分割
此处，我们设两个指针i和j，i指向数组的初始处，j指向数组倒数第二个数，然后i++一直到a[i]的值大于flag，j–一直到a[j]的值小于flag，并且交换a[i]和a[j]（对于等于的情况则是不处理）。

代码：

    public void quickSort(int[] a, int left , int right)
    {
            int k = getmid(a,left,right);
            int i=left, j = right-1;
            for(;;)
            {
                while(a[++i]<k){};
                while(a[--j]>k){};
                if(i<j)
                    swap(a,i,j);
                else
                    break;
            }
            swap(a,i,right);

            quickSort(a,left,i-1);
            quickSort(a,i+1,right);
    }

对于小数组来说，直接插入排序比快排序效率高，所以这里我们设计了一个if判断，当长度小于limit（此处为10）时候转而使用插入排序。

代码：

    public void quickSort(int[] a, int left , int right)
    {
        if(left+limit<=right)
        {
            int k = getmid(a,left,right);
            int i=left, j = right-1;
            for(;;)
            {
                while(a[++i]<k){};
                while(a[--j]>k){};
                if(i<j)
                    swap(a,i,j);
                else
                    break;
            }
            swap(a,i,right);

            quickSort(a,left,i-1);
            quickSort(a,i+1,right);
        }
        else
            insertSort(a,left,right);
    }

总的测试代码：

package quicksort;

public class quicksort {
    private static int limit = 10;
    public void quickSort(int[] a)
    {
        quickSort(a,0,a.length-1);
    }
    public int getmid(int[] a, int left, int right)
    {
        int midpos = (left+right)/2;
        //在找的同时将这三个值排好位置
        if(a[right]<a[left])
            swap(a,left,right);
        if(a[midpos]<a[left])
            swap(a,midpos,left);
        if(a[midpos]<a[right])
            swap(a,midpos,right);

        //将枢纽元置于数组末尾
        swap(a,midpos,right);
        return a[right];
    }
    public void swap(int[] a, int left , int right)
    {
        int temp = a[left];
        a[left] = a[right];
        a[right] = temp;
    }
    public void quickSort(int[] a, int left , int right)
    {
        if(left+limit<=right)
        {
            int k = getmid(a,left,right);
            int i=left, j = right-1;
            for(;;)
            {
                while(a[++i]<k){};
                while(a[--j]>k){};
                if(i<j)
                    swap(a,i,j);
                else
                    break;
            }
            swap(a,i,right);

            quickSort(a,left,i-1);
            quickSort(a,i+1,right);
        }
        else
            insertSort(a,left,right);
    }
    public void insertSort(int[] a, int left, int right)
    {
        for(int i=left+1;i<=right;i++)
        {
            int j;
            int temp = a[i];
            for(j=i-1;j>=left&&temp<a[j];j--)
            {
                a[j+1] = a[j];
            }
            a[j+1] = temp;
        }
    }
    public static void main(String[] args)
    {
        quicksort m = new quicksort();
        int[] a = {9,7,6,5,4,3,21,1};
        for(int temp: a)
            System.out.print(temp);
        System.out.println();
        m.quickSort(a);
        for(int temp: a)
            System.out.print(temp);
        System.out.println();

    }
}

输出：