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