# Stooge sort

Class Visualization of Stooge sort (only shows swaps). Sorting algorithm Array O(nlog 3/log 1.5) O(n)

Stooge sort is a recursive sorting algorithm. It is notable for its exceptionally bad time complexity of O(nlog 3 / log 1.5 ) = O(n2.7095...). The running time of the algorithm 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.[1]

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

``` 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
L[i] ↔ L[j]           // Swap the leftmost element and the rightmost element
if (j - i + 1) > 2 then       // If there are at least 3 elements in the array
t = floor((j - i + 1) / 3) // Rounding down
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
}
```
```-- 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

1. ^ "CSE 373" (PDF). courses.cs.washington.edu. Retrieved 14 September 2020.