def sorting_int_semi_rand():
print("ЧАСТИЧНО УПОРЯДОЧЕННЫЕ ЦЕЛЫЕ ЧИСЛА")
for number in ranges:
short = np.zeros(number, np.int64)
for i in range(len(short)):
short[i] = i
random.shuffle(short[int(len(short) / 5):int(2 * len(short) / 5)])
random.shuffle(short[int(3 * len(short) / 5):int(4 * len(short) / 5)])
# start = perf_counter_ns()
# bubble_sort(short.copy())
# end = perf_counter_ns()
# bubble_time = end - start
# print("Сортировка пузырьком с размером массива: ", number, " Время: ", bubble_time)
start = perf_counter_ns()
shell_sort(short.copy())
end = perf_counter_ns()
shell_time = end - start
print("Сортировка Шелла с размером массива: ", number, " Время: ",
shell_time)
start = perf_counter_ns()
quick_sort(short.copy())
end = perf_counter_ns()
quick_time = end - start
print("Быстрая сортировка с размером массива: ", number, " Время: ",
quick_time)
start = perf_counter_ns()
merge_sort(short.copy())
end = perf_counter_ns()
merge_time = end - start
print("Сортировка слиянием с размером массива: ", number, " Время: ",
merge_time)
start = perf_counter_ns()
heap_sort(short.copy())
end = perf_counter_ns()
heap_time = end - start
print("Сортировка кучей с размером массива: ", number, " Время: ",
heap_time)
start = perf_counter_ns()
radix_sort(short.copy())
end = perf_counter_ns()
radix_time = end - start
print("Поразрядная сортировка с размером массива: ", number,
" Время: ", radix_time)
start = perf_counter_ns()
sorted(short.copy())
end = perf_counter_ns()
sorted_time = end - start
print("Встроенная в язык сортировка с размером массива: ", number,
" Время: ", sorted_time)
return 0
def test_heap_sort(self):
rand_list_copy = self.rand_list[:]
rand_list_copy.sort()
print("rand list = {self.rand_list}".format(self = self))
heap_sort(self.rand_list)
print("rand list sorted = {self.rand_list}".format(self = self))
print('#' * 20)
self.assertEqual(rand_list_copy, self.rand_list)
def sorting_str_same_rand():
print("СТРОКИ ИЗ ОДИНАКОВЫХ ЭЛЕМЕНТОВ")
for number in ranges:
short = list()
symbol = random.choice(string.ascii_lowercase)
for i in range(number):
short.append(''.join(symbol))
# start = perf_counter_ns()
# bubble_sort(short.copy())
# end = perf_counter_ns()
# bubble_time = end - start
# print("Сортировка пузырьком с размером массива: ", number, " Время: ", bubble_time)
start = perf_counter_ns()
shell_sort(short.copy())
end = perf_counter_ns()
shell_time = end - start
print("Сортировка Шелла с размером массива: ", number, " Время: ",
shell_time)
start = perf_counter_ns()
quick_sort(short.copy())
end = perf_counter_ns()
quick_time = end - start
print("Быстрая сортировка с размером массива: ", number, " Время: ",
quick_time)
start = perf_counter_ns()
merge_sort(short.copy())
end = perf_counter_ns()
merge_time = end - start
print("Сортировка слиянием с размером массива: ", number, " Время: ",
merge_time)
start = perf_counter_ns()
heap_sort(short.copy())
end = perf_counter_ns()
heap_time = end - start
print("Сортировка кучей с размером массива: ", number, " Время: ",
heap_time)
start = perf_counter_ns()
str_radix_sort(short.copy())
end = perf_counter_ns()
radix_time = end - start
print("Поразрядная сортировка с размером массива: ", number,
" Время: ", radix_time)
start = perf_counter_ns()
sorted(short.copy())
end = perf_counter_ns()
sorted_time = end - start
print("Встроенная в язык сортировка с размером массива: ", number,
" Время: ", sorted_time)
return 0
def sorting_short_rand():
print("РАНДОМНЫЕ МАЛЕНЬКИЕ ЧИСЛА")
for number in ranges:
short = np.zeros(number, np.int64)
for i in range(len(short)):
short[i] = i % 10
random.shuffle(short)
# start = perf_counter_ns()
# bubble_sort(short.copy())
# end = perf_counter_ns()
# bubble_time = end - start
# print("Сортировка пузырьком с размером массива: ", number, " Время: ", bubble_time)
start = perf_counter_ns()
shell_sort(short.copy())
end = perf_counter_ns()
shell_time = end - start
print("Сортировка Шелла с размером массива: ", number, " Время: ",
shell_time)
start = perf_counter_ns()
quick_sort(short.copy())
end = perf_counter_ns()
quick_time = end - start
print("Быстрая сортировка с размером массива: ", number, " Время: ",
quick_time)
start = perf_counter_ns()
merge_sort(short.copy())
end = perf_counter_ns()
merge_time = end - start
print("Сортировка слиянием с размером массива: ", number, " Время: ",
merge_time)
start = perf_counter_ns()
heap_sort(short.copy())
end = perf_counter_ns()
heap_time = end - start
print("Сортировка кучей с размером массива: ", number, " Время: ",
heap_time)
start = perf_counter_ns()
radix_sort(short.copy())
end = perf_counter_ns()
radix_time = end - start
print("Поразрядная сортировка с размером массива: ", number,
" Время: ", radix_time)
start = perf_counter_ns()
sorted(short.copy())
end = perf_counter_ns()
sorted_time = end - start
print("Встроенная в язык сортировка с размером массива: ", number,
" Время: ", sorted_time)
return 0
def test_heap_sort():
ARR_SIZE = 20
random_arr = [None] * ARR_SIZE
for i in range(ARR_SIZE):
random_arr[i] = randrange(1, 100)
print("Array before heap sort: {}".format(random_arr))
heap.heap_sort(random_arr)
print("Array after heap sort: {}".format(random_arr))
def sorting_int_same_rand():
print("МАССИВ ИЗ ОДИНАКОВЫХ ЦЕЛЫХ ЧИСЕЛ")
for number in ranges:
short = np.zeros(number, np.int64)
for i in range(len(short)):
short[i] = 654
# start = perf_counter_ns()
# bubble_sort(short.copy())
# end = perf_counter_ns()
# bubble_time = end - start
# print("Сортировка пузырьком с размером массива: ", number, " Время: ", bubble_time)
start = perf_counter_ns()
shell_sort(short.copy())
end = perf_counter_ns()
shell_time = end - start
print("Сортировка Шелла с размером массива: ", number, " Время: ",
shell_time)
start = perf_counter_ns()
quick_sort(short.copy())
end = perf_counter_ns()
quick_time = end - start
print("Быстрая сортировка с размером массива: ", number, " Время: ",
quick_time)
start = perf_counter_ns()
merge_sort(short.copy())
end = perf_counter_ns()
merge_time = end - start
print("Сортировка слиянием с размером массива: ", number, " Время: ",
merge_time)
start = perf_counter_ns()
heap_sort(short.copy())
end = perf_counter_ns()
heap_time = end - start
print("Сортировка кучей с размером массива: ", number, " Время: ",
heap_time)
start = perf_counter_ns()
radix_sort(short.copy())
end = perf_counter_ns()
radix_time = end - start
print("Поразрядная сортировка с размером массива: ", number,
" Время: ", radix_time)
start = perf_counter_ns()
sorted(short.copy())
end = perf_counter_ns()
sorted_time = end - start
print("Встроенная в язык сортировка с размером массива: ", number,
" Время: ", sorted_time)
return 0
def test_merge_sort(fixtures):
for fixture in fixtures:
assert merge_sort(fixture[0]) == fixture[1]
assert quick_sort(fixture[0]) == fixture[1]
assert insertion_sort(fixture[0]) == fixture[1]
assert bubble_sort(fixture[0]) == fixture[1]
assert heap_sort(fixture[0]) == fixture[1]
def test_heap():
A = [i for i in range(100, 0, -1)]
heap_sort(A)
assert A == B
def test_heap_sort(self):
self.assertEqual(heap_sort(self.RAW_DATA), self.REF_DATA)
def __init__(self, name, listing):
# Initilization steps
self.name = name
listing_copy = listing
listing_copy2 = listing
self.listing = listing_copy
##################################################
# For each algorithm, the accuracy, time, and list
# will be tracked using the methods shown below
##################################################
# Python sort will be used as the master sort
listing_copy_py = listing_copy
start = timer()
self.python_sorted_list = python_sort(listing_copy_py)
end = timer()
self.python_sorted_time = end - start
# Bubble Sort will be tested against python sort
listing_copy_bu = listing_copy
start = timer()
self.bubble_sorted_list = bubble_sort(listing_copy_bu)
end = timer()
self.bubble_sort_accurate = False
if self.bubble_sorted_list == self.python_sorted_list:
self.bubble_sort_accurate = True
self.bubble_sort_time = end - start
# Selection sort will be tested against python sort
listing_copy_sel = listing_copy
start = timer()
self.selection_sorted_list = selection_sort(listing_copy_sel)
end = timer()
self.selection_sort_accurate = False
if self.selection_sorted_list == self.python_sorted_list:
self.selection_sort_accurate = True
self.selection_sort_time = end - start
# Merge sort will be tested against python sort
listing_copy_mer = listing_copy
start = timer()
self.merge_sorted_list = merge_sort(listing_copy_mer)
end = timer()
self.merge_sort_accurate = False
if self.merge_sorted_list == self.python_sorted_list:
self.merge_sort_accurate == True
self.merge_sort_time = end - start
#Shell root sort will be tested against python sort
listing_copy_she = listing_copy
start = timer()
self.shell_sorted_list = shell_sort(listing_copy_she)
end = timer()
self.shell_accurate = False
if self.shell_sorted_list == self.python_sorted_list:
self.shell_accurate = True
self.shell_time = end - start
#Insertion sort will be tested against python sort
listing_copy_ins = listing_copy
start = timer()
self.insertion_sorted_list = insertion_sort(listing_copy_ins)
end = timer()
self.insertion_accurate = False
if self.insertion_sorted_list == self.python_sorted_list:
self.insertion_accurate = True
self.insertion_time = end - start
# Heap sort will be tested against python sort
listing_copy_hea = listing_copy
start = timer()
self.heap_sorted_list = heap_sort(listing_copy_hea)
end = timer()
self.heap_accurate = False
if self.heap_sorted_list == self.python_sorted_list:
self.heap_accurate = True
self.heap_time = end - start
#Strand sort will be tested against python sort
listing_copy_strand = listing_copy2
start = timer()
self.strand_sorted_list = strand_sort(listing_copy_strand)
end = timer()
self.strand_accurate = False
if self.strand_sorted_list == self.python_sorted_list:
self.strand_root_accurate = True
self.strand_time = end - start
def test_heap_sort(self):
l = [16, 14, 10, 8, 7, 9, 3, 2, 4, 1]
heap_sort(l)
self.assertEqual([1, 2, 3, 4, 7, 8, 9, 10, 14, 16], l)
print("select_sorted_list3: " + str(select_sorted_list3))
# 插入排序
list1, list2, list3 = get_list()
insert_sorted_list1 = insert_sort(list1)
insert_sorted_list2 = insert_sort(list2)
insert_sorted_list3 = insert_sort(list3)
print("insert_sorted_list1: " + str(insert_sorted_list1))
print("insert_sorted_list2: " + str(insert_sorted_list2))
print("insert_sorted_list3: " + str(insert_sorted_list3))
# 希尔排序
list1, list2, list3 = get_list()
shell_sorted_list1 = shell_sort(list1)
shell_sorted_list2 = shell_sort(list2)
shell_sorted_list3 = shell_sort(list3)
print("shell_sorted_list1: " + str(shell_sorted_list1))
print("shell_sorted_list2: " + str(shell_sorted_list2))
print("shell_sorted_list3: " + str(shell_sorted_list3))
# 堆排序
list1, list2, list3 = get_list()
heap_sorted_list1 = heap_sort(list1)
heap_sorted_list2 = heap_sort(list2)
heap_sorted_list3 = heap_sort(list3)
print("heap_sorted_list1: " + str(heap_sorted_list1))
print("heap_sorted_list2: " + str(heap_sorted_list2))
print("heap_sorted_list3: " + str(heap_sorted_list3))
def test_heap_sort_single_elem(self):
lst = [5]
heap_sort(lst)
self.assertEqual([5], lst)
def sorting_date_semi_rand():
print("ЧАСТИЧНО УПОРЯДОЧЕННЫЕ ДАТЫ")
for number in ranges:
short = list()
for i in range(number):
date = Date(YYYY=1000,
MM=random.randint(1, 12),
DD=random.randint(1, 28))
short.append(date)
short = np.asarray(short)
short[0:int(len(short) / 5)] = sorted(short[0:int(len(short) / 5)])
short[int(2 * len(short) / 5):int(3 * len(short) / 5)] = sorted(
short[int(2 * len(short) / 5):int(3 * len(short) / 5)])
short[int(4 * len(short) / 5):int(5 * len(short) / 5)] = sorted(
short[int(4 * len(short) / 5):int(5 * len(short) / 5)])
# start = perf_counter_ns()
# bubble_sort(short.copy())
# end = perf_counter_ns()
# bubble_time = end - start
# print("Сортировка пузырьком с размером массива: ", number, " Время: ", bubble_time)
start = perf_counter_ns()
shell_sort(short.copy())
end = perf_counter_ns()
shell_time = end - start
print("Сортировка Шелла с размером массива: ", number, " Время: ",
shell_time)
start = perf_counter_ns()
quick_sort(short.copy())
end = perf_counter_ns()
quick_time = end - start
print("Быстрая сортировка с размером массива: ", number, " Время: ",
quick_time)
start = perf_counter_ns()
merge_sort(short.copy())
end = perf_counter_ns()
merge_time = end - start
print("Сортировка слиянием с размером массива: ", number, " Время: ",
merge_time)
start = perf_counter_ns()
heap_sort(short.copy())
end = perf_counter_ns()
heap_time = end - start
print("Сортировка кучей с размером массива: ", number, " Время: ",
heap_time)
start = perf_counter_ns()
date_radix_sort(short.copy())
end = perf_counter_ns()
radix_time = end - start
print("Поразрядная сортировка с размером массива: ", number,
" Время: ", radix_time)
start = perf_counter_ns()
sorted(short.copy())
end = perf_counter_ns()
sorted_time = end - start
print("Встроенная в язык сортировка с размером массива: ", number,
" Время: ", sorted_time)
return 0
def sorting_str_semi_rand():
print("ЧАСТИЧНО УПОРЯДОЧЕННЫЕ СТРОКИ")
for number in ranges:
short = list()
for i in range(number):
short.append(''.join(
random.choice(string.ascii_lowercase)
for _ in range(np.random.randint(1, 10))))
short = np.asarray(short)
short[0:int(len(short) / 5)] = sorted(short[0:int(len(short) / 5)])
short[int(2 * len(short) / 5):int(3 * len(short) / 5)] = sorted(
short[int(2 * len(short) / 5):int(3 * len(short) / 5)])
short[int(4 * len(short) / 5):int(5 * len(short) / 5)] = sorted(
short[int(4 * len(short) / 5):int(5 * len(short) / 5)])
newshort = list()
for j in range(len(short)):
newshort.append(short[j])
# start = perf_counter_ns()
# bubble_sort(newshort.copy())
# end = perf_counter_ns()
# bubble_time = end - start
# print("Сортировка пузырьком с размером массива: ", number, " Время: ", bubble_time)
start = perf_counter_ns()
shell_sort(newshort.copy())
end = perf_counter_ns()
shell_time = end - start
print("Сортировка Шелла с размером массива: ", number, " Время: ",
shell_time)
start = perf_counter_ns()
quick_sort(newshort.copy())
end = perf_counter_ns()
quick_time = end - start
print("Быстрая сортировка с размером массива: ", number, " Время: ",
quick_time)
start = perf_counter_ns()
merge_sort(newshort.copy())
end = perf_counter_ns()
merge_time = end - start
print("Сортировка слиянием с размером массива: ", number, " Время: ",
merge_time)
start = perf_counter_ns()
heap_sort(newshort.copy())
end = perf_counter_ns()
heap_time = end - start
print("Сортировка кучей с размером массива: ", number, " Время: ",
heap_time)
start = perf_counter_ns()
str_radix_sort(newshort.copy())
end = perf_counter_ns()
radix_time = end - start
print("Поразрядная сортировка с размером массива: ", number,
" Время: ", radix_time)
start = perf_counter_ns()
sorted(newshort.copy())
end = perf_counter_ns()
sorted_time = end - start
print("Встроенная в язык сортировка с размером массива: ", number,
" Время: ", sorted_time)
return 0
def sorting_date_same_rand():
print("МАССИВ ИЗ ОДИНАКОВЫХ ДАТ")
for number in ranges:
date = Date(YYYY=1000,
MM=random.randint(1, 12),
DD=random.randint(1, 28))
short = list()
for i in range(number):
short.append(date)
short = np.asarray(short)
# start = perf_counter_ns()
# bubble_sort(short.copy())
# end = perf_counter_ns()
# bubble_time = end - start
# print("Сортировка пузырьком с размером массива: ", number, " Время: ", bubble_time)
start = perf_counter_ns()
shell_sort(short.copy())
end = perf_counter_ns()
shell_time = end - start
print("Сортировка Шелла с размером массива: ", number, " Время: ",
shell_time)
start = perf_counter_ns()
quick_sort(short.copy())
end = perf_counter_ns()
quick_time = end - start
print("Быстрая сортировка с размером массива: ", number, " Время: ",
quick_time)
start = perf_counter_ns()
merge_sort(short.copy())
end = perf_counter_ns()
merge_time = end - start
print("Сортировка слиянием с размером массива: ", number, " Время: ",
merge_time)
start = perf_counter_ns()
heap_sort(short.copy())
end = perf_counter_ns()
heap_time = end - start
print("Сортировка кучей с размером массива: ", number, " Время: ",
heap_time)
start = perf_counter_ns()
date_radix_sort(short.copy())
end = perf_counter_ns()
radix_time = end - start
print("Поразрядная сортировка с размером массива: ", number,
" Время: ", radix_time)
start = perf_counter_ns()
sorted(short.copy())
end = perf_counter_ns()
sorted_time = end - start
print("Встроенная в язык сортировка с размером массива: ", number,
" Время: ", sorted_time)
return 0
def test_case01(self):
A = [2, 3, 1]
heap.heap_sort(A)
print A
self.assertTrue(A == [1, 2, 3])
def test_heap_sort_0_elem(self):
lst = []
heap_sort(lst)
self.assertEqual([], lst)
def test_case02(self):
A = [4, 1, 3, 2, 16, 9, 10, 14, 8, 7]
heap.heap_sort(A)
print A
self.assertTrue(A == [1, 2, 3, 4, 7, 8, 9, 10, 14, 16])
before = time.time()
choiceStr = ""
if choice == 1:
choiceStr = "insertion sort"
insertion_sort(integers)
elif choice == 2:
choiceStr = "merge sort"
p = 0
r = len(integers)
merge_sort(integers, p, r - 1)
elif choice == 3:
choiceStr = "heap sort"
heap_sort(integers)
elif choice == 4:
choiceStr = "quick sort"
quick_sort(integers, 0, len(integers) - 1)
elif choice == 5:
choiceStr = "counting sort"
integers = counting_sort(integers, len(integers))
elif choice == 6:
choiceStr = "default sort(timsort - a hybrid of merge and insertion)"
integers = sorted(integers)
else:
choiceStr = "no such sort"
after = time.time()
timediff = round(float(after - before), 2)
if sorted(integers) == integers:
print("")
print("Starting Quick Sort - ASC")
st = time.time()
quick_sort(asc_array)
print('Quick sort took %.3f seconds' % ((time.time() - st)))
print("")
print("Starting Quick Sort - DESC")
st = time.time()
quick_sort(desc_array)
print('Quick sort took %.3f seconds' % ((time.time() - st)))
# Heap Sort
print("-----------------")
print("Starting Heap Sort - RAND")
st = time.time()
heap_sort(rand_array)
print('Heap sort took %.3f seconds' % ((time.time() - st)))
print("")
print("Starting Heap Sort - ASC")
st = time.time()
heap_sort(asc_array)
print('Heap sort took %.3f seconds' % ((time.time() - st)))
print("")
print("Starting Heap Sort - DESC")
st = time.time()
heap_sort(desc_array)
print('Heap sort took %.3f seconds' % ((time.time() - st)))
