在实现快速排序时，您必须做的一件事就是选择一个枢轴。但是当我看下面这样的伪代码时，我不清楚我应该如何选择枢轴。列表的第一个元素？还有什么？
function quicksort(array)
var list less, greater
if length(array) ≤ 1
return array
select and remove a pivot value pivot from array
for each x in array
if x ≤ pivot then append x to less
else append x to greater
return concatenate(quicksort(less), pivot, quicksort(greater))
有人可以帮我理解选择支点的概念，以及不同的场景是否需要不同的策略。
选择随机枢轴可以最大限度地减少遇到最坏情况 O(n 2 ) 性能的机会（总是选择第一个或最后一个会导致接近排序或接近反向排序数据的最坏情况性能）。在大多数情况下，选择中间元素也是可以接受的。
此外，如果您自己实现这一点，则存在就地工作的算法版本（即，无需创建两个新列表然后将它们连接起来）。
这取决于您的要求。随机选择一个支点会使创建产生 O(N^2) 性能的数据集变得更加困难。“三个中位数”（第一个、最后一个、中间）也是一种避免问题的方法。不过，请注意比较的相对表现；如果您的比较代价高昂，那么 Mo3 会进行比随机选择（单个枢轴值）更多的比较。比较数据库记录的成本可能很高。
更新：将评论纳入答案。
mdkess断言：
“3 的中位数”不是第一个最后一个中间值。选择三个随机索引，并取其中间值。关键是要确保您对枢轴的选择不是确定性的——如果是，则可以很容易地生成最坏情况的数据。
我对此作出回应：
P Kirschenhofer、H Prodinger、C Martínez 对Hoare 的三分中位数查找算法的分析（1997 年）支持您的论点（“三分中位数”是三个随机项）。
portal.acm.org 上有一篇文章描述了Hannu Erkiö的“The Worst Case Permutation for Median-of-Three Quicksort”，发表在 The Computer Journal，第 27 卷，第 3 期，1984 年。[更新 2012-02- 26：得到文章的文字。第 2 节“算法”开始：“通过使用 A[L:R] 的第一个、中间和最后一个元素的中值，可以在大多数实际情况下实现有效的划分为大小相当的部分。'因此，它正在讨论第一个中间最后一个 Mo3 方法。]
另一篇有趣的短文是由 MD McIlroy 撰写的，“A Killer Adversary for Quicksort”，发表在 Software-Practice and Experience, Vol. 上。29（0），1-4（0 1999）。它解释了如何使几乎所有快速排序的行为都呈二次方。
AT&T 贝尔实验室技术杂志，1984 年 10 月“构建工作排序例程的理论与实践”指出，“Hoare 建议围绕几条随机选择的行的中值进行分区。Sedgewick [...] 建议选择第一个 [. ..] 最后 [...] 和中间”。这表明文献中已知两种用于“三中位数”的技术。（2014 年 11 月 23 日更新：这篇文章似乎可以从IEEE Xplore或Wiley获得——如果你有会员资格或准备付费的话。）
JL Bentley 和 MD McIlroy 于 1993 年 11 月在 Software Practice and Experience 第 23(11) 卷中发表的“Engineering a Sort Function”对这些问题进行了广泛的讨论，他们选择了一种自适应分区算法，部分基于数据集的大小。有很多关于各种方法的权衡的讨论。
谷歌搜索“三中位数”非常适合进一步跟踪。
谢谢你提供的详情; 我以前只遇到过确定性的“三中位数”。
呵呵，我刚教过这门课。
有几种选择。
简单：选择范围的第一个或最后一个元素。（对部分排序的输入不好）更好：选择范围中间的项目。（对部分排序的输入更好）
但是，选择任意元素存在将大小为 n 的数组划分为大小为 1 和 n-1 的两个数组的风险。如果你经常这样做，你的快速排序就有变成 O(n^2) 的风险。
我看到的一个改进是选择中位数（第一、最后、中间）；在最坏的情况下，它仍然可以达到 O(n^2)，但从概率上讲，这是一种罕见的情况。
对于大多数数据，选择第一个或最后一个就足够了。但是，如果你发现你经常遇到最坏的情况（部分排序的输入），第一个选择是选择中心值（对于部分排序的数据来说，这是一个统计上很好的支点）。
如果您仍然遇到问题，请走中间路线。
永远不要选择一个固定的支点——这可能会被攻击以利用您算法的最坏情况 O(n 2 ) 运行时，这只是自找麻烦。快速排序的最坏情况运行时发生在分区结果为一个包含 1 个元素的数组和一个包含 n-1 个元素的数组时。假设您选择第一个元素作为分区。如果有人向您的算法提供一个按降序排列的数组，那么您的第一个枢轴将是最大的，因此数组中的其他所有内容都将移动到它的左侧。然后当你递归时，第一个元素将再次成为最大的，所以你再一次把所有的东西都放在它的左边，依此类推。
更好的技术是median-of-3 方法，您可以在其中随机选择三个元素，然后选择中间值。你知道你选择的元素不会是第一个或最后一个，而且，根据中心极限定理，中间元素的分布将是正常的，这意味着你会倾向于中间（因此, nlog(n) 时间)。
如果您绝对想保证算法的 O(nlog(n)) 运行时间，那么用于查找数组中值的columns-of-5 方法在 O(n) 时间内运行，这意味着快速排序中的递归方程最坏的情况是：
T(n) = O(n) (find the median) + O(n) (partition) + 2T(n/2) (recurse left and right)
根据主定理，这是 O(nlog(n))。然而，常数因子会很大，如果最坏情况下的性能是您最关心的问题，请改用合并排序，它平均只比快速排序慢一点，并保证 O(nlog(n)) 时间（并且将比这个蹩脚的中位数快速排序要快得多）。
不要试图变得太聪明并结合枢轴策略。如果您通过选择第一个、最后一个和中间随机索引的中值来将 3 的中值与随机枢轴相结合，那么您仍然容易受到许多发送 3 二次方中值的分布的影响（所以它实际上比普通随机枢轴）
例如，管风琴分布 (1,2,3...N/2..3,2,1) 第一个和最后一个都为 1，随机索引将是大于 1 的某个数字，取中位数为 1 (第一个或最后一个），你会得到一个非常不平衡的分区。
这样做更容易将快速排序分为三个部分
它只比一个长函数效率低一点，但更容易理解。
代码如下：
/* This selects what the data type in the array to be sorted is */
#define DATATYPE long
/* This is the swap function .. your job is to swap data in x & y .. how depends on
data type .. the example works for normal numerical data types .. like long I chose
above */
void swap (DATATYPE *x, DATATYPE *y){
DATATYPE Temp;
Temp = *x; // Hold current x value
*x = *y; // Transfer y to x
*y = Temp; // Set y to the held old x value
};
/* This is the partition code */
int partition (DATATYPE list[], int l, int h){
int i;
int p; // pivot element index
int firsthigh; // divider position for pivot element
// Random pivot example shown for median p = (l+h)/2 would be used
p = l + (short)(rand() % (int)(h - l + 1)); // Random partition point
swap(&list[p], &list[h]); // Swap the values
firsthigh = l; // Hold first high value
for (i = l; i < h; i++)
if(list[i] < list[h]) { // Value at i is less than h
swap(&list[i], &list[firsthigh]); // So swap the value
firsthigh++; // Incement first high
}
swap(&list[h], &list[firsthigh]); // Swap h and first high values
return(firsthigh); // Return first high
};
/* Finally the body sort */
void quicksort(DATATYPE list[], int l, int h){
int p; // index of partition
if ((h - l) > 0) {
p = partition(list, l, h); // Partition list
quicksort(list, l, p - 1); // Sort lower partion
quicksort(list, p + 1, h); // Sort upper partition
};
};
如果您正在对一个可随机访问的集合（如数组）进行排序，通常最好选择物理中间项。有了这个，如果数组都准备好排序（或几乎排序），两个分区将接近偶数，您将获得最佳速度。
如果您正在对仅具有线性访问权限的内容（如链表）进行排序，那么最好选择第一个项目，因为它是访问速度最快的项目。然而，在这里，如果列表已经排序，那么你就搞砸了——一个分区将始终为空，而另一个分区拥有一切，从而产生了最糟糕的情况。
然而，对于链表，选择除第一个之外的任何内容只会让事情变得更糟。它选择列出列表中的中间项目，您必须在每个分区步骤中逐步完成它 - 添加一个 O(N/2) 操作，该操作完成 logN 次，总时间为 O(1.5 N *log N)那就是如果我们在开始之前就知道列表有多长——通常我们不知道，所以我们必须一路走过去数一数，然后走一半找到中间，然后一步一步走第三次做实际分区：O(2.5N * log N)
这完全取决于您的数据是如何排序的。如果您认为它将是伪随机的，那么您最好的选择是选择随机选项或选择中间选项。
理想情况下，枢轴应该是整个数组的中间值。这将减少获得最坏情况性能的机会。
快速排序的复杂性随着枢轴值的选择而变化很大。例如，如果您总是选择第一个元素作为枢轴，算法的复杂性会变得像 O(n^2) 一样糟糕。这是选择枢轴元素的一种聪明方法 - 1. 选择数组的第一个、中间、最后一个元素。2. 比较这三个数，找出大于一且小于其他数的数，即中位数。3. 将此元素作为枢轴元素。
通过这种方法选择枢轴将数组分成近两半，因此复杂性降低到 O(nlog(n))。
平均而言，中位数为 3 对较小的 n 有利。对于较大的 n，中位数为 5 会更好一些。第九个，即“三个中值的三个中值”对于非常大的 n 甚至更好。
随着 n 的增加，采样越高，您获得的效果就越好，但随着样本的增加，改进会显着减慢。而且您会产生采样和分类样本的开销。
我建议使用中间指数，因为它可以很容易地计算出来。
您可以通过四舍五入（array.length / 2）来计算它。
在真正优化的实现中，选择枢轴的方法应该取决于数组大小——对于大数组，花更多时间选择一个好的枢轴是值得的。如果不进行全面分析，我猜“O(log(n)) 元素的中间”是一个好的开始，并且这具有不需要任何额外内存的额外好处：在较大的分区上使用尾调用并在-位置分区，我们几乎在算法的每个阶段都使用相同的 O(log(n)) 额外内存。