奇葩的不可行排序：睡眠排序、面条排序、猴子排序（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<cstdlib>
#include<chrono>
#include<iostream>
#include<thread>
#include<vector>
#include <algorithm>

//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<std::thread> threads;
	std::vector<int> 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<int> 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线程都执行完毕。可以把时间设成比最大输入稍大。

不可行原因：

1. 比如输入数据很相近时会有误差
2. 输入数据很多时，这些线程不能看作是同时启动等等
3. 输入数据太大时，运行时间太长

命题来源及吃瓜群众：话题提出、网友讨论、负值改进

 

面条排序(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<iostream> 
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 <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>

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）都不会结束。