直插，快排，堆排，归并排序的分析

一：直接插入排序

直接插入排序（Insertion Sort）可以说是排序里最简单的了。

void InsertSort(int array[], int left, int right)
{
    int temp;
    int j;
    for (int i = left + 1; i <= right; i++)
    {
        temp = array[i];
        j = i - 1;
        while (j >= left && array[j] > temp)
            array[j + 1] = array[j--];
        array[j + 1] = temp;
    }
}

算法复杂度（摘自维基百科）：
如果目标是把 n 个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。
最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需 n-1 次即可。
最坏情况就是，序列是降序排列，那么此时需要进行的比较共有 12n(n−1) 次。插入排序的赋值操作是比较操作的次数加上 n-1 次。平均来说插入排序算法复杂度为 O(n2)。

因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。 插入排序在工业级库中也有着广泛的应用，在 STL 的 sort 算法和 stdlib 的 qsort 算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为 8 个或以下）。

二：快速排序

快速排序本身不难，对于初学者，难就难在递归的理解。
算法步骤：
（1）：选取主元（开头，或末尾，或随机一个）；
（2）：小于（或等于）主元的放左边，大于（或等于）主元的放右边；
（3）：分别对左边，右边递归，即重复（1）（2）步。

void QuickSort(int array[], int left, int right)
{
    if (left >= right)
        return;

    int base = array[left];
    int i = left;
    int j = right;
    while (i < j)  //小于（或等于）主元的放左边，大于主元（或等于）的放右边
    {
        while (i < j && array[j] >= base)
            j--;
        while (i < j && array[i] <= base)
            i++;
        swap(array[i], array[j]);
    }
    swap(array[left], array[i]);

    QuickSort(array, left, i - 1);  //分别对左边，右边递归
    QuickSort(array, i + 1, right);
}

有必要对以上代码的细节方面作个总结：
（1）：递归结束条件

if (left >= right)
    return;

结束条件应该是大于或等于，而不仅仅是等于。
考虑这样的情况：在一段区间中，取开头作为主元，很巧的是该区间除开头（即主元），其它所有的数都大于主元，于是分别对两边递归：

QuickSort(array, left, i - 1);  //分别对左边，右边递归
QuickSort(array, i + 1, right);

第一个函数的后两个参数：left与i - 1，前者大，后者小。
（2）：等于主元的数如何放置

while (i < j && array[j] >= base)
    j--;
while (i < j && array[i] <= base)
    i++;

代码对等于主元的数采取的策略是：保持原位不动。
我们试着改变下代码：

while (i < j && array[j] > base)  //去掉等号
    j--;
while (i < j && array[i] <= base)
    i++;

我们把等于主元的数全部移动到左边。这么做，程序依旧运行正常。
我们再试着改下代码：

while (i < j && array[j] > base)  //去掉等号
    j--;
while (i < j && array[i] < base)  //去掉等号
    i++;

左边等于主元的数移到右边，右边等于主元的数移到左边。
这样的做法有点诡异，似乎除了多了无用的交换操作耗时外，并不会对程序造成其它的影响。
考虑这样的情况：

3 作为主元，i 和 j 指向的位置如上图，接着交换两个位置的值，

while (i < j)  
{
    while (i < j && array[j] > base)
        j--;
    while (i < j && array[i] < base)
        i++;
    swap(array[i], array[j]);  //交换两值
}

程序会永远在这步进入死循环。
有的人提议：只要在 swap 后再加一句代码就行了嘛。如下：

while (i < j)  
{
    while (i < j && array[j] > base)  //去掉等号
        j--;
    while (i < j && array[i] < base)  //去掉等号
        i++;
    swap(array[i], array[j]);  //交换两值
    i++; j++;  //新增的代码
}
swap(array[left], array[i]);

但这么做，又引出了新的麻烦。
试想，若 i 的下一个位置就是 j（即 i+1 等于 j），在i++; j++;后，while 语句停止，swap 语句交换了主元和位置 i 的值，问题来了，i 指向的值或许是大于主元的，这就造成了程序的逻辑错误。
（3）：i 和 j 的操作顺序

while (i < j && array[j] >= base)
    j--;
while (i < j && array[i] <= base)
    i++;

为何 j 在前，i 在后？
其实这与我们选取的主元位置有关。程序中默认以数组首元素作为主元。

while (i < j)  //小于（或等于）主元的放左边，大于主元（或等于）的放右边
{
    while (i < j && array[j] >= base)
        j--;
    while (i < j && array[i] <= base)
        i++;
    swap(array[i], array[j]);
}
swap(array[left], array[i]);  //交换主元与array[i]

while 语句停止的条件正好是 i 等于 j，接下来交换主元与array[i]，值得我们注意的是，array[i]被交换至左边，但它可以保证其值总是小于等于主元么？

简单推理之下，若我们让 j 先行，i 后走，就可以保证被交换前，其值总是小于等于主元的。反之，若误写了下面的代码，排序后的结果就会是错的。

while (i < j && array[i] <= base)  //i在前
    i++;
while (i < j && array[j] >= base)  //j在后
    j--;

算法复杂度：
最好的情况，每次我们运行一次分区，我们会把一个数组分为两个几近相等的片段。这个意思就是每次递归调用处理一半大小的数组。则会有关系式：

T(n)=2T(n2)+O(n)

解出 Tbest(n)=O(nlogn)。

最坏的情况，在分割后，两子数组总是拥有各为 1 和 n-1 长度的数组，则递归关系式变为：

T(n)=T(n−1)+O(n)+O(1)=T(n−1)+O(n)

