史上最简单的排序算法？看起来却满是bug

大家好，我是雨乐。

今天在搜论文的时候，偶然发现一篇文章，名为<Is this the simplest (and most surprising) sorting algorithm ever?>，看了里面的内容，蛮有意思，所以今天借助此文，分享给大家。

算法

下面我看下伪代码实现，在证明该排序算法正确性之前，我们暂且将其命名为ICan’tBelieveItCanSort。

ICan’tBelieveItCanSort(A[1..n]) {
  for i = 1 to n do
    for j = 1 to n do
      if A[i] < A[j] then
        swap(A[i], A[j])
}

看了上面代码的第一反应是什么？会不会跟我一样，觉得

❝

这不就是一个错误的冒泡排序算法么，只是把第二行把范围写错，第三行交换的条件写反了罢了。

❞

下面是冒泡排序的伪代码：

BubbleSort(A[1..n]) {
  for i = 1 to n do
    for j = i + 1 to n do
      if (A[i] > A[j]) then
        swap(A[i], A[j]);
}

❝

为了后续描述方便，我将该算法统一称之为"新算法"。

❞

从上面两个伪代码的实现来看，新算法ICan’tBelieveItCanSort和传统的冒泡排序算法BubbleSort的区别如下：

• 在新算法中，内循环为 for j = 1 to n do

  而在传统的冒泡算法中，内循环为 for j = i + 1 to n do

• 在新算法中，交换的条件为 if A[i] < A[j] then

  而在传统的冒泡排序算法中，交换条件为 if A[i] > A[j] then

好了，我们言归正传，重新转回到新算法，为了方便大家阅读，再此重新贴一次新算法的伪代码：

ICan’tBelieveItCanSort(A[1..n]) {
  for i = 1 to n do
    for j = 1 to n do
      if A[i] < A[j] then
        swap(A[i], A[j])
}

先不论算法的正确与否，因为在A[i] < A[j]时候才进行交换，所以上述代码给我们的第一印象就是 按照降序排列。但实际上，通过代码运行结果来分析，其确实是升序排列。

下面给出证明过程。

证明

下面将通过数学归纳法来证明此算法的正确性。

假设Pᵢ是经过 i 次（1 ≤ i ≤ n）外循环后得到的数组，那么前i项已经是升序排列，即 A[1] ≤ A[2] ≤ . . . ≤ A[i]。

要证明该算法正确，只需要证明P对于任何[i + 1..n]都成立。

根据数学归纳法，我们只要证明 P₁成立，假设 Pᵢ成立，接着再证明 Pi+1 也成立，命题即可得证。

P₁显然是正确的，而且这一步和普通的冒泡算法降序没有区别，经过第1次外循环，A[1]就是整个数组的最大元素。

接着我们假设Pᵢ成立，然后证明 Pi+1 成立。

下面我们开始证明新算法的正确性。

首先假设存在一个下标K：

❝

首先假设 A [k]（k 介于 1~i 之间）满足 A[k] > A[i+1] 最小的一个数，那么 A [k−1]≤A [i+1]（k≠1）。

如果 A [i+1]≥A [i]，那么这样的 k 不存在，我们就令 k=i+1。

❞

现在，我们考虑以下几种情况：

• 1 ≤ j ≤ k−1 此时，由于A[1..i]是递增有序，且A[K]是满足A[k] > A[i+1] 最小的一个数，所以A[j] < A[i +1]，没有任何元素交换发生。

• k ≤ j ≤ i (显然，当k = i+1的时候，不会进入此步骤)

  由于 A[j] > A[i+1]，所以每次比较后都会有元素交换发生。

  我们使用 A[] 和 A′[] 来表示交换前和交换后的元素，所以A[i+1] = A[k]，A′[k]=A[i+1]。

  经过一系列交换，最大元素最终被放到了 A[i+1] 位置上，原来的A[i+1]变成了最大元素，A[k]被插入了大小介于原来A[k]和A[k-1]之间的元素。

• i+1 ≤ j ≤ n

  由于最大元素已经交换到前 i+1 个元素中，此过程也没有任何元素交换。

经过上面一系列条件，最终，P就是升序排序算法执行完以后的结果。

❝

由于内外循环完全一样，所以此算法可以说是最简单的排序算法了。

❞

优化

从上面的证明过程中，我们可以发现，除了 i=1 的循环以外，其余循环里 j=i-1 之后的部分完全无效，因此可以将这部分省略，得到简化后的算法。

ICan’tBelieveItCanSort(A[1..n]) {
  for i = 2 to n do
    for j = 1 to i - 1 do
      if A[i] < A[j] then
        swap(A[i], A[j])
}

对比

但从代码来看，新算法像是冒泡算法的变种，但是从上面证明过程来看，新算法实际上是一种插入算法。

下面为新算法的模拟图：

新算法

下面为冒泡算法的模拟图：

冒泡算法

实现

代码实现比较简单，如下：

#include 
#include 
#include 

void SimplestSort(std::vector &v) {
  for (int i = 0; i < v.size(); ++i) {
    for (int j = 0; j < v.size(); ++j) {
      if (v[i] < v[j]) {
 std::swap(v[i], v[j]);
      }
    }
  }
}

int main() {
  std::vector v = {9, 8, 1, 3,2, 5, 4, 7, 6};
  SimplestSort(v);

  for (auto item : v) {
    std::cout << item << std::endl;
  }

  return 0;
}

输出结果：

1
2
3
4
5
6
7
8
9

更简单的算法？

看完这篇论文，突然想起之前有个更简单且容易理解的算法，我们暂且称之为休眠算法。

思想：

❝

构造n个线程，它们和这n个数一一对应。初始化后，线程们开始睡眠，等到对应的数那么多个时间单位后各自醒来，然后输出它对应的数。这样最小的数对应的线程最早醒来，这个数最早被输出。等所有线程都醒来，排序就结束了。

❞

例如对于 [4,2,3,5,9] 这样一组数字，就创建 5 个线程，每个线程睡眠 4s，2s，3s，5s，9s。这些线程睡醒之后，就把自己对应的数报出来即可。这样等所有线程都醒来，排序就结束了。

算法思路很简单，但是存在一个问题，创建的线程数依赖于需要排序的数组的元素个数，因此这个算法暂且只能算是一个思路吧。

结语

这个算法不一定是史上最简单的排序算法，但却是最神奇的排序算法。神奇之处在于 大于号和小于号颠倒了却得到了正确的结果。

其实，我们完全可以用另外一个简单的思路来理解这个算法，那就是冒泡两次，第一次非递增排序，第二次非递减排序，算是负负得正，得到了正确的结果吧。

由于"最简单"算法的时间复杂度过高，其仅仅算是一种实现思路，也算是开拓一下思路，实际使用的时候，还是建议使用 十大经典排序算法。

今天的文章就到这里，下期见。