常见排序算法的总结 - 复杂度、实现和稳定性_各个排序算法怎么实现,复杂度怎么样。

最基础的算法问题，温故知新。排序算法的几个主要指标是，时间复杂度（最好，最差和平均），空间复杂度（额外空间）和稳定性。本文主要描述八种常见算法：简单选择排序、冒泡排序、简单插入排序、希尔排序、归并排序、快速排序、堆排序和基数排序，关于它们的指标统计可以直接看最后。

值得一提的是排序算法的稳定性，之前关注较少。稳定性的意思是对于序列中键值（Key value）相同的元素，它们在排序前后的相对关系保持不变。对于int这样的基本数据类型，稳定性基本上是没有意义的，因为它的键值就是元素本身，两个元素的键值相同他们就可以被认为是相同的。但对于复杂的数据类型，数据的键值相同，数据不一定相同，比如一个Student类，包括Name和Score两个属性，以Score为键值排序，这时候键值相同元素间的相对关系就有意义了。

简单选择排序

应该是最自然的思路。选择排序的思想是，从全部序列中选取最小的，与第0个元素交换，然后从第1个元素往后找出最小的，与第一个元素交换，再从第2个元素往后选取最小的，与第2个元素交换，直到选取最后一个元素。

void selectionSort(int a[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        int minIdx = i;
        for (int j = i + 1; j < n; ++j) {
            if (a[j] < a[minIdx]) {
                minIdx = j;
            }
        }
        int tmp = a[i];
        a[i] = a[minIdx];
        a[minIdx] = tmp;
    }
}

无论如何都要完整地执行内外两重循环，故最好、最差和平均时间复杂度都是O(n2)，不需要额外空间。选择排序是不稳定的。

冒泡排序

冒泡排序的思想是，从第0个元素到第n-1个元素遍历，若前面一个元素大于后面一个元素，则交换两个元素，这样可将整个序列中最大的元素冒泡到最后，然后再从第0个到第n-2遍历，如此往复，直到只剩一个元素。

void bubbleSort(int a[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < n - i - 1; ++j) {
            if (a[j] > a[j + 1]) {
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
            }
        }
    }
}

冒泡排序与简单选择排序类似，无论如何都要执行完两重循环，故最好、最坏和平均时间复杂度均为O(n2)，不需要额外空间。冒泡排序是稳定的。
冒泡排序的一个改进是，在内层循环之前设置一个标记变量，用于标记循环是否进行了交换，在内层循环结束时，若判断没有进行交换，则说明剩下的序列中，每个元素都小于等于后面一个元素，即已经有序，可终止循环。这样，冒泡排序的最好时间复杂度可以提升到O(n)。

简单插入排序（Insertion Sort）

思路是类似扑克牌的排序，每次从未排序序列的第一个元素，插入到已排序序列中的合适位置。假设初始的有序序列为第0个元素（本文描述的序号都从0开始），只有一个元素的序列肯定是有序的，然后从原先序列的第1个元素开始到第n-1个元素遍历，每次将当前元素插入到它之前序列中的合适位置。

void insertionSortBSearch(int a[], n) {
    for (int i = 1; i < n; ++i) { 
        int j, val = a[i]; 
        for (j = i - 1; j >= 0 && a[j] > val; --j) {
            a[j + 1] = a[j];
        }
        a[j + 1] = val;
    }
}

两重循环，最差和平均时间复杂度为O(n2)，最好情况是原序列已有序，则忽略内层循环，时间复杂度O(n)。插入排序是稳定的。
这里，内层循环我们用的是从后向前遍历，来找到合适的插入位置，而内层循环所遍历的，是已排序的数组，所以我们可以使用二分查找来寻找插入位置，从而使时间复杂度提高到O(n*log n)。代码如下。

// 二分查找改进的插入排序
void insertionSortBSearch(int a[], n) {
    for (int i = 1; i < n; ++i) { 
        int j, val = a[i]; 
        int begin = 0, end = i - 1;
        while (begin < end) {
            int mid = begin + (end - begin) / 2;
            if (a[mid] > val) {
                end = mid - 1;
            }
            else {
                begin = mid;
            }
        }
        for (j = i - 1; j >= begin; --j) {
            a[j + 1] = a[j];
        }
        a[begin] = val;
    }
}

希尔排序

希尔排序可以被认为是简单插入排序的一种改进。插入排序一个比较耗时的地方在于需要将元素反复后移，因为它是以1为增量进行比较的元素的后移可能会进行多次。一个长度为n的序列，以1为增量就是一个序列，以2为增量就形成两个序列，以i为增量就形成i个序列。希尔排序的思想是，先以一个较大的增量，将序列分成几个子序列，将这几个子序列分别排序后，合并，在缩小增量进行同样的操作，知道增量为1时，序列已经基本有序，这是进行简单插入排序的效率就会较高。希尔排序的维基词条上有一个比较好的解释例子如下：

