Editing Stooge sort

{{short description|Inefficient recursive sorting algorithm}}
{{Use dmy dates|date=September 2020}}
{{Infobox Algorithm
|image = [[File:Sorting stoogesort anim.gif]]
|caption = Visualization of Stooge sort (only shows swaps).
|class=[[Sorting algorithm]]
|data=[[Array data structure|Array]]
|time = <math>O(n^{\log 3/\log 1.5})</math>
|space = <math>O(n)</math>
}}
'''Stooge sort''' is a [[Recursion|recursive]] [[sorting algorithm]]. It is notable for its exceptionally poor [[time complexity]] of <math>O(n^{\log 3/\log 1.5})</math> = <math>O(n^{2.7095...})</math>
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]].<ref>{{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}}</ref>

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 ===
<syntaxhighlight lang="javascript">
 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
 }
</syntaxhighlight>

=== Haskell ===
<syntaxhighlight lang="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

</syntaxhighlight>

==References==
<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]

{{sorting}}

{{DEFAULTSORT:Stooge Sort}}
[[Category:Comparison sorts]]
[[Category:Articles with example pseudocode]]

{{comp-sci-stub}}