def start_algorithm():
global data
if not data: return
if(alg_menu.get() == 'Quick sort'):
quick_sort(data, 0,len(data) - 1,draw_data,speed_scale.get())
elif alg_menu.get() == 'Bubble sort':
bubble_sort(data,draw_data,speed_scale.get())
elif alg_menu.get() == 'Merge sort':
merge_sort(data, draw_data, speed_scale.get())
elif alg_menu.get() == 'Insertion sort':
insertion_sort(data, draw_data, speed_scale.get())
draw_data(data,[['green'] for x in range(len(data))])
def test_run_benchmarks():
generators_list = [random_generator, almost_sorted_generator, reverse_sorted_generator, few_uniq_generator]
# generators_list = [random_generator, reverse_sorted_generator]
# generators_list = [few_uniq_generator]
# sort_func_list = [bubble_sort, insertion_sort, insertion_sort2]
sort_func_list = [bubble_sort, insertion_sort, insertion_sort2, selection_sort, shell_sort, \
merge_sort, quick_sort, lambda x: quick_sort(x, splitByMedian), heap_sort,
lambda x: radix_sort(x, 1000), intro_sort, timsort]
# sort_func_list = [quick_sort, \
# lambda x: quick_sort(x, partition_func=splitByMiddleElement), \
# lambda x: quick_sort(x, partition_func=splitByMedian), \
# lambda x: quick_sort(x, leaf_sort_func=leaf_insertion_sort)]
# sort_func_list = [radix_sort, \
# lambda x: radix_sort(x, 2), \
# lambda x: radix_sort(x, 100),
# lambda x: radix_sort(x, 1000),
# lambda x: radix_sort(x, 10000)
# ]
for generator in generators_list:
print generator
for sort_func in sort_func_list:
run_until(sort_func, 0.5, generator)
for generator in generators_list:
print generator
for list_size in sorted(result[generator]):
sys.stdout.write(str(list_size) + "\t")
for sort_func in sort_func_list:
if sort_func in result[generator][list_size]:
sys.stdout.write("{:.3f}\t".format(result[generator][list_size][sort_func]))
else:
sys.stdout.write("\t")
sys.stdout.write("\n")
def start():
print('Sorting...')
global data
if not data:
return
# These if else statements call the function of the selected algorithm
if algMenu.get() == 'Quick Sort':
quick_sort(data, draw_data, speedScale.get())
elif algMenu.get() == 'Bubble Sort':
bubble_sort(data, draw_data, speedScale.get())
elif algMenu.get() == 'Insertion Sort':
insertion_sort(data, draw_data, speedScale.get())
elif algMenu.get() == 'Selection Sort':
selection_sort(data, draw_data, speedScale.get())
elif algMenu.get() == 'Merge Sort':
merge_sort(data, 0, len(data) - 1, draw_data, speedScale.get())
elif algMenu.get() == 'Counting Sort':
count_sort(data, draw_data, speedScale.get())
def test_quick_sort(make_random_lists):
random_lists = make_random_lists
for a_list in random_lists:
sorted_list = quick_sort(a_list)
for j in range(len(a_list)):
if j == 0:
continue
else:
if sorted_list[j] < sorted_list[j - 1]:
raise ValueError, sorted_list
def test_quick_sort(make_random_lists):
random_lists = make_random_lists
for a_list in random_lists:
sorted_list = quick_sort(a_list)
for j in range(len(a_list)):
if j == 0:
continue
else:
if sorted_list[j] < sorted_list[j-1]:
raise ValueError, sorted_list
def bucket_sort(num_list):
"""
桶排序
根据数值分桶，桶内快排
:param num_list:
:return:
"""
# 10个桶
# 具体问题按需取值
# 注意[[]] * 10 这种写法是浅复制10个空数组
bucket = [[] for _ in range(bucket_num)]
gap = math.ceil(max(num_list)/bucket_num)
for v in num_list:
bucket[v//gap].append(v)
ret = []
for l in bucket:
quick_sort(l, 0, len(l)-1)
ret.extend(l)
return ret
def bucket_sort(seq):
biggest = 0
for number in seq:
if number > biggest:
biggest = number
buckets = []
buckets.append([]) * (biggest / 10 + 1)
for number in seq:
buckets[number / 10].append(number)
for index, bucket in enumerate(buckets):
# using quicksort to sort individual buckets
buckets[index] = quick_sort(bucket)
final = [number for number in bucket for bucket in buckets]
return final
def test_quick_sort(): arr = [3,5,6,2,9] right = (len(arr) -1) assert quick_sort(arr, 0, right) == [2,3,5,6,9]
def test_two_ordered(): arr = [2,4] assert quick_sort(arr, 0, len(arr)-1) == [2,4]
def test_two(): arr = [4,2] assert quick_sort(arr, 0, len(arr)-1) == [2,4]
#!/usr/bin/env python3
# run.py
# demonstrates a quick sort using quick_sort.py
from quick_sort import *
myarray = [3, 8, 7, 1, 2, 4, 5, 6]
print("(UNSORTED) ", myarray)
print("\n ... performing quick sort ... \n")
myarray = quick_sort(myarray, 0, len(myarray) - 1)
print("(SORTED) ", myarray)
import quick_sort number = [1,2,3,45,67,89] quick_sort(number)
def quick(self, arr):
''' quicksort implementation'''
return quick_sort(arr)
def test_sorting_mix(self): self.assertEqual([-6, 5, ',', '/', '?', 'K', 'c'],quick_sort(['/',',','c',5,-6,'K','?']))
def test_quick_sort_dupes():
array = [8, 4, 4, 4, 16, 5]
actual = quick_sort(array, 0, len(array) - 1)
expected = [4, 4, 4, 5, 8, 16]
assert actual == expected
def test_quicksort(self):
quick_sort(self.ex)
self.assertEqual(self.ex, [1, 2, 3, 4, 5, 6, 7, 8])
from quick_sort import *
def read_input(fn):
return [int(l) for l in open(fn).readlines()]
results = {10: (25, 29, 21), 100: (615, 587, 518), 1000: (10297, 10184, 8921)}
pivot_funcs = (first_pivot, last_pivot, median_of_three_pivot)
for n in 10, 100, 1000:
data = read_input("assignment_1_3_test_%d.txt" % n)
for idx, pivot_func in enumerate(pivot_funcs):
assert quick_sort(list(data), pivot_func) == results[n][idx]
data = read_input("assignment_1_3_input.txt")
print([quick_sort(list(data), pf) for pf in pivot_funcs])
def test_sorting_letters(self): self.assertEqual(["a"],quick_sort(["a"])) self.assertEqual(['C','E','T','b','c','k'],quick_sort(['T','C','c','k','E','b']))
def test_sorting_numbers(self): self.assertEqual([4],quick_sort([4])) self.assertEqual([-7,-4,0,2,3,10,15],quick_sort([2,-4,0,10,15,-7,3]))
import random import copy from insertion_sort import * from merge_sort import * from quick_sort import * if __name__ == "__main__": arr = [random.randint(0, 100) for i in range(10)] print(arr) print(insertion_sort(copy.deepcopy(arr))) print(arr) print(merge_sort(copy.deepcopy(arr))) print(arr) print(quick_sort(copy.deepcopy(arr), 0, len(arr)-1))
def test_quick_sort_short():
array = [4, 6, 2]
actual = quick_sort(array, 0, len(array) - 1)
expected = [2, 4, 6]
assert actual == expected
def test_quick_sort_happy():
array = [8, 4, 23, 42, 16, 15]
actual = quick_sort(array, 0, len(array) - 1)
expected = [4, 8, 15, 16, 23, 42]
assert actual == expected
def test_sorting_symbols(self): self.assertEqual(["!"],quick_sort(["!"])) self.assertEqual(['*','>','?'],quick_sort(['?','*','>']))
def test_quick_sort_long():
array = [4, 6, 2, 4, 8, 7, 1, 12, 3]
actual = quick_sort(array, 0, len(array) - 1)
expected = [1, 2, 3, 4, 4, 6, 7, 8, 12]
assert actual == expected
print()
print("Merge sorted: ")
merge_sorted_list = list(original)
a = time.time()
merge_sorted_list = merge_sort(merge_sorted_list)
b = time.time()
print(b - a)
print_list(merge_sorted_list)
test_properties(sorted, merge_sorted_list)
print()
print("Quick sorted: ")
quick_sorted_list = list(original)
a = time.time()
quick_sort(quick_sorted_list)
b = time.time()
print(b - a)
print_list(quick_sorted_list)
test_properties(sorted, quick_sorted_list)
print()
print("Max heap sorted: ")
max_heap_sorted_list = list(original)
a = time.time()
max_heap_sorted_list = max_heap_sort(max_heap_sorted_list)
b = time.time()
print(b - a)
max_heap_sorted_list = list(reversed(max_heap_sorted_list))
print_list(max_heap_sorted_list)
test_properties(sorted, max_heap_sorted_list)
def test_quick_sort_empty():
array = []
actual = quick_sort(array, 0, len(array) - 1)
expected = 'cannot sort an empty array'
assert actual == expected
def topological_sort(graph):
color, pi, d, f = depth_first_search(graph)
f, vertices = quick_sort(f, 0, len(f) - 1, fetch_vertices(graph))
f.reverse()
vertices.reverse()
return f, vertices
def generateArray(elements):
array = []
for i in range(elements):
array.append(random.randint(0, 100))
return array
if __name__ == '__main__':
## Quicksort
print('Quicksort:')
array = generateArray(20)
print(array)
quick_sort(array, 0, len(array) - 1)
print(array)
## Mergesort
print('Mergesort:')
array = generateArray(20)
print(array)
array = merge_sort(array)
print(array)
## Selectionsort
print('Selectionsort:')
array = generateArray(20)
print(array)
selection_sort(array)
print(array)
n = int(input('\n\n Aperte 0 Para Voltar: '))
elif n == 6:
print("\n" * 130)
print('*** Quick Sort ***\n')
try:
nome_arq = input('Nome do arquivo a ser Aplicado Quick Sort: ')
nome_arq = nome_arq + '.txt'
arquivo = open(nome_arq, 'r')
lista = arquivo.readlines()
x5 = 0
while x5 != 9:
for index in range(len(lista)):
lista[index] = lista[index].rstrip('\n')
lista[index] = int(lista[index])
quick_sort(lista, 0, len(lista) - 1)
n_lista = lista
print('*** Aplicado o Quick Sort ***\n')
print(lista)
arquivo = open(nome_arq, "w")
frases = list()
for i in range(len(n_lista)):
frases.append(str(n_lista[i]))
frases.append('\n')
arquivo.writelines(frases)
arquivo.close()
x5 = int(input('\n\n Aperte 9 Para Voltar: '))
except FileNotFoundError:
print('Arquivo não Foi encontrado ')
print('Erros Provaveis: Nome errado')
def test_one(): arr = [3] assert quick_sort(arr, 0, len(arr)-1) == [3]
from shell_sort import *
if __name__ == "__main__":
parser = argparse.ArgumentParser(prog='main.py')
parser.add_argument('--insertion',
help='insertion sort algorithm',
dest='insertion',
action="store_true")
parser.add_argument('--bubble',
help='Bubble sort algorithm',
dest='bubble',
action="store_true")
parser.add_argument('--quick',
help='quick sort algorithm',
dest='quick',
action="store_true")
parser.add_argument('--shell',
help=' shell sort algorithm',
dest='shell',
action="store_true")
args = parser.parse_args()
if args.insertion:
sort()
if args.bubble:
bubble()
if args.quick:
quick_sort()
if args.shell:
shell_sort()
from quick_sort import * lst = [8, 7, 6, 5, 4, 3, 2, 1] quick_sort(lst) print(lst)
def test_quicksort(self):
quick_sort(self.ex)
self.assertEqual(self.ex, [1, 2, 3, 4, 5, 6, 7, 8])
