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 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 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
print("select_sorted_list1: " + str(select_sorted_list1))
print("select_sorted_list2: " + str(select_sorted_list2))
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 __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 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 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 shell(*args): return shell_sort(*args)
else:
print "Heap Sort incorrect."
except:
print "Heapsort function errored or is incomplete."
try:
from bucket import bucket
if(bucket(list(nums)) == sortedNums):
print "Bucket Sort success"
else:
print "Bucket Sort incorrect"
except:
print "Bucketsort function errored or is incomplete"
try:
from shell import shell_sort
if(shell_sort(list(nums)) == sortedNums):
print "Shell Sort success"
else:
print "Shell Sort incorrect"
except:
print "ShellSort function errored or is incomplete"
try:
from brick import brick_sort
if(brick_sort(list(nums)) == sortedNums):
print "Brick Sort success"
else:
print "Brick Sort incorrect"
except:
print "BrickSort function errored or is incomplete"
def shell(*args):
return shell_sort(*args)