Slowsort

Slowsort is an esoteric sort based on the concept of "multiply and surrender", opposite to "divide and conquer". it runs in $$O(n^{O(\log n)})$$ time, uses $$O(n)$$ stack memory, and is unstable.

Algorithm
Slowsort works as follows:


 * 1) Recursively sort the first and second halves.
 * 2) Compare the last elements of the now-sorted halves, moving the larger one to the end.
 * 3) Recursively sort the rest of the array, not including the last element.

Pseudocode
procedure slow_sort(array arr,int i,int j) do if i >= j do return end if int mid = middle(i,j) slow_sort(arr,i,mid) slow_sort(arr,mid + 1,j) if arr[mid] > arr[j] do swap arr[mid] and arr[j] end if slow_sort(arr,i,j - 1) end

Sillysort
In Sillysort, the third step of Slowsort's algorithm does not include the first element instead of the last element.

Snuffle Sort
Created by _fluffy, this is defined as follows:


 * 1) Swap the first and last elements if they are out of order.
 * 2) Repeat the following steps $$\left\lfloor\frac{n}{2}\right\rfloor$$ times, where $$n$$ is the length of the array:
 * 3) Snuffle Sort the first $$\left\lfloor\frac{n + 1}{2}\right\rfloor$$ of the array.
 * 4) Snuffle Sort the last $$\left\lceil\frac{n + 1}{2}\right\rceil$$ of the array.

Note the floor and ceiling functions: they only affect arrays of even lengths. The algorithm also performs a complexity of $$O(n^{O(\log n)})$$ best, average, and worst case runtime.