问题

快速排序，这是一个经典的算法，本文给出几种python的写法，供参考。 特别是python能用一句话实现快速排序。

思路说明

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。 （1） 分治法的基本思想 分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。 （2）快速排序的基本思想 设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：

分解：

在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。 注意： 划分的关键是要求出基准记录所在的位置pivotpos。划分的结果可以简单地表示为(注意pivot=R[pivotpos])： R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys 其中low≤pivotpos≤high。

求解：

通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。

组合：

因为当”求解”步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言，”组合”步骤无须做什么，可看作是空操作。

解决(Python)

  1.   1. #!/usr/bin/env python
  2.     2. #coding:utf-8
  3.     3.   4. #方法1
  4.     5.   6. def quickSort(arr):
  5.     7.     less = []
  6.     8.     pivotList = []
  7.     9.     more = []
  8.     10.     if len(arr) <= 1:
  9.     11.         return arr
  10.     12.     else:
  11.     13.         pivot = arr[0]      #将第一个值做为基准
  12.     14.         for i in arr:
  13.     15.             if i < pivot:
  14.     16.                 less.append(i)
  15.     17.             elif i > pivot:
  16.     18.                 more.append(i)
  17.     19.             else:
  18.     20.                 pivotList.append(i)
  19.     21.   22.         less = quickSort(less)      #得到第一轮分组之后，继续将分组进行下去。
  20.     23.         more = quickSort(more)
  21.     24.   25.         return less + pivotList + more
  22.     26.   27. #方法2
  23.     28. # 分为<, >, = 三种情况，如果分为两种情况的话函数调用次数会增加许多，以后几个好像都有相似的问题
  24.     29. # 如果测试1000个100以内的整数，如果分为<, >=两种情况共调用函数1801次，分为<, >, = 三种情况，共调用函数201次
  25.     30. def qsort(L):
  26.     31.     return (qsort([y for y in L[1:] if y <  L[0]]) + L[:1] + [y for y in L[1:] if y == L[0] + qsort([y for y in L[1:] if y > L[0]])) if len(L) > 1 else L
  27.     32.   33. #方法3
  28.     34. #基本思想同上，只是写法上又有所变化
  29.     35.   36. def qsort(list):
  30.     37.     if not list:
  31.     38.         return []
  32.     39.     else:
  33.     40.         pivot = list[0]
  34.     41.         less = [x for x in list     if x <  pivot]
  35.     42.         more = [x for x in list[1:] if x >= pivot]
  36.     43.         return qsort(less) + [pivot] + qsort(more)
  37.     44.   45. #方法4
  38.     46.   47. from random import *
  39.     48.   49. def qSort(a):
  40.     50.     if len(a) <= 1:
  41.     51.         return a
  42.     52.     else:
  43.     53.         q = choice(a)       #基准的选择不同于前，是从数组中任意选择一个值做为基准
  44.     54.         return qSort([elem for elem in a if elem < q]) + [q] * a.count(q) + qSort([elem for elem in a if elem > q])
  45.     55.   56.   57. #方法5
  46.     58. #这个最狠了，一句话搞定快速排序，瞠目结舌吧。
  47.     59.   60. qs = lambda xs : ( (len(xs) <= 1 and [xs]) or [ qs( [x for x in xs[1:] if x < xs[0]] ) + [xs[0]] + qs( [x for x in xs[1:] if x >= xs[0]] ) ] )[0]
  48.     61.   62.   63. if __name__=="__main__":
  49.     64.     a = [4, 65, 2, -31, 0, 99, 83, 782, 1]
  50.     65.     print quickSort(a)
  51.     66.     print qSort(a)
  52.     67.   68.     print qs(a)

整理人：豆包AI助手