解出 Tworst(n)=O(n2)。

三：堆排序

堆排序是利用堆的性质进行的一种选择排序。下面先讨论一下堆。
堆实际上是一棵完全二叉树，其满足性质：任何一节点大于等于或者小于等于其左右子树节点。

堆分为大顶堆和小顶堆，满足 “任何一节点大于等于其左右子树节点” 的称为大顶堆，满足 “任何一节点小于等于其左右子树节点” 的称为小顶堆。由上述性质可知：大顶堆的堆顶肯定是最大的，小顶堆的堆顶是最小的。

下面举个例子（资源来自堆排序 - 海子）来说明堆排序的过程（以升序为例）：
（1）

给定整型数组：{16, 7, 3, 20, 17, 8}，根据该数组 “构建” 完全二叉树（并不是真的写代码去构建，只是把数组看成完全二叉树去操作）。
程序从最后一个非叶子节点开始，即 3。判断其左右孩子：8，8 比 3 大，把 8 调整上去。

（2）

3 节点下无孩子，判断结束。
继续往前一步，至 7 节点，判断其左右孩子：20 和 17，20 是最大的，将其调整上去。

（3）

7 节点下无孩子，判断结束。
继续往前一步，至 16 节点，判断其左右孩子：20 和 8，20 是最大的，将其调整上去。

（4）

判断 16 节点下左右孩子：7 和 17，17 是最大的，将其调整上去。

（5）

16 节点下无孩子，判断结束。
遍历已至头部，结束。

（6）至此数组已经满足大顶堆的性质，接下来的操作就很简单了。

看完上面所述的流程你至少有两个疑问：

• 如何确定最后一个非叶子节点？

其实这是有一个公式的，设二叉树节点总数为 n，则最后一个非叶子节点是第 ⌊n2⌋ 个。

• 数组当中如何确定当前节点的左右孩子位置？

设当前节点下标是 i，则其左孩子的下标是 2i，右孩子的下标是 2i+1。请注意：这是建立在数组下标从 1 开始的情况。若数组下标从 0 开始，则其左右孩子下标还各需多加一个 1。

本程序默认数组下标从 1 开始，请读者注意。

/* 已知array[left]...array[right]的值除arr[left]之外均满足堆的定义，本函数调整array[left]，使array[left]...array[right]成一个大顶堆 */
void HeapAdjust(int array[], int left, int right)
{
    int index = left;
    for (int i = left * 2; i <= right; i = i * 2)
    {
        if (i < right && array[i] < array[i + 1])  //找到孩子中较大者
            i++;
        if (array[index] > array[i])
            return;
        swap(array[index], array[i]);
        index = i;
    }
}

void HeapSort(int array[], int left, int right)
{
    int len = right - left + 1;
    for (int i = len / 2; i >= left; i--)  //把数组调整成大顶堆
        HeapAdjust(array, i, right);
    for (int i = right; i > left; i--)  //排序
    {
        swap(array[left], array[i]);
        HeapAdjust(array, left, i - 1);
    }
}

时间复杂度为 O(nlogn)。证明如下：
首先计算建堆的时间，也就是下面的代码：

for (int i = len / 2; i >= left; i--)  //把数组调整成大顶堆
    HeapAdjust(array, i, right);

n 个节点，从第 0 层至第 log2n 层。对于第 i 层的 2i 个点需要往下走 log2n−i 步。
把走的所有步相加：

T(n)=∑i=0i=log2n2i(log2n−i)=2n−log2n−2<2n=O(n)

接下来就是排序的时间，即下面的代码：

for (int i = right; i > left; i--)  //排序
{
    swap(array[left], array[i]);
    HeapAdjust(array, left, i - 1);
}

HeapAdjust() 耗时 logn，共 n 次，故排序时间为 O(nlogn)。

综上所述，堆排序时间复杂度为 T(n)=O(n)+O(nlogn)=O(nlogn)​。

四：归并排序

对于待排序数组：{5, 2, 4, 6, 1, 3, 2, 6}，归并算法的思路如上图，注意上图是从下往上看。

/* 把有序的array[left]...array[mid]和array[mid+1]...array[right]合并 */
void Merge(int array[], int temp[], int left, int mid, int right)
{
    int i = left;
    int j = mid + 1;
    int k = left;
    while (i <= mid && j <= right)
    {
        if (array[i] < array[j])
            temp[k++] = array[i++];
        else
            temp[k++] = array[j++];
    }

    while (i <= mid)
        temp[k++] = array[i++];
    while (j <= right)
        temp[k++] = array[j++];

    while (left <= right)
        array[left] = temp[left++];
}

void MergeSort(int array[], int temp[], int left, int right)
{
    if (left >= right)
        return;
    int mid = ((right - left) >> 1) + left;
    MergeSort(array, temp, left, mid);
    MergeSort(array, temp, mid + 1, right);
    Merge(array, temp, left, mid, right);
}

Merge() 耗时 O(n)，则归并排序的时间递归式为 T(n)=2T(n2)+O(n)，解得 T(n)=O(nlogn)。

五：四种排序比较

排序方法	最差时间复杂度	最佳时间复杂度	平均时间复杂度	空间复杂度	稳定性
直接插入	O(n2)	O(n)	O(n2)	O(1)	稳定
快速排序	O(n2)	O(nlogn)	O(nlogn)	O(logn)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定

所谓的稳定性，百度百科解释为：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri = rj，且 ri 在 rj 之前，而在排序后的序列中，ri 仍在 rj 之前，则称这种排序算法是稳定的；否则称为不稳定的。

本文转自：http://www.61mon.com/index.php/archives/193/