Stooge sort

{{Infobox Algorithm

|image = File:Sorting stoogesort anim.gif

|caption = Visualization of Stooge sort (only shows swaps).

|time = $O(n^{\log 3/\log 1.5})$

|space = $O(n)$

}}

Stooge sort is a recursive sorting algorithm. It is notable for its exceptionally poor time complexity of $O(n^{\log 3/\log 1.5})$ = $O(n^{2.7095...})$

The algorithm's running time is thus slower compared to reasonable sorting algorithms, and is slower than bubble sort, a canonical example of a fairly inefficient sort. It is, however, more efficient than Slowsort. The name comes from The Three Stooges.{{cite web |url=https://courses.cs.washington.edu/courses/cse373/13wi/lectures/02-22/18-sorting1-bogo-stooge-bubble.pdf |title= CSE 373 |website= courses.cs.washington.edu|format=PDF|access-date=2020-09-14}}

The algorithm is defined as follows:

If the value at the start is larger than the value at the end, swap them.
If there are three or more elements in the list, then:
Stooge sort the initial 2/3 of the list
Stooge sort the final 2/3 of the list
Stooge sort the initial 2/3 of the list again

It is important to get the integer sort size used in the recursive calls by rounding the 2/3 upwards, e.g. rounding 2/3 of 5 should give 4 rather than 3, as otherwise the sort can fail on certain data.

Implementation

= Pseudocode =

function stoogesort(array L, i = 0, j = length(L)-1){

if L[i] > L[j] then // If the leftmost element is larger than the rightmost element

swap(L[i],L[j]) // Then swap them

if (j - i + 1) > 2 then // If there are at least 3 elements in the array

t = floor((j - i + 1) / 3)

stoogesort(L, i, j-t) // Sort the first 2/3 of the array

stoogesort(L, i+t, j) // Sort the last 2/3 of the array

stoogesort(L, i, j-t) // Sort the first 2/3 of the array again

return L

}

= Haskell =

-- Not the best but equal to above

stoogesort :: (Ord a) => [a] -> [a]

stoogesort [] = []

stoogesort src = innerStoogesort src 0 ((length src) - 1)

innerStoogesort :: (Ord a) => [a] -> Int -> Int -> [a]

innerStoogesort src i j

| (j - i + 1) > 2 = src

| otherwise = src'

where

src' = swap src i j -- need every call

t = floor (fromIntegral (j - i + 1) / 3.0)

src'' = innerStoogesort src' i (j - t)

src' = innerStoogesort src (i + t) j

src' = innerStoogesort src i (j - t)

swap :: (Ord a) => [a] -> Int -> Int -> [a]

swap src i j

| a > b = replaceAt (replaceAt src j a) i b

| otherwise = src

where

a = src !! i

b = src !! j

replaceAt :: [a] -> Int -> a -> [a]

replaceAt (x:xs) index value

| index == 0 = value : xs

| otherwise = x : replaceAt xs (index - 1) value

References

=Sources=

{{cite web|url=https://xlinux.nist.gov/dads/HTML/stoogesort.html|title=stooge sort|last=Black|first=Paul E.|work=Dictionary of Algorithms and Data Structures|publisher=National Institute of Standards and Technology|accessdate=18 June 2011}}
{{Introduction to Algorithms|edition=2|chapter=Problem 7-3|pages=161–162}}

External links

[http://cg.scs.carleton.ca/~morin/misc/sortalg/ Sorting Algorithms (including Stooge sort)]
[http://impomatic.blogspot.com/2008/01/stooge-sort.html Stooge sort – implementation and comparison]

Category:Comparison sorts

Category:Articles with example pseudocode