indent_style = space

indent_size = 4

indent_style = space

indent_size = 4

from .pidgeonhole_sort import pidgeonhole_sort

from .stooge_sort import stooge_sort

from .cocktail_shaker_sort import cocktail_shaker_sort

def cocktail_shaker_sort(data):

upper = len(data) - 1

lower = 0

no_swap = False

while upper - lower > 1 and not no_swap:

no_swap = True

for j in range(lower, upper):

if data[j + 1] < data[j]:

data[j + 1], data[j] = data[j], data[j + 1]

no_swap = False

upper = upper - 1

for j in range(upper, lower, -1):

if data[j - 1] > data[j]:

data[j - 1], data[j] = data[j], data[j - 1]

no_swap = False

lower = lower + 1

return data

def pidgeonhole_sort(data):

minimum = min(data)

size = max(data) - minimum + 1

holes = [0] * size

for item in data:

holes[item - minimum] += 1

i = 0

for count in range(size):

while holes[count] > 0:

holes[count] -= 1

data[i] = count + minimum

i += 1

return data

def stooge_sort(seq, start=0, end=None):

if end is None:

end = len(seq) - 1

if seq[start] > seq[end]:

seq[start], seq[end] = seq[end], seq[start]

if (end - start + 1) > 2:

third = (end - start + 1) // 3

stooge_sort(seq, start, end-third)

stooge_sort(seq, start+third, end)

stooge_sort(seq, start, end-third)

return seq

Cocktail shaker sort, also known as bidirectional bubble sort, cocktail sort, shaker sort (which can also refer to a variant of selection sort), ripple sort, shuffle sort, or shuttle sort, is a variation of bubble sort that is both a stable sorting algorithm and a comparison sort. The algorithm differs from a bubble sort in that it sorts in both directions on each pass through the list. This sorting algorithm is only marginally more difficult to implement than a bubble sort, and solves the problem of turtles in bubble sorts. It provides only marginal performance improvements, and does not improve asymptotic performance; like the bubble sort, it is not of practical interest (insertion sort is preferred for simple sorts), though it finds some use in education.

from allalgorithms.sorting import cocktail_shaker_sort

arr = [77, 2, 10, -2, 1, 7]

print(cocktail_shaker_sort(arr))

- `array`: Unsorted Array

Pigeonhole sorting is a sorting algorithm that is suitable for sorting lists of elements where the number of elements (n) and the length of the range of possible key values (N) are approximately the same. It requires O(n + N) time. It is similar to counting sort, but differs in that it "moves items twice: once to the bucket array and again to the final destination [whereas] counting sort builds an auxiliary array then uses the array to compute each item's final destination and move the item there."

from allalgorithms.sorting import pidgeonhole_sort

arr = [77, 2, 10, -2, 1, 7]

print(pidgeonhole_sort(arr))

- `array`: Unsorted Array

Stooge sort is a recursive sorting algorithm. It is notable for its exceptional bad time complexity of O(n^(log 3 / log 1.5)) = O(n^2.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.

from allalgorithms.sorting import stooge_sort

arr = [77, 2, 10, -2, 1, 7]

print(stooge_sort(arr))

- `array`: Unsorted Array

bubble_sort,

insertion_sort,

merge_sort,

selection_sort,

pidgeonhole_sort,

stooge_sort,

cocktail_shaker_sort

def test_pidgeonhole_sort(self):

self.assertEqual([-44, 1, 2, 3, 7, 19], pidgeonhole_sort([7, 3, 2, 19, -44, 1]))

def test_stooge_sort(self):

self.assertEqual([-44, 1, 2, 3, 7, 19], stooge_sort([7, 3, 2, 19, -44, 1]))

def test_cocktail_shaker_sort(self):

self.assertEqual([-44, 1, 2, 3, 7, 19], cocktail_shaker_sort([7, 3, 2, 19, -44, 1]))