让我们首先为三个数字实现中位数三，所以是一个独立的函数。我们可以通过对三个元素的列表进行排序来做到这一点，然后返回第二个元素，例如：

def median_of_three(a, b, c):
    return sorted([a, b, c])[1]

现在对于范围low… high（包含low，排除high），我们应该确定我们应该构造三个中位数的元素是什么：

1. 第一个元素：L[low]，
2. 最后一个元素L[High-1]，和
3. 中间元素（如果有两个这样的元素，取第一个）L[（low High-1）//2]。

所以现在我们只需要将分区函数修补到：

def Partition(L, low, high, ascending = True):
    print('Quicksort, Parameter L:')
    print(L)
    result = 0 
    pivot = median_of_three(L[low], L[(low+high-1)//2], L[high-1])
    i = low + 1  
    for j in range(low + 1, high, 1): 
        result += 1
        if (ascending and L[j] < pivot) or (not ascending and L[j] > pivot):
            L[i], L[j] = L[j], L[i]  
            i += 1  
    L[low], L[i-1] = L[i-1], L[low] 
    return i - 1, result

编辑：确定三个元素的中位数。

三个元素的中位数是位于另外两个值中间的元素。所以在casea

所以我们需要确定元素的顺序，这样我们就可以确定中间的元素。比如：

def median_of_three(a, b, c):
    if a <= b and b <= c:
        return b
    if c <= b and b <= a:
        return b
    if a <= c and c <= b:
        return c
    if b <= c and c <= a:
        return c
    return a

所以现在我们已经定义了三个中位数和四个if情况。

EDIT2：这仍然存在一个问题。在执行透视后，您将元素L[i-1]与原始代码中的L[low]交换（透视的位置）。但这当然不再起作用：因为现在透视可以位于三个维度中的任何一个。因此，我们需要使median_of_three（…）更智能：它不仅应该返回透视元素，还应该返回该透视的位置：

def median_of_three(L, low, high):
    mid = (low+high-1)//2
    a = L[low]
    b = L[mid]
    c = L[high-1]
    if a <= b <= c:
        return b, mid
    if c <= b <= a:
        return b, mid
    if a <= c <= b:
        return c, high-1
    if b <= c <= a:
        return c, high-1
    return a, low

现在我们可以解决这个问题：

def Partition(L, low, high, ascending = True):
    print('Quicksort, Parameter L:')
    print(L)
    result = 0 
    pivot, pidx = median_of_three(L, low, high)
    i = low + (low == pidx)
    for j in range(low, high, 1):
        if j == pidx: continue
        result += 1
        if (ascending and L[j] < pivot) or (not ascending and L[j] > pivot):
            L[i], L[j] = L[j], L[i]  
            i += 1 + (i+1 == pidx)
    L[pidx], L[i-1] = L[i-1], L[pidx] 
    return i - 1, result

编辑3：清理它。

虽然上面看起来可行，但它相当复杂：我们需要让i和j“跳过”枢轴的位置。

如果我们首先将枢轴移动到子列表的前面（因此移动到low索引），可能会更简单：

def Partition(L, low, high, ascending = True):
    print('Quicksort, Parameter L:')
    print(L)
    result = 0 
    pivot, pidx = median_of_three(L, low, high)
    L[low], L[pidx] = L[pidx], L[low]
    i = low + 1
    for j in range(low+1, high, 1):
        result += 1
        if (ascending and L[j] < pivot) or (not ascending and L[j] > pivot):
            L[i], L[j] = L[j], L[i]  
            i += 1
    L[low], L[i-1] = L[i-1], L[low] 
    return i - 1, result