root =true

[*]

indent_style =tab

indent_style =space

indent_size =4

end_of_line =lf

charset =utf-8

trim_trailing_whitespace =true

root =true

[*]

indent_style =tab

indent_style =space

indent_size =4

end_of_line =lf

charset =utf-8

trim_trailing_whitespace =true

from .insertion_sortimportinsertion_sort

from .selection_sortimportselection_sort

from .bubble_sortimportbubble_sort

from .pidgeonhole_sortimportpidgeonhole_sort

from .stooge_sortimportstooge_sort

from .cocktail_shaker_sortimportcocktail_shaker_sort

defcocktail_shaker_sort(data):

upper=len(data)-1

whileupper-lower>1andnotno_swap:

forjinrange(lower,upper):

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

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

forjinrange(upper,lower,-1):

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

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

defpidgeonhole_sort(data):

minimum=min(data)

size=max(data)-minimum+1

holes= [0]*size

foritemindata:

holes[item-minimum]+=1

forcountinrange(size):

whileholes[count]>0:

holes[count]-=1

data[i]=count+minimum

defstooge_sort(seq,start=0,end=None):

ifendisNone:

end=len(seq)-1

ifseq[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)

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.sortingimport 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.sortingimport 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.sortingimport stooge_sort

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

print(stooge_sort(arr))

-`array`: Unsorted Array

fromallalgorithms.sortingimport (

bubble_sort,

insertion_sort,

merge_sort,

bubble_sort,

insertion_sort,

merge_sort,

selection_sort,

pidgeonhole_sort,

stooge_sort,

)

classTestSorting(unittest.TestCase):

deftest_merge_sort(self):

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

deftest_selection_sort(self):

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

deftest_pidgeonhole_sort(self):

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

deftest_stooge_sort(self):

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

deftest_cocktail_shaker_sort(self):

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

if__name__=="__main__":

unittest.main()