快速排序

算法思想：

快速排序采用了分治的思想，在对数组进行排序时，首先选取数组中的一个元素作为基准元素，然后将数组中所有小于等于基准元素的元素放在基准元素的左边，而大于基准元素的放在基准元素的右边，然后对基准元素的左右两边的序列采用同样的方式对其进行排序。

代码实现思路：

在代码实现中都是选择第一个元素作为基准元素。

思路1：在白话经典算法系列之六 快速排序 快速搞定中提出的是挖坑填数的方法，即首先用一个变量保存基准元素，此时基准元素的位置就是个坑,然后用一个指针循环的从数组最右往左找到第一个小于基准元素的元素，然后将这个元素填入坑中，同时这个元素的位置处产生一个坑，然年再从左往由用一个指针找到第一个大于基准元素的元素，填入坑中。循环往复，直到两个指针相等，指向同一个位置（）这个位置是个坑，然后将基准元素填入这个坑中。然后递归的对基准元素左右序列进行排序。

思路2：在算法 3：最常用的排序——快速排序中，实现和思路一不一样，首先是用来个指针分别从左往右和从右往左找到第一个大于和小于基准元素的两个元素，然后交换，重复上述操作，直到两个指针指向同一个位置，然后交换这个位置的元素和基准元素。

优化方法：

方法1：对于小数组，使用插入排序，避免递归调用。例如，当if(hi <= lo + M)时，就可以转到插入排序。
方法2：选择一个更好的基准元素。如选取中位数，随机选取基准元素。
方法3：如果数组中含有大量的重复元素，可以采用三向切分。将数组切分为三部分，分别对应于小于、等于和大于切分元素的数组元素。代码参考快速排序及其优化

时间复杂度：

最好和平均情况下，是O(nlogn)；最坏情况下，是O(n2)。

空间复杂度：

递归造成的栈空间的使用。
最好情况，递归的深度为log2n，其空间复杂度也就为O(logn)。
最坏情况，需要进行n‐1递归调用，其空间复杂度为O(n)。这种情况可以通过随机选取基准元素避免。
平均情况，空间复杂度也为O(logn)。

稳定性：

不稳定。
在基准元素和a[lt]交换时可能打乱稳定性。

代码实现：

package sort;

/**
 * @作者：dhc
 * @创建时间：21:44 2018/8/13
 * @排序方法：快速排序
 * @时间复杂度：O(nlogn)
 * @空间复杂度：递归造成的栈空间的使用，最好情况，递归的深度为log2n，其空间复杂度也就为O(logn)，最坏情况，需要进行n‐1递归调用，
 * 其空间复杂度为O(n)，平均情况，空间复杂度也为O(logn)
 * @稳定性：不稳定（在基准元素和a[lt]交换时可能打乱稳定性）
 */
public class QuickSort {
    public static void quickSort(int[] nums,int l, int r){
            if(l < r){
                int base = nums[l];
                int lt = l;
                int rt = r;
                while (lt < rt){
                    //找到一个比基准数小的元素
                    while (lt < rt && nums[rt] >= base ){
                        rt--;
                    }
                    if(lt < rt){
                        nums[lt++] = nums[rt];
                    }
                    while (lt < rt && nums[lt] <= base){
                        lt++;
                    }
                    if(lt < rt){
                        nums[rt--] = nums[lt];
                    }
                }
                nums[lt] = base;
                quickSort(nums,l,lt - 1);
                quickSort(nums,lt + 1,r);
            }
    }
    //交换
    public static void quickSort1(int[] nums,int l, int r){
            if(l >= r){
                return;
            }
            int base = nums[l];
            int lt = l;
            int rt = r;
            while(lt < rt){
                while(lt < rt && nums[rt] >= base){
                    rt--;
                }
                while(lt < rt && nums[lt] <= base){
                    lt++;
                }
                if(lt < rt){
                    int tem = nums[rt];
                    nums[rt] = nums[lt];
                    nums[lt] = tem;
                }
                //在这里之所有不用对lt和rt进行加减操作，是因为上面交换后他们当前对应的元素肯定是小于和大于基准元素的。
            }
            nums[l] = nums[rt];
            nums[rt] = base;
            quickSort1(nums,l,rt-1);
            quickSort1(nums,rt+1,r);

    }

    public static void main(String[] args) {
        int[] nums = new int[]{2,3,4,1,5,6,5,1,32,2};
        quickSort(nums,0,nums.length-1);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+" ");
        }
    }
}

参考链接

维基百科
白话经典算法系列之六 快速排序 快速搞定
算法 3：最常用的排序——快速排序
排序–快速排序及其优化
快速排序及其优化