end -= 1
HeapSort._sift_down(data, 0, end)
return data
@staticmethod
def _heapify(data, count):
start = (count - 2) // 2
while start >= 0:
HeapSort._sift_down(data, start, count - 1)
start -= 1
@staticmethod
def _sift_down(data, start, end):
root = start
while (root * 2 + 1) <= end:
child = root * 2 + 1
swap = root
if data[swap] < data[child]:
swap = child
if (child + 1) <= end and data[swap] < data[child + 1]:
swap = child + 1
if swap != root:
data[root], data[swap] = data[swap], data[root]
root = swap
else:
return
if __name__ == '__main__':
print_tests(HeapSort)
class QuickSort:
"""
Time complexity:
- Worst case: O(nˆ2)
- Best case: O(nlogn)
- Average case: O(nlogn)
Space complexity:
- O(logn)
"""
@staticmethod
def sort(data):
if data is None:
raise TypeError("data should not be None.")
if len(data) < 2:
return data
pivot_idx = random.randint(0, len(data) - 1)
pivot = data[pivot_idx]
smaller = [i for i in data[:pivot_idx] if i < pivot
] + [i for i in data[pivot_idx + 1:] if i < pivot]
greater = [i for i in data[:pivot_idx] if i >= pivot
] + [i for i in data[pivot_idx + 1:] if i >= pivot]
return QuickSort.sort(smaller) + [pivot] + QuickSort.sort(greater)
if __name__ == '__main__':
print_tests(QuickSort)
MergeSort.sort(left)
MergeSort.sort(right)
i = j = k = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
data[k] = left[i]
i += 1
else:
data[k] = right[j]
j += 1
k += 1
while i < len(left):
data[k] = left[i]
i += 1
k += 1
while j < len(right):
data[k] = right[j]
j += 1
k += 1
return data
if __name__ == '__main__':
print_tests(MergeSort)
def sort(data):
if data is None:
raise TypeError("data should not be None.")
if len(data) < 2:
return data
for i in range(len(data) - 1):
min_idx = SelectionSort._find_min_idx(data[i:])
data[i], data[min_idx+i] = data[min_idx+i], data[i]
return data
@staticmethod
def _find_min_idx(items):
if len(items) < 1:
return None
min_item = items[0]
min_idx = 0
for idx in range(1, len(items)):
if items[idx] < min_item:
min_item = items[idx]
min_idx = idx
return min_idx
if __name__ == '__main__':
print_tests(SelectionSort)
"""
@staticmethod
def sort(data) -> list:
if data is None:
raise TypeError("data should not be None.")
if len(data) < 2:
return data
# find out the max number in data
max_num = max(data)
min_num = min(data)
aux = [0] * (max_num - min_num + 1)
for i in range(len(data)):
aux_idx = data[i] - min_num
aux[aux_idx] += 1
k = 0
for j in range(len(aux)):
if aux[j] > 0:
for _ in range(aux[j]):
data[k] = j + min_num
k += 1
return data
if __name__ == '__main__':
print_tests(CountingSort)
from sorting.utils import print_tests
class InsertionSort:
"""
Time complexity:
- Worst case: O(nˆ2)
- Best case: O(n)
- Average case: O(nˆ2)
Space complexity:
- O(1)
"""
@staticmethod
def sort(data):
if data is None:
raise TypeError("data should not be None.")
if len(data) < 2:
return data
for i in range(1, len(data)):
for j in range(i):
if data[j] > data[i]:
data[j], data[i] = data[i], data[j]
return data
if __name__ == '__main__':
print_tests(InsertionSort)
from sorting.utils import print_tests
class BubbleSort:
"""
Time complexity:
- worst case: O(nˆ2)
- best case: O(n)
- average case: O(nˆ2)
Space complexity:
- O(1)
"""
@staticmethod
def sort(data):
if data is None:
raise TypeError("data should not be None.")
if len(data) < 2:
return data
for end in range(len(data) - 1, -1, -1):
for i in range(end):
if data[i] > data[i + 1]:
data[i + 1], data[i] = data[i], data[i + 1]
return data
if __name__ == "__main__":
print_tests(BubbleSort)