// 原始序列
13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10
// 以5为增量划分，5列，每列即为一个子序列
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10
// 对每一个子序列进行插入排序得到以下结果
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
// 恢复一行显示为
10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45
// 再以3为增量划分，3列，每列即为一个子序列
10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
// 对每一个子序列进行插入排序得到如下结果
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
// 恢复一行为
10 14 13 25 23 33 27 25 59 39 65 73 45 94 82 94
// 然后再以1为增量进行插入排序，即简单插入排序
// 此时序列已经基本有序，分布均匀，需要反复后移的情况较少，效率较高

上面的例子中，我们依次选取了5、3和1为增量，实际中增量的选取并没有统一的规则，唯一的要求就是最后一次迭代的增量需为1。最初的增量选取规则为，从n/2折半递减直到1。还有一些关于希尔排序增量选取的研究，针对不同数据有不同的表现，在此不做展开。下面是增量从n/2折半递减到1的代码示例。

void shellSort(int a[], int n) {
    for (int step = n / 2; step > 0; step /= 2) {
        for (int i = step; i < n; ++i) {
            int j, val = a[i];
            for (j = n - step; j >= 0 && a[j] > val; j -= step) {
                a[j + step] = a[j];
            }
            a[j + 1] = val;
        }
    }
}

希尔排序在简单插入排序的基础上做了些改进，它的最好及最差时间复杂度和简单插入排序一样，分别是是O(n)和O(n2)，平均时间复杂度试增量选取规则而定，一般认为介于O(n)和O(n2)之间。它不需要额外空间。它是不稳定的。

归并排序

归并排序的思想是，利用二分的特性，将序列分成两个子序列进行排序，将排序后的两个子序列归并（合并），当序列的长度为2时，它的两个子序列长度为1，即视为有序，可直接合并，即达到归并排序的最小子状态。基于递归的实现如下：

