python排序算法之（快速排序）

最新推荐文章于 2024-08-25 23:21:27 发布

PANDATAOTAO

最新推荐文章于 2024-08-25 23:21:27 发布

阅读量200

点赞数

快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 O(n²)，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好，可是这是为什么呢，我也不知道。好在我的强迫症又犯了，查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案：

快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

1. 算法步骤

从数列中挑出一个元素，称为 “基准”（pivot）;
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

2. 动图演示

在这里插入图片描述
代码如下：

3. Python 代码实现

def quickSort(arr, left=None, right=None):
    left = 0 if not isinstance(left,(int, float)) else left
    right = len(arr)-1 if not isinstance(right,(int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
        quickSort(arr, left, partitionIndex-1)
        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
    pivot = left
    index = pivot+1
    i = index
    while  i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index+=1
        i+=1
    swap(arr,pivot,index-1)
    return index-1

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

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

代码如下：

代码如下：

   public static void quickSort(int[] arr, int left, int right) {
       int l = left;// 左下标
       int r = right;// 右下标
       int pivot = arr[(left + right) / 2];// 找到中间的值
       // 将比pivot小的值放在其左边，比pivot大的值放在其右边
       while (l < r) {
           // 在pivot左边寻找，直至找到大于等于pivot的值才退出
           while (arr[l] < pivot) {
               l += 1;// 将l右移一位
           }
           // 在pivot右边寻找，直至找到小于等于pivot的值才退出
           while (arr[r] > pivot) {
               r -= 1;// 将r左移一位
           }
           if (l >= r) {
               // 左右下标重合，寻找完毕，退出循环
               break;
           }
           // 交换元素
           int temp = arr[l];
           arr[l] = arr[r];
           arr[r] = temp;

           //倘若发现值相等的情况，则没有比较的必要，直接移动下标即可

           // 如果交换完后，发现arr[l]==pivot，此时应将r左移一位
           if (arr[l] == pivot) {
               r -= 1;
           }
           // 如果交换完后，发现arr[r]==pivot，此时应将l右移一位
           if (arr[r] == pivot) {
               l += 1;
           }
       }
       // 如果l==r，要把这两个下标错开，否则会出现无限递归，导致栈溢出的情况
       if (l == r) {
           l += 1;
           r -= 1;
       }
       // 向左递归
       if (left < r) {
           quickSort(arr, left, r);
       }
       // 向右递归
       if (right > l) {
           quickSort(arr, l, right);
       }
   }

测试代码：

   public static void main(String[] args) {
       int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
       quickSort(arr, 0, arr.length - 1);
       System.out.println(Arrays.toString(arr));
   }

运行结果：

[2, 3, 4, 5, 15, 19, 26, 27, 36, 44, 38, 46, 47, 48, 50]

快速排序的实现原理很简单，就是将原数组分成两部分，然后以中间值为标准，比它小的就放其左边，比它大的就放其右边，然后在左右两边又以相同的方式继续排序。
所以在代码实现过程中，首先要创建两个移动的变量，一个从最左边开始往右移动，一个从最右边开始往左移动，通过这两个变量来遍历左右两部分的元素。当发现左边有大于中间数的元素，右边有小于中间数的元素，此时就进行交换。当两个变量重合也就是相等的时候遍历结束，然后左右两部分作递归处理。