奇葩的不可行排序：睡眠排序、面条排序、猴子排序（c++版）
常用和经典的排序算法
目前常用和经典的排序算法有：
冒泡排序（bubble sort） — O(n^2）
鸡尾酒排序(Cocktail sort，双向的冒泡排序) — O(n^2）
插入排序（insertion sort）— O(n^2)
桶排序（bucket sort）— O(n); 需要 O(k) 额外空间
计数排序(counting sort) — O(n+k); 需要 O(n+k) 额外空间
合并排序（merge sort）— O(nlog n); 需要 O(n) 额外空间
原地合并排序— O(n^2)
二叉排序树排序 （Binary tree sort） — O(nlog n)期望时间； O(n^2)最坏时间； 需要 O(n) 额外空间
鸽巢排序(Pigeonhole sort) — O(n+k); 需要 O(k) 额外空间
基数排序（radix sort）— O(n·k); 需要 O(n) 额外空间
Gnome 排序— O(n^2)
图书馆排序— O(nlog n) with high probability，需要 （1+ε)n额外空间
不稳定的
选择排序（selection sort）— O(n^2)
希尔排序（shell sort）— O(nlog n) 如果使用最佳的现在版本
组合排序— O(nlog n)
堆排序（heapsort）— O(nlog n)
平滑排序— O(nlog n)
快速排序（quicksort）— O(nlog n) 期望时间，O(n^2) 最坏情况； 对于大的、乱数列表一般相信是最快的已知排序
Introsort— O(nlog n)
Patience sorting— O(nlog n+ k) 最坏情况时间，需要 额外的 O(n+ k) 空间，也需要找到最长的递增子串行（longest increasing subsequence）
不实用的
Bogo排序— O(n× n!) 期望时间，无穷的最坏情况。
Stupid sort— O(n^3); 递归版本需要 O(n^2) 额外存储器
珠排序（Bead sort） — O(n) or O（√n)，但需要特别的硬件
Pancake sorting— O(n)，但需要特别的硬件
stooge sort——O（n^2.7）很漂亮但是很耗时
但是除了这些算法，还有哪些奇葩又去有趣的排序算法呢？
睡眠排序（Sleep Sort）
睡眠排序也称为硬件排序, 充分利用硬件计时器的资源实现拟态算法：
这个事件起源于秃子发表了一个时间复杂度为O(n)的排序算法，睡眠排序的主要逻辑是构造n个线程，它们和这n个数一一对应。初始化后，线程们开始睡眠，等到对应的那么多个时间单位后各自醒来，然后输出对应的数。这样最小的数对应的线程最早醒来，这个数最早被输出。等所有线程都醒来，排序就结束了。
#include
#include
#include
#include
#include
#include
//void SleepSort(const int i)
//{
// std::this_thread::sleep_for(std::chrono::milliseconds(i));
// std::cout << i << " ";
//}
void SleepSort(const int i, const int offset)
{
std::this_thread::sleep_for(std::chrono::milliseconds(i + offset));
std::cout << i << " ";
}
int main()
{
std::cout << "Sorted array is:\n";
std::vector threads;
std::vector num;
int x;
while (std::cin >> x )
num.push_back(x);
//for (int i = 0; i < num.size(); ++i)
// threads.push_back(std::thread(SleepSort, num[i]));
//添加负值排序
std::vector data;
data.reserve(num.size() - 1);
for (int i = 0; i < num.size(); ++i)
data.push_back(num[i]);
const int minElem = std::abs(*std::min_element(data.begin(), data.end())); //min_element寻找范围 [first, last) 中的最小元素。
for (int i = 0; i < num.size(); ++i)
threads.push_back(std::thread(SleepSort, num[i], minElem));
for (auto& thread : threads)
thread.join();
return 0;
}
注释：
[1] 当线程不太多的时候，基本可以认为它们是同时启动的。
[2] 主线程睡眠足够长时间，等所有Sleeper线程都执行完毕。可以把时间设成比最大输入稍大。
不可行原因：
- 比如输入数据很相近时会有误差
- 输入数据很多时，这些线程不能看作是同时启动等等
- 输入数据太大时，运行时间太长
命题来源及吃瓜群众：话题提出、网友讨论、负值改进
面条排序(Spaghetti Sort, 意面排序)
意大利面条排序(Spaghetti Sort)的思路是，将输入分别对应到不同长度的面条上，每根面条的长度即为对应的数字的大小。比如，对于[1, 4, 2, 8, 9]这个输入，则分别做出长度为1cm、4cm、2cm、8cm、9cm的面条。然后，将这些面条的一头对其，用手抓住，另一头向下。然后慢慢地将手向下垂直下降，第一个触碰到桌面的面条对应的数字则为最大的数字，第二个触碰到的就是第二大的，依次类推。
Spaghetti排序简直不是一个软件可行的想法 - 它是一种按物理长度排序的“物理”理论方法。基本上它说：“将一堆意大利面条棒推到一个平坦的表面上，使最长的那些比最短的更突出 - 从而按长度”排序“它们。
最接近的类似想法可以实施（并且已经多次）是Radix分类。但这仅适用于您的数据肯定属于固定值集 - 足够小以适应可用资源（例如RAM）的情况。例如，如果你的整数是32位并且可以是32位范围内的任何值，那么你需要在一个数组中至少有2 ^ 32 = 4M个插槽（桶），以便能够对它们进行排序而不需要重复（重复它会变成重复）更复杂，更多的内存饥饿）。如果它是64位我不会建议这条路线，因为你可能需要很多存储才能达到那个数量的桶 - 在这种情况下我会采用某种形式的混合方法（使用基数将数字分组到某些部分）可能的值，然后使用像qsort这样的正常排序分别对这些组进行排序，然后将这些组一个接一个地合并在一起）。
参考：https://en.wikipedia.org/wiki/Spaghetti_sort
猴子排序(Bogo Sort)
在计算机科学中，Bogo排序（Bogo-Sort）是个既不实用又原始的排序算法，其原理等同将一堆卡片抛起，落在桌上后检查卡片是否已整齐排列好，若非就再抛一次。其名字源自Quantum bogodynamics，又称bozo sort、blort sort或猴子排序（参见无限猴子定理）。
while not isInOrder(deck):
shuffle(deck)但是问题很明显啊，太慢啊，O(N*N!)，这么慢搞什么鬼啊（缘分大法好）。
// C++ implementation of Bogo Sort
#include
using namespace std;
// To check if array is sorted or not
bool isSorted(int a[], int n)
{
while (--n > 1)
if (a[n] < a[n - 1])
return false;
return true;
}
// To generate permuatation of the array
void shuffle(int a[], int n)
{
for (int i = 0; i < n; i++)
swap(a[i], a[rand() % n]);
}
// Sorts array a[0..n-1] using Bogo sort
void bogosort(int a[], int n)
{
// if array is not sorted then shuffle
// the array again
while (!isSorted(a, n))
shuffle(a, n);
}
// prints the array
void printArray(int a[], int n)
{
for (int i = 0; i < n; i++)
printf("%d ", a[i]);
printf("\n");
}
// Driver code
int main()
{
int a[] = { 3, 2, 5, 1, 0, 4 };
int n = sizeof a / sizeof a[0];
bogosort(a, n);
printf("Sorted array :\n");
printArray(a, n);
return 0;
} 参考文章：geeksforgeeks
量子猴排(Quantum Bogo Sort)
不过好在量子物理的发展，给了我们用这个方法解决问题的一线生机。所谓量子猴排就是洗牌的时候，使用量子化随机排列（quantumly randomized）。这样的话，我们在观测这组数之前，这组数的状态是叠加的。
通过这种量子化随机排列，我们划分出来了O(n)个平行宇宙。接下来，在某个宇宙00729中，观测一下这组数，发现运气不好，没有排序好，那么我们就销毁掉这个宇宙。然后再看看其他宇宙的运气怎么样。终于，在一个宇宙04008中，发现刚好是排好序的数组。那么我们就保留宇宙04008。最后，没有被销毁的宇宙中，数组都是恰好一次被排好序的。算法结束。
我们来分析一下量子猴排的时间复杂度，嗯，O(n)，看是不是快了很多。
参考文章：代码改进-知乎罗必成
蠢猴排序（Bogobogo sort）
前面介绍的猴子排序或者量子猴排，有的同学们可能并不会觉得慢或者麻烦。相反，说不定决定其实猴子排序还是太快了呢（脑洞已开），所以就有了蠢猴排序，该算法实现如下：
#include
#include
#include
#include
int* bogobogosort(int* toSort, int size);
/*
* Taken from http://benpfaff.org/writings/clc/shuffle.html
*
* Copyright © 2004 Ben Pfaff
*/
void shuffle(int *array, size_t n) {
if (n > 1) {
size_t i;
for (i = 0; i < n - 1; i++) {
size_t j = i + rand() / (RAND_MAX / (n - i) + 1);
int t = array[j];
array[j] = array[i];
array[i] = t;
}
}
}
int* bogobogosort_rec(int *toSort, int size) {
int* copy = (int*)malloc(size * sizeof(int));
memcpy(copy, toSort, size * sizeof(int));
int i;
if (size > 1) {
int* ret = bogobogosort_rec(copy, size - 1);
memcpy(copy, ret, (size - 1) * sizeof(int));
if (copy[size - 2] > copy[size - 1]) {
shuffle(copy, size);
ret = bogobogosort_rec(copy, size);
memcpy(copy, ret, size * sizeof(int));
}
}
for (i = 0; i < size; i++) {
if (toSort[i] == copy[i]) continue;
}
return copy;
}
int* bogobogosort(int* toSort, int size) {
int i;
int *result = (int*)malloc(size * sizeof(int));
int *tmp = bogobogosort_rec(toSort, size);
memcpy(result, tmp, size * sizeof(int));
for (i = 0; i < size; i++) {
if (result[i] == tmp[i]) continue;
}
return result;
}
int main() {
int num[6] = { 0,5,2,1,8,10 };
int size = 6;
int *newnum = new int[size];
newnum = bogobogosort(num, size);
for (int x=0;x< size;x++)
std::cout << newnum[x] << " ";
std::cout << std::endl;
return 0;
} 从递归的底层往上看的话，蠢猴排序就是先将一个元素排序一下，这是最简单的。然后拷贝第二个元素进来，判断一下大小，如果顺序不对则对这两个元素猴子排序一下。接下里拷贝第三个元素进来，在判断一下这下顺序是不是错了，如果错了则再对这三个元素猴子排序一下……一直这么进行下去。
蠢猴排序的时间复杂度有说是的，也有说是的，也有说是的，反正大家大致的意思是，用蠢猴排序来对一个稍微长点的乱序数组进行排序的话，就有可能一直运行到宇宙的热寂（Heat death of the universe）都不会结束。