.mypy_cache/

.idea/

from .merge_sortimport*

from .merge_sortimportmerge_sort

from .insertion_sortimportinsertion_sort

from .selection_sortimportselection_sort

from .bubble_sortimportbubble_sort

defbubble_sort(seq):

foriinrange(len(seq)):

forjinrange(len(seq)-i-1):

ifseq[j]>seq[j+1]:

seq[j],seq[j+1]=seq[j+1],seq[j]

definsertion_sort(arr):

iflen(arr)==1:

foriinrange(1,len(arr)):

whilej>=0andarr[j]>arr[i]:

arr.insert(j+1,arr.pop(i))

defmerge_sort(arr):

iflen(arr)==1:

defselection_sort(seq):

foriinrange(len(seq)):

forjinrange(min_idx,len(seq)):

ifseq[j]<seq[min_idx]:

seq[i],seq[min_idx]=seq[min_idx],seq[i]

Bubble sort, sometimes referred to as sinking sort, is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items and swaps them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted. The algorithm, which is a comparison sort, is named for the way smaller or larger elements "bubble" to the top of the list. Although the algorithm is simple, it is too slow and impractical for most problems even when compared to insertion sort. Bubble sort can be practical if the input is in mostly sorted order with some out-of-order elements nearly in position.

from allalgorithms.sortingimport bubble_sort

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

print(bubble_sort(arr))

-`array`: Unsorted Array

Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort.

from allalgorithms.sortingimport insertion_sort

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

print(insertion_sort(arr))

-`array`: Unsorted Array

In computer science, selection sort is a sorting algorithm, specifically an in-place comparison sort. It has O(n^2) time complexity, making it inefficient on large lists, and generally performs worse than the similar insertion sort. Selection sort is noted for its simplicity, and it has performance advantages over more complicated algorithms in certain situations, particularly where auxiliary memory is limited.

from allalgorithms.sortingimport selection_sort

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

print(selection_sort(arr))

-`array`: Unsorted Array

fromallalgorithms.searchesimport (

)

fromallalgorithms.searchesimportbinary_search

classTestSearches(unittest.TestCase):

deftest_binary_search(self):

self.assertEqual(None,binary_search(arr,8))

self.assertEqual(None,binary_search(arr,-1))

if__name__=='__main__':

unittest.main()