BogoSort或排列排序

BogoSort也称为置换排序，愚蠢排序，慢速排序，shot弹枪排序或猴子排序是一种基于生成和测试范式的特别无效的算法。该算法会连续生成其输入的排列，直到找到已排序的排列。(Wiki)
例如，如果将bogosort用于对一副纸牌进行排序，则将包括检查该纸牌是否井然有序；如果不是，则将纸牌扔到空中，随机拾起纸牌，然后重复直到对卡片组进行排序为止的过程。

伪代码：

while not Sorted(list) do
    shuffle (list)
done

例子：

让我们考虑一个示例数组(3 2 5 1 0 4)
4 5 0 3 2 1(第一次混洗)
4 1 3 2 5 0(第二次改组)
1 0 3 2 5 4(第三次改组)
3 1 0 2 4 5(第4次改组)
1 4 5 0 3 2(第5次改组)
。
。
。
0 1 2 3 4 5(nth改组)-排序数组

这里，n是未知的，因为算法未知，在哪个步骤中将得出结果排列进行排序。

C++

// 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

---

Java

// Java Program to implement BogoSort
public class BogoSort
{
    // Sorts array a[0..n-1] using Bogo sort
    void bogoSort(int[] a)
    {
        // if array is not sorted then shuffle the
        // array again
        while (isSorted(a) == false)
            shuffle(a);
    }
  
    // To generate permuatation of the array
    void shuffle(int[] a)
    {
         // Math.random() returns a double positive
         // value, greater than or equal to 0.0 and
         // less than 1.0.
         for (int i=1; i <= n; i++)
             swap(a, i, (int)(Math.random()*i));
    }
  
    // Swapping 2 elements
    void swap(int[] a, int i, int j)
    {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
  
    // To check if array is sorted or not
    boolean isSorted(int[] a)
    {
        for (int i=1; i

---

Python

# Python program for implementation of Bogo Sort
import random
  
# Sorts array a[0..n-1] using Bogo sort
def bogoSort(a):
    n = len(a)
    while (is_sorted(a)== False):
        shuffle(a)
  
# To check if array is sorted or not
def is_sorted(a):
    n = len(a)
    for i in range(0, n-1):
        if (a[i] > a[i+1] ):
            return False
    return True
  
# To generate permuatation of the array
def shuffle(a):
    n = len(a)
    for i in range (0,n):
        r = random.randint(0,n-1)
        a[i], a[r] = a[r], a[i]
  
# Driver code to test above
a = [3, 2, 4, 1, 0, 5]
bogoSort(a)
print("Sorted array :")
for i in range(len(a)):
    print ("%d" %a[i]),

C#

// C# implementation of Bogo Sort
using System; 
    
class GFG 
{ 
    // To Swap two given numbers
    static void Swap(ref T lhs, ref T rhs)
    {
        T temp;
        temp = lhs;
        lhs = rhs;
        rhs = temp;
    }
      
    // To check if array is sorted or not 
    public static bool isSorted(int[] a, int n) 
    { 
        int i = 0;
        while(ia[i+1])
                return false;
            i++;
        }
        return true;
    } 
        
    // To generate permuatation of the array 
    public static void shuffle(int[] a, int n) 
    { 
        Random rnd = new Random();
        for (int i=0; i < n; i++) 
            Swap(ref a[i], ref a[rnd.Next(0,n)]); 
    } 
        
    // Sorts array a[0..n-1] using Bogo sort 
    public static 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 
    public static void printArray(int[] a, int n) 
    { 
        for (int i=0; i

---

输出：

Sorted array :
0 1 2 3 4 5 

时间复杂度：

• 最坏的情况：O(∞)(因为该算法没有上限)
• 平均情况：O(n * n！)
• 最好的情况：O(n)(当给定的数组已经排序时)

辅助空间： O(1)