from utils import sorting_test
class InsertionSort:
@staticmethod
def sort(arr: list) -> list:
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
return arr
if __name__ == '__main__':
i_s = InsertionSort()
sorting_test(i_s.sort)
def sort(self, arr: list) -> list:
self.arr = arr
self.quick_sort(0, len(self.arr) - 1)
return self.arr
def quick_sort(self, low: int, high: int) -> None:
if low < high:
part = self.partition(low, high)
self.quick_sort(low, part - 1)
self.quick_sort(part + 1, high)
def partition(self, low: int, high: int) -> int:
piv = self.arr[high]
ind = low
for i in range(low, high):
if self.arr[i] <= piv:
self.arr[ind], self.arr[i] = self.arr[i], self.arr[ind]
ind += 1
self.arr[ind], self.arr[high] = self.arr[high], self.arr[ind]
return ind
if __name__ == '__main__':
qs = QuickSort()
sorting_test(qs.sort)
def largest_check(arr: list, largest: int, other: int, heap_size: int) -> int:
if other < heap_size and arr[other] > arr[largest]:
largest = other
return largest
def heapify(self, arr: list, ind: int, heap_size: int) -> list:
left = 2 * ind + 1
right = 2 * ind + 2
largest = ind
largest = self.largest_check(arr, largest, left, heap_size)
largest = self.largest_check(arr, largest, right, heap_size)
if largest != ind:
arr[largest], arr[ind] = arr[ind], arr[largest]
arr = self.heapify(arr, largest, heap_size)
return arr
def build_heap(self, arr: list) -> list:
for i in range(int(len(arr)), -1, -1):
self.heapify(arr, i, len(arr))
return arr
if __name__ == '__main__':
hs = HeapSort()
sorting_test(hs.sort)
middle = len(arr) // 2
left = arr[:middle]
right = arr[middle:]
left = self.sort(left)
right = self.sort(right)
result = self.merge(left, right)
return result
@staticmethod
def merge(left: list, right: list) -> list:
result = []
while left and right:
if left[0] < right[0]:
result.append(left.pop(0))
else:
result.append(right.pop(0))
if left:
result += left
elif right:
result += right
return result
if __name__ == '__main__':
ms = MergeSort()
sorting_test(ms.sort)
from utils import sorting_test
class CountingSort:
@staticmethod
def sort(arr: list) -> list:
counting_arr = [arr.count(i) for i in range(0, max(arr) + 1)]
offset = 0
for i, num in enumerate(counting_arr):
arr[offset:offset + num] = [i for _ in range(num)]
offset += num
return arr
if __name__ == '__main__':
cs = CountingSort()
sorting_test(cs.sort)
from utils import sorting_test
class RadixSort:
@staticmethod
def sort(arr: list):
rad = 10
while True:
rad_list = [[] for _ in range(10)]
for num in arr:
r = num % rad // (rad // 10)
rad_list[r].append(num)
if not any(rad_list[1:]):
return rad_list[0]
arr.clear()
for r_list in rad_list:
if r_list:
arr += r_list
rad *= 10
if __name__ == '__main__':
rs = RadixSort()
sorting_test(rs.sort)
@staticmethod
def shaker_sort(array: list) -> list:
left = 0
right = len(array) - 1
while left <= right:
for i in range(left, right):
if array[i] > array[i + 1]:
array[i], array[i + 1] = array[i + 1], array[i]
right -= 1
for i in range(right, left, -1):
if array[i] < array[i - 1]:
array[i], array[i - 1] = array[i - 1], array[i]
left += 1
return array
if __name__ == '__main__':
b = BubbleSort()
print('Simple bubble sort test:')
sorting_test(b.sort)
print('Modified bubble sort test:')
sorting_test(b.modified_sort)
print('Shaker sort test:')
sorting_test(b.shaker_sort)
from utils import sorting_test
class SelectionSort:
@staticmethod
def sort(arr: list) -> list:
for i in range(0, len(arr)):
min_ind = i
ch_m = False
for j in range(i + 1, len(arr)):
if arr[min_ind] > arr[j]:
min_ind = j
ch_m = True
if ch_m:
arr[i], arr[min_ind] = arr[min_ind], arr[i]
return arr
if __name__ == '__main__':
ss = SelectionSort()
sorting_test(ss.sort)