void mergeSortRecursive(int a[], int b[], int start, int end) {
    if (start >= end) {
        return;
    }
    int mid = start + (end - start) / 2,
        start1 = start, end1 = mid,
        start2 = mid + 1, end2 = end;
    mergeSortRecursive(a, b, start1, end1);
    mergeSortRecursive(a, b, start2, end2);
    int i = 0;
    while (start1 <= end1 && start2 <= end2) {
        b[i++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
    }
    while (start1 <= end1) {
        b[i++] = a[start1++];
    }
    while (start2 <= end2) {
        b[i++] = a[start2++];
    }
    for (i = start; i < end; ++i) {
        a[i] = b[i];
    }
}
 
void mergeSort(int a[], int n) {
    int *b = new int[n];
    mergeSortRecursive(a, b, 0, n - 1);
    delete[] b;
}

归并排序的最好，最坏和平均时间复杂度都是O(n*logn)。但需要O(n)的辅助空间。归并排序是稳定的。

快速排序

快速排序可能是最常被提到的排序算法了，快排的思想是，选取第一个数为基准，通过一次遍历将小于它的元素放到它的左侧，将大于它的元素放到它的右侧，然后对它的左右两个子序列分别递归地执行同样的操作。

void quickSortRecursive(int a[], int start, int end) {
    if (start >= end)
        return;
    int mid = a[start];
    int left = start + 1, right = end;
    while (left < right) {
        while (a[left] <= mid && left < right)
            ++left;
        while (a[right] > mid && left < right)
            --right;
        swap(a[left], a[right]);
    }
    if (a[left] <= a[start])
        swap(a[left], a[start]);
    else
        --left;
    if (left)
        quickSortRecursive(a, start, left - 1);
    quickSortRecursive(a, left + 1, end);
}
 
void quickSort(int a[], int n) {
    quickSortRecursive(a, 0, n - 1);
}

快速排序利用分而治之的思想，它的最好和平均实际复杂度为O(nlogn)，但是，如果选取基准的规则正好与实际数值分布相反，例如我们选取第一个数为基准，而原始序列是倒序的，那么每一轮循环，快排都只能把基准放到最右侧，故快排的最差时间复杂度为O(n2)。快排算法本身没有用到额外的空间，可以说需要的空间为O(1)；对于递归实现，也可以说需要的空间是O(n)，因为在递归调用时有栈的开销，当然最坏情况是O(n)，平均情况是O(logn)。快速排序是不稳定的。

堆排序

堆排序利用的是二叉树的思想，所谓堆就是一个完全二叉树，完全二叉树的意思就是，除了叶子节点，其它所有节点都有两个子节点，这样子的话，完全二叉树就可以用一个一块连续的内存空间（数组）来存储，而不需要指针操作了。堆排序分两个流程，首先是构建大顶堆，然后是从大顶堆中获取按逆序提取元素。
首先是大顶堆，大顶堆即一个完全二叉树，的每一个节点都大于它的所有子节点。大顶堆可以按照从上到下从左到右的顺序，用数组来存储，第i个节点的父节点序号为(i-1)/2，左子节点序号为2i+1，右子节点序号为2(i+1)。构建大顶堆的过程即从后向前遍历所有非叶子节点，若它小于左右子节点，则与左右子节点中最大的交换，然后递归地对原最大节点做同样的操作。下面是一个较好的示意图来自bubkoo：

构建完大顶堆后，我们需要按逆序提取元素，从而获得一个递增的序列。首先将根节点和最后一个节点交换，这样最大的元素就放到最后了，然后我们更新大顶堆，再次将新的大顶堆根节点和倒数第二个节点交换，如此循环直到只剩一个节点，此时整个序列有序。下面是一个较好的示意图来自bubkoo：

void updateHeap(int a[], int i, int n) {
    int iMax = i,
        iLeft = 2 * i + 1,
        iRight = 2 * (i + 1);
    if (iLeft < n && a[iMax] < a[iLeft]) {
        iMax = iLeft;
    }
    if (iRight < n && a[iMax] < a[iRight]) {
        iMax = iRight;
    }
    if (iMax != i) {
        int tmp = a[iMax];
        a[iMax] = a[i];
        a[i] = tmp;
        updateHeap(a, iMax, n);
    }
}
 
void heapSort(int a[], int n) {
    for (int i = (n - 1) / 2; i >= 0; i--) {
        updateHeap(a, i, n);
    }
    for (int i = n - 1; i > 0; --i) {
        int tmp = a[i];
        a[i] = a[0];
        a[0] = tmp;
        updateHeap(a, 0, i);
    }
}

堆排序的整个过程中充分利用的二分思想，它的最好、最坏和平均时间复杂度都是O(nlogn)。堆排序不需要额外的空间。堆排序的交换过程不连续，显然是不稳定的。

基数排序

基数排序是一种典型的空间换时间的排序方法。以正整数为例，将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位（个位）排序一直到最高位排序完成以后，数列就变成一个有序序列。
对正整数我们常以10为基数，每一位可以为0到9，对于其它数据类型如字符串，我们可以进一步拓展基数，基数越大越占空间，但时间更快，如果有一段足够长的内存空间，也就是说基数为无穷大，那就足够表示所有出现的数值，我们就可以通过一次遍历就实现排序，当然实现上这是不可能的（对已知输入范围的数据是可能的，而且非常有用的，可以用这种思想来模拟一个简单的hash函数）。

int maxBit(int a[], int n)
{
    int maxData = a[0];     
    for (int i = 1; i < n; ++i)
    {
        if (maxData < a[i]) {
            maxData = a[i];
        }   
    }
    int d = 1;
    int p = 10;
    while (maxData >= p)
    {
        maxData /= 10;
        ++d;
    }
    return d;
}
void radixsort(int a[], int n)
{
    int d = maxBit(a, n);
    int *tmp = new int[n];
    int *count = new int[10];
    int i, j, k;
    int radix = 1;
    for (i = 1; i <= d; i++, radix *= 10)
    {
        for (j = 0; j < 10; j++) {
            count[j] = 0;
        }   
        for (j = 0; j < n; j++)
        {
            k = (a[j] / radix) % 10;
            count[k]++;
        }
        for (j = 1; j < 10; j++) {
            count[j] = count[j - 1] + count[j];
        }   
        for (j = n - 1; j >= 0; j--)
        {
            k = (a[j] / radix) % 10;
            tmp[count[k] - 1] = a[j];
            count[k]--;
        }
        for (j = 0; j < n; j++) {
            a[j] = tmp[j];
        }
    }
    delete[]tmp;
    delete[]count;
}

基数排序的最好，最好、最坏和平均时间复杂度都是O(n*k)，其中n是数据大小，k是所选基数。它需要O(n+k)的额外空间。它是稳定的。

八种排序算法总结

上面介绍了最常提到的八种排序算法，最基础的是选择和插入，基于选择和插入分别改进出了冒泡和希尔。基于二分思想又提出了归并、快排和堆排序。最后基于数据的分布特征，提出了基数排序。这些排序算法的主要指标总结如下。

参考

排序算法时间复杂度：https://www.geeksforgeeks.org/time-complexities-of-all-sorting-algorithms/
排序算法稳定性：https://www.geeksforgeeks.org/stability-in-sorting-algorithms/