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

最新推荐文章于 2024-11-09 21:51:15 发布

架构师小秘圈

最新推荐文章于 2024-11-09 21:51:15 发布

阅读量139

点赞数

文章标签：算法 java 数据结构排序算法快速排序

原文链接：https://mp.weixin.qq.com/s?__biz=MzU0OTE4MzYzMw==&mid=2247527555&idx=4&sn=513cdf4e9745580af0d10092b67d75a3&chksm=fbb1e57dccc66c6b63341e55af9a69cc0cea1724753272d36bed9043a0bc653bb1637dfe820d&scene=126&&sessionid=0

版权

今天在搜论文的时候，偶然发现一篇文章，名为<<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
而在传统的冒泡算法中，内循环为 for j = i + 1 to n
在新算法中，交换的条件为 if A[i] < A[j]
而在传统的冒泡排序算法中，交换条件为 if A[i] > A[j]

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

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 <algorithm>
#include <iostream>
#include <vector>

void SimplestSort(std::vector<int> &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<int> v = {9, 8, 1, 3,2, 5, 4, 7, 6};
  SimplestSort(v);

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

  return 0;
}

输出结果：