在（17）中我们对排序算法进行了简单的分析，并得出了两个结论：
1.只进行相邻元素交换的排序算法时间复杂度为O(N2)
2.要想时间复杂度低于O(N2)，算法必须进行远距离的元素交换
而今天，我们将对排序算法进行进一步的分析，这一次的分析将针对“使用比较进行排序”的排序算法，到目前为止我们所讨论过的所有排序算法都在此范畴内。所谓“使用比较进行排序”，就是指这个算法实现排序靠的就是让元素互相比较，比如插入排序的元素与前一个元素比较，若反序则交换位置，再比如快速排序小于枢纽的元素分为一组，大于枢纽的元素分为另一组。它们都是依靠“比较”来完成排序工作。
要对使用比较进行排序的算法进行分析，我们首先要引入一个概念：决策树。
决策树就是这样的二叉树：树的根结点表示“元素的所有可能顺序”，树的每一条边表示“一种可能的比较”，一条边连接的孩子结点则是“父结点经过该边所代表的比较后剩余的可能顺序”。这样的解释很难理解，但有图搭配就可以好很多：
上图是一棵三元素排序决策树，根结点处表示所有可能的顺序，而从根延伸下来的两条边分别表示了两种“决策”，或者说“比较”，经过该“决策”后就可以得出剩余的可能情况，比如根结点的左孩子是经历决策“a<b”后剩余的可能。显然，叶子代表只剩一种可能顺序。
注意，决策树并没有代表任何排序算法，即没有哪个排序算法是这样工作的。但是决策树可以给我们这样一个信息：通过比较来排序的算法，本质上就是沿着决策树从根到某个叶子的路径比较下去。
因此，分析这条“路径”平均经过多少条边，就相当于分析使用比较的排序算法平均需要多少次比较。这也是本次分析与（17）的不同之处，在（17）中我们的分析针对的是排序算法的“交换”次数，这次我们分析的是“比较”次数，而比较次数显然更为关键，因为不论元素是否远距离交换，比较总是存在的。
要分析使用比较进行排序的算法平均进行几次比较，我们就必须知晓以下定理。
定理1：深度为d的二叉树，最多拥有2d个叶子
证明很简单：二叉树的深度d即二叉树中深度最大的叶子的深度d，若存在某个叶子深度不是d，则可以在该叶子下添加两个孩子而不改变树的深度，因此深度为d的二叉树要有最多的叶子则必为满二叉树，此时有叶子2d个（深度为d的层最多有2d个结点）
定理2：有y个叶子的二叉树，深度至少为[logy]（底数默认为2）
证明：由定理1可以直接推出。
这个证明可能有点难懂，我们可以触类旁通一下：假如1元钱最多可以买5个糖，那么5个糖最少需要多少钱？答案是1元，恰好是反函数的关系。类似的，深度为x的二叉树最多有y个叶子，那么有y个叶子的二叉树最少有多少深度？答案就是x了。
定理3：N元素排序的决策树有N!个叶子结点
证明：N元素排序的可能顺序共有N!个，而决策树的叶子就是表示“仅剩的可能性”即某一种可能顺序，所以N元素排序的决策树共有N!个叶子
定理4：使用元素比较的排序算法至少需要O(logN!)次比较
证明：由定理2可知，有y个叶子的决策树，深度至少为[logy]，而N元素排序决策树叶子数量必为N!，所以N元素排序决策树深度至少为[logN!]，也即N元素排序决策树的任一叶子深度至少为[logN!]，而叶子的深度就表示了从根到该叶子的路径上经过的边的数量，也就是“比较”的次数，因此定理4成立。
定理5：使用元素比较的排序算法至少需要Ω(N*logN)次比较
证明：根据定理4进行继续计算：
logN!=log(N*(N-1)*(N-2)*……*2*1)
=logN+log(N-1)+log(N-1)+……+log2+log1
>=logN+log(N-1)+……log(N/2)
>=(N/2)*log(N/2)=(N/2)*log(N*1/2)=(N/2)*logN+(N/2)*log(1/2)
>=(N/2)*logN-N/2
=Ω(N*logN)
定理5就是我们这次分析的最终结果，并且我们可以将定理5进行一个推广：假设存在X种可能情形，确定具体情形的方法是不断地问“是或否”型的问题，那么累计需要问的次数至少是[logX]。
那么根据定理5，堆排序、合并排序和快速排序是否已经代表了排序的最快境界呢？不是的，因为定理5依然是有“限定”的，那就是通过比较进行排序的算法才符合，也就是说不是通过比较来完成排序的话，是可能突破这个界限的。
不通过比较来完成排序，是个什么样子？我们这里可以举一个简单的例子：桶式排序。其时间复杂度是O(N)。
现实生活中桶式排序的思想是不少见的，举个例子感受一下：
假设我们有很多硬币，一分、二分、五分、一角、五角和一元都有，现在我们想要将它们按从小到大排好序，该怎么做？手工模拟任意排序算法都可以完成这项工作，但没有人会这么傻。大部分人的做法都是：准备6个“桶”，分别存放这6种硬币，一分的扔进一分桶，一元的扔进一元桶，所有硬币扔进桶里了，再按顺序从桶里倒出来，排序就完成了。
将上述思想转换到计算机中就是这样：假设我们的元素都是自然数，且一定小于MAX，那我们只要准备MAX个空桶，即定义一个整形数组bucket[MAX]，并将其全部初始化为0。然后遍历所有元素，若元素为i，则令bucket[i]加1，最后统计数组bucket的情况，就可以得出元素的顺序：
//size为数组src的大小，也即元素个数
void BucketSort(unsigned int *src,unsigned int size)
{
//MAX为宏，表示src中元素不会大于等于的值
unsigned int bucket[MAX] = { 0 };
//将元素们“扔进桶里”
for (unsigned int i = 0;i < size;++i)
++bucket[src[i]];
//将桶里的元素“倒出来”
unsigned int j = 0;
for (unsigned int i = 0;i < MAX;++i)
for (unsigned int x = 0;x < bucket[i];++x)
src[j++] = bucket[i];
}
显然，桶式排序的局限性在于要求元素必须是自然数，必须存在上限且上限不可过分大，因为元素的上限决定了桶的数量，而桶的数量并不是想要多少有多少，比如我的电脑就不支持分配一个大小为INT_MAX的数组。
桶式排序还有一种变种，只需要10个桶即可，感兴趣的可以去搜索“桶式排序”或“基数排序”，此处不做介绍。
本篇博文就是有关排序的最后一篇博文了，下一篇博文开始，我将会介绍图论算法，并不难，至少理解起来是不难。