Bogosort

Bogosort

Class	Sorting
Data structure	Array
Worst-case performance	Unbounded (randomized version), O((n+1)!) (deterministic version)
Best-case performance	O(n)
Average performance	O((n+1)!)
Worst-case space complexity	O(n)
Optimal	No

In computer science, bogosort (also permutation sort, stupid sort, slowsort, shotgun sort or monkey sort) is a highly ineffective sorting function based on the generate and test paradigm. The function successively generates permutations of its input until it finds one that is sorted. It is not useful for sorting, but may be used for educational purposes, to contrast it with more efficient algorithms.

Two versions of the function exist: a deterministic version that enumerates all permutations until it hits a sorted one, and a randomized version that randomly permutes its input. An analogy for the working of the latter version is to sort a deck of cards by throwing the deck into the air, picking the cards up at random, and repeating the process until the deck is sorted. Its name comes from the word bogus.

Description of the function

The following is a description of the randomized function in pseudocode:

while not isInOrder(deck):
    shuffle(deck)

Here is the above pseudocode re-written in Python3:

import random

def isSorted(data):
    for i in range(len(data)-1):
        if data[i] > data[i+1]:
            return False
    else:
        return True

def bogosort(data):
    while not isSorted(data):
        random.shuffle(data)

Of course, this assumes that data is a simple, mutable datatype - like Python's builtin list - whose elements can be compared without issue.

Here is a code example with shuffle in Standard ML:

 val _ = load "Random";
 load "Int";
 val rng = Random.newgen ();

 fun select (y::xs, 0) = (y, xs)
   | select (x::xs, i) = let val (y, xs') = select (xs, i-1) in (y, x::xs') end
   | select (_, i) = raise Fail ("Short by " ^ Int.toString i ^ " elements.");

 (* Recreates a list in random order by removing elements in random positions *)
 fun shuffle xs =
    let fun rtake [] _ = []
          | rtake ys max =
             let val (y, ys') = select (ys, Random.range (0, max) rng)
             in y :: rtake ys' (max-1)
             end
    in rtake xs (length xs) end;

 fun bogosort xs comp = 
 let fun isSorted (x::y::xs) comp = comp(x,y) <> GREATER andalso isSorted (y::xs) comp
       | isSorted _ comp = true;
     val a = ref xs;
 in while(not(isSorted (!a) comp)) do (
  a := shuffle (!a)
  ); (!a) end;

Running time and termination

If all elements to be sorted are distinct, the expected number of comparisons performed in the average case by randomized bogosort is asymptotically equivalent to $(e-1)n!$, and the expected number of swaps in the average case equals $(n-1)n!$. The expected number of swaps grows faster than the expected number of comparisons, because if the elements are not in order, this will usually be discovered after only a few comparisons, no matter how many elements there are; but the work of shuffling the collection is proportional to its size. In the worst case, the number of comparisons and swaps are both unbounded, for the same reason that a tossed coin might turn up heads any number of times in a row.

The best case occurs if the list as given is already sorted; in this case the expected number of comparisons is $n-1$, and no swaps at all are carried out.

For any collection of fixed size, the expected running time of the algorithm is finite for much the same reason that the infinite monkey theorem holds: there is some probability of getting the right permutation, so given an unbounded number of tries it will almost surely eventually be chosen.

Related algorithms

Gorosort

is a sorting algorithm introduced in the 2011 Google Code Jam. As long as the list is not in order, a subset of all elements is randomly permuted. If this subset is optimally chosen each time this is performed, the expected value of the total number of times this operation needs to be done is equal to the number of misplaced elements.

Bogobogosort

is an algorithm that was designed not to succeed before the heat death of the universe on any sizable list. It works by recursively calling itself with smaller and smaller copies of the beginning of the list to see if they are sorted. The best case is a single element, which is always sorted. For other cases, it compares the last element to the maximum element from the previous elements in the list. If the last element is greater or equal, it checks if the order of the copy matches the previous version, copies back if not, and returns. Otherwise, it reshuffles the current copy of the list and goes back to its recursive check.

Bozosort

is another sorting algorithm based on random numbers. If the list is not in order, it picks two items at random and swaps them, then checks to see if the list is sorted. The running time analysis of a bozosort is more difficult, but some estimates are found in H. Gruber's analysis of "perversely awful" randomized sorting algorithms. O(n!) is found to be the expected average case.

Worstsort

is a pessimal sorting algorithm that is guaranteed to complete, assuming that the universe does not burn itself out before completion of the algorithm; however, there is no computable limit to the inefficiency of the sorting algorithm, and therefore it is more pessimal than the other algorithms described herein. The ${\text{worstsort}}$ algorithm is based on a bad sorting algorithm, ${\text{badsort}}$. The badsort algorithm accepts two parameters: $L$, which is the list to be sorted, and $k$, which is a recursion depth. At recursion level $k=0$, ${\text{badsort}}$ merely uses a common sorting algorithm, such as bubblesort, to sort its inputs and return the sorted list. That is to say, ${\text{badsort}}(L,0)={\text{bubblesort}}(L)$. Therefore, badsort's time complexity is $O\left(n^{2}\right)$ if $k=0$. However, for any $k>0$, ${\text{badsort}}(L,k)$ first generates $P$, the list of all permutations of $L$. Then, ${\text{badsort}}$ calculates ${\text{badsort}}(P,k-1)$, and returns the first element of the sorted $P$. To make ${\text{worstsort}}$ truly pessimal, $k$ may be assigned to the value of a computable increasing function such as $f\colon \mathbb {N} \to \mathbb {N}$ (e.g. $f(n)=A(n,n)$, where $A$ is Ackermann's function). Ergo, to sort a list arbitrarily badly, you would execute ${\text{worstsort}}(L,f)={\text{badsort}}(L,f({\text{length}}(L)))$, where ${\text{length}}(L)$ = number of elements in $L$. The resulting algorithm has complexity $\Omega \left(\left(n!^{(f(n))}\right)^{2}\right)$, where $n!^{(m)}=(\dotso ((n!)!)!\dotso )!$ = factorial of $n$ iterated $m$ times. This algorithm can be made as inefficient as we wish by picking a fast enough growing function $f$.

