Python 仅对2个元素进行快速排序

在“Grokking算法”中，作者针对快速排序实现的基本情况给出了以下代码：

def quicksort(array):
  if len(array) < 2:
    # base case, arrays with 0 or 1 element are already "sorted"
    return array

def快速排序（数组）：
如果len（数组）<2：
#基本情况下，具有0或1个元素的数组已“排序”
返回数组

然后写道“让我们看看更大的数组。有两个元素的数组也很容易排序-检查第一个元素是否小于第二个元素，如果不是，则交换它们。”

过了一会儿，通过一个示例，他写道“好吧，快速排序基本用例已经知道如何对两个元素的数组进行排序。”

我看不出这是怎么回事。是不是少了一步？当然，代码是有效的，但我看不到算法中显式处理2元素列表的部分，那么2元素列表如何排序呢？即，“检查第一个元素是否小于第二个元素，如果不是，则交换它们”的逻辑在哪里

完整算法如下所示：

def quicksort(array):
  if len(array) < 2:
    # base case, arrays with 0 or 1 element are already "sorted"
    return array
  else:
    # recursive case
    pivot = array[0]
    # sub-array of all the elements less than the pivot
    less = [i for i in array[1:] if i <= pivot]
    # sub-array of all the elements greater than the pivot
    greater = [i for i in array[1:] if i > pivot]
    return quicksort(less) + [pivot] + quicksort(greater)

print quicksort([10, 5, 2, 3])

def快速排序（数组）：
如果len（数组）<2：
#基本情况下，具有0或1个元素的数组已“排序”
返回数组
其他：
#递归案例
pivot=数组[0]
#小于轴的所有元素的子数组
less=[i为数组中的i[1:]如果我旋转]
返回快速排序（较小）+[pivot]+快速排序（较大）
打印快速排序（[10,5,2,3]）

根据注释，包含0或1个元素的数组已经“排序”

类似地，这也适用于按顺序排列的元素

[1, 2]
pivot = array[0] # pivot = 1
less = [i for i in array[1:] if i <= pivot] # less = []
greater = [i for i in array[1:] if i > pivot]  # greater = [2]
return quicksort(less) + [pivot] + quicksort(greater)
return [] + [1] + [2]
return [1, 2]

[1,2]
pivot=数组[0]#pivot=1
less=[i为数组中的i[1:]如果我旋转]#更大=[2]
返回快速排序（较小）+[pivot]+快速排序（较大）
返回[]+[1]+[2]
返回[1,2]

您应该看看

#递归案例

：

# recursive case
pivot = array[0]
# sub-array of all the elements less than the pivot
less = [i for i in array[1:] if i <= pivot]
# sub-array of all the elements greater than the pivot
greater = [i for i in array[1:] if i > pivot]
return quicksort(less) + [pivot] + quicksort(greater)

#递归情况
pivot=数组[0]
#小于轴的所有元素的子数组
less=[i为数组中的i[1:]如果我旋转]
返回快速排序（较小）+[pivot]+快速排序（较大）

如果有两个元素，

less

或

greater

将是一个空列表，另一个（非空）将连接到右侧左侧的第一个元素（轴），具体取决于其大小

---

顺便说一句，快速排序算法对非常短的数组不起作用，通常的做法是使用更简单的方法，例如，如果元素的数量小于（比如）五个，则使用气泡排序。

它位于

less=…

表达式中。注意

如果它是这么说的，那么你是对的，这是误导。双元素列表不是此代码中的基本情况。这是递归案例的一部分。
return less + [pivot] + greater
return [1] +  [2]  + []
return [1, 2]

[1, 2]
pivot = array[0] # pivot = 1
less = [i for i in array[1:] if i <= pivot] # less = []
greater = [i for i in array[1:] if i > pivot]  # greater = [2]
return quicksort(less) + [pivot] + quicksort(greater)
return [] + [1] + [2]
return [1, 2]

# recursive case
pivot = array[0]
# sub-array of all the elements less than the pivot
less = [i for i in array[1:] if i <= pivot]
# sub-array of all the elements greater than the pivot
greater = [i for i in array[1:] if i > pivot]
return quicksort(less) + [pivot] + quicksort(greater)