排序算法之快速排序详解(附示例代码)

1.快速排序简介
对于包含n个数的输入数组来说,快速排序是一种最坏情况时间复杂度为O(n的平方)的排序算法.虽然最坏情况时间复杂度很差,但是快速排序通常是实际排序应用中最好的选择.因为他的平均性能非常好,它的期望时间复杂度是O(n lg n),而且其中包含的常数因子非常小.
2.快速排序的原理
快速排序与归并排序已有,也使用分治思想.下面介绍下对一个典型的子数组A[p..r]进行快速排序的三步分治过程:
分解:数组A[p..r]被划分为两个(可能为空)子数组A[p..q-1]和A[q+1..r],使得A[p..q-1]中的每一个元素都小于等于A[q],而A[q]也小于等于A[p..q-1]中的每个元素,其中,计算下标q也是划分过程的一部分.
解决:通过递归调用快速排序,对子数组A[p..q-1]和A[q+1..r]进行排序.
合并:因为子数组都是原址排序的,所以不需要合并操作:数组A[p..r]已经有序.
通俗点讲就是把数组根据一个参照值划分为两部分,左边部分小于等于参照值,右边部分大于等于参照值,然后再不断递归调用该方法,直到数组只有一个元素,就认为其是有序的.注意:划分过程,左边部分和右边部分可以是不均衡的.
3.java代码实现,代码中关键代码都有注释

//将数组排序成满足数组左边比中间值小,右边比中间值大的方法
    int partition(int arr[], int left, int right)
    {
        int i = left, j = right;
        int tmp;
        //定义参照值为数组的中间值
        int pivot = arr[(left + right) / 2];

        while (i <= j) {
            //当arr[i]小于参照值时,符合左边小的原则,不需调换位置,直接跳过,直到找到不满足条件的A[i]时终止该循环
            while (arr[i] < pivot)
                i++;
            //当arr[j]大于参照值时,符合右边大的原则,不需调换位置,直接跳过,直到找到不满足条件的A[j]时终止该循环
            while (arr[j] > pivot)
                j--;
            //i小于j时,完成a[i]和a[j]的交换
            if (i <= j) {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
                i++;
                j--;
            }
        };
        //返回的i就是满足i左边的值比i小.i右边的值比i大
        return i;
    }

    void quickSort(int arr[], int left, int right) {
        int index = partition(arr, left, right);
//        System.out.println("index"+index);
        if (left < index - 1){
            quickSort(arr, left, index - 1);
//            System.out.println(Arrays.toString(arr));
        }

        if (index < right){
            quickSort(arr, index, right);
//            System.out.println(Arrays.toString(arr));
        }
    }

    @Test
    public void testQuickSort(){
        int a[] = {222,5, 2, 4, 6, 1, 3, 11, 9, 10, 8, 7,0};
        quickSort(a,0,a.length - 1);
        System.out.println("最终排序结果"+Arrays.toString(a));
    }

运行结果如下图:

4.C代码实现

void quickSort(int arr[], int left, int right) {
      int i = left, j = right;
      int tmp;
      int pivot = arr[(left + right) / 2];

      /* partition */
      while (i <= j) {
            while (arr[i] < pivot)
                  i++;
            while (arr[j] > pivot)
                  j--;
            if (i <= j) {
                  tmp = arr[i];
                  arr[i] = arr[j];
                  arr[j] = tmp;
                  i++;
                  j--;
            }
      };

      /* recursion */
      if (left < j)
            quickSort(arr, left, j);
      if (i < right)
            quickSort(arr, i, right);
}

5.快速排序的性能分析.
a.最坏情况分析
在最坏情况下,快速排序每一层递归的时间复杂度是n的平方.
特例:当划分非平衡的时候,快速排序的运行时间为n的平方
b.期望运行时间
在输入元素互异的情况下,快速排序算法的期望运行时间为n lg n.
如有疑问请直接在评论提出
不足之处请指正,谢谢!