Analysis of Runtime

Here is some Python code to efficiently test the average complexity of Bogosort.

Experimental Runtime of Bogosort

#!/usr/bin/env python3.6

import sys
import time
import random
import multiprocessing as mp
from multiprocessing import Queue
from tqdm import tqdm

import numpy as np
import matplotlib.pyplot as plt
from scipy.special import factorial


WORKCOUNT = 8
TRIALCOUNT = 10


def main():
    listlengths = range(2, 10)
    times = []
    for listlength in listlengths:
        print(listlength)
        trials = {'time': [], 'cycles': []}
        for trial in tqdm(range(TRIALCOUNT)):
            stime = time.time()
            array = random.sample(list(range(listlength)), k=listlength)

            workers = []
            output = Queue()
            counts = Queue()
            for _ in range(WORKCOUNT):
                w = Sorter(array, output, counts)
                workers.append(w)
                w.start()

            result = output.get()

            total_count = 0
            for _ in range(WORKCOUNT):
                total_count += counts.get()

            for _ in range(WORKCOUNT):
                output.put('DEATH')

            for w in workers:
                w.join()

            etime = time.time()
            trials['time'].append(etime - stime)
            trials['cycles'].append(total_count)
        times.append(trials)

    fig, axarr = plt.subplots(2, 1, figsize=(8, 6))

    for i, (length, trial) in enumerate(zip(listlengths, times)):
        axarr[0].plot(np.ones(TRIALCOUNT) * length, np.log(trial['time']), 'rx', alpha=0.4)
    axarr[0].plot(listlengths, [np.log(sum(t['time']) / len(t['time'])) for t in times], label='Average Result')
    axarr[0].legend(loc=0)
    axarr[0].set_xlabel('Length of Initial List')
    axarr[0].set_ylabel('Average Time Elapsed - ln(seconds)')

    for i, (length, trial) in enumerate(zip(listlengths, times)):
        axarr[1].plot(np.ones(TRIALCOUNT) * length, np.log(trial['cycles']), 'rx', alpha=0.4)
    axarr[1].plot(listlengths, [np.log(sum(t['cycles']) / len(t['cycles'])) for t in times], label='Average Result')
    axarr[1].plot(listlengths, np.log([n * factorial(n) for n in listlengths]), label=r'$n \cdot n!$')
    axarr[1].legend(loc=0)
    axarr[1].set_xlabel('Length of Initial List')
    axarr[1].set_ylabel('Average Time Elapsed - ln(Operations)')

    fig.suptitle('Parallel Bogosort')
    plt.tight_layout()
    plt.savefig('bogosort.png')


def is_sorted(some_list):
    for x, y in zip(some_list[:-1], some_list[1:]):
        if x > y:
            return False
    return True


class Sorter(mp.Process):
    def __init__(self, array, output, counts, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.array = array
        self.length = len(array)
        self.output = output
        self.count = 0
        self.counts = counts

    def run(self):
        while True:
            if self.output.empty():
                new_list = random.sample(self.array, k=len(self.array))
                self.count += self.length   # not just one cause we gotta check all items for sorted
                if is_sorted(new_list):
                    self.counts.put(self.count)
                    self.output.put(new_list)
                    break
            else:
                self.counts.put(self.count)
                break

if __name__ == '__main__':
    sys.exit(main())

See also

• Las Vegas algorithm
• Stooge sort

External links

• BogoSort on WikiWikiWeb
• Inefficient sort algorithms
• Bogosort: an implementation that runs on Unix-like systems, similar to the standard sort program.
• Bogosort and jmmcg::bogosort: Simple, yet perverse, C++ implementations of the bogosort algorithm.
• Bogosort NPM package: bogosort implementation for Node.js ecosystem.