def testMergeSort4(self):
l = list()
random.seed(12345)
l.extend(random.sample(xrange(1000), 900))
l.extend(random.sample(xrange(1000), 900))
l.extend(random.sample(xrange(1000), 900))
ol = l[:]
sort.mergesort(l)
self.assertEqual(l, sorted(ol))
def new_tree(listin):
sorter = sort.mergesort()
listin_sorted = sorter.msort(listin)
print listin_sorted
length = len(listin_sorted)
pivoti = length/2
new_tree = tree(listin_sorted[pivoti])
if pivoti > 0:
new_tree.add_list_sorted(listin_sorted[:pivoti])
if pivoti < len(listin_sorted)-1:
new_tree.add_list_sorted(listin_sorted[pivoti:])
return new_tree
def new_tree(listin):
sorter = sort.mergesort()
listin_sorted = sorter.msort(listin)
print listin_sorted
length = len(listin_sorted)
pivoti = length / 2
new_tree = tree(listin_sorted[pivoti])
if pivoti > 0:
new_tree.add_list_sorted(listin_sorted[:pivoti])
if pivoti < len(listin_sorted) - 1:
new_tree.add_list_sorted(listin_sorted[pivoti:])
return new_tree
def q5_merge_sort(self):
try:
tests = 1000
points = 0
for i in xrange(tests):
l = [random() for i in xrange(randint(20, 50))]
if sorted(l) == mergesort(l):
points += 1
self.total_points += 2
return ('mergesort', points, tests)
except:
return ('No mergesort found', 0, 0)
def test_sorted_list(self):
data_size = 1000
seed(42)
orig_data = sample(range(data_size * 3), k=data_size)
self.assertFalse(is_sorted(orig_data))
test_data = selection_sort(orig_data.copy())
self.assertTrue(is_sorted(test_data))
test_data = insertion_sort(orig_data.copy())
self.assertTrue(is_sorted(test_data))
test_data = mergesort(orig_data.copy())
self.assertTrue(is_sorted(test_data))
test_data = quicksort(orig_data.copy())
self.assertTrue(is_sorted(test_data))
def test_sorted_list():
data_size = 1000
seed(42)
orig_data = sample(range(data_size * 3), k=data_size)
assert not is_sorted(orig_data)
test_data = selection_sort(orig_data.copy())
assert is_sorted(test_data)
test_data = insertion_sort(orig_data.copy())
assert is_sorted(test_data)
test_data = mergesort(orig_data.copy())
assert is_sorted(test_data)
test_data = quicksort(orig_data.copy())
assert is_sorted(test_data)
def main():
parser = createParser()
argument = parser.parse_args(sys.argv[1:])
try:
if argument.task == 1:
if argument.subtask == 1:
with open(argument.file, 'r') as file:
text.repeats(file)
elif argument.subtask == 2:
with open(argument.file, 'r') as file:
text.average(file)
elif argument.subtask == 3:
with open(argument.file, 'r') as file:
text.median(file)
elif argument.subtask == 4:
with open(argument.file, 'r') as file:
text.top(file)
elif argument.task == 2:
if argument.subtask == 1:
lst = raw_input("Enter list: ").split()
lst = [int(elem) for elem in lst]
print sort.quicksort(lst)
elif argument.subtask == 2:
lst = raw_input("Enter list: ").split()
lst = [int(elem) for elem in lst]
print sort.mergesort(lst)
elif argument.subtask == 3:
lst = raw_input("Enter list: ").split()
lst = [int(elem) for elem in lst]
print sort.radixsort(lst)
elif argument.task == 3:
storage.storage()
elif argument.task == 4:
n = int(raw_input("Enter n: "))
fib.print_fib(n)
except Exception as e:
print e
def test_sorting_correctness(self):
"""should give known result with known input"""
for input_value, output_value in self.known_values:
"""Python Built-in sorting"""
self.assertEqual(
output_value,
sorted(input_value)
)
"""Merge Sort"""
self.assertEqual(
output_value,
mergesort(input_value)
)
def new_tree(listin, paired=False):
sorter = sort.mergesort()
listin_sorted = sorter.msort(listin)
print listin_sorted
length = len(listin_sorted)
pivoti = length / 2
new_tree = tree()
if not paired:
new_tree.root.key = listin_sorted[pivoti]
new_tree.root.set_value(listin_sorted[pivoti])
else:
new_tree.root.key = listin_sorted[pivoti][0]
new_tree.root.set_value(listin_sorted[pivoti][1])
if pivoti > 0:
new_tree.root.add_list_sorted(listin_sorted[:pivoti], paired)
if pivoti < len(listin_sorted) - 1:
new_tree.root.add_list_sorted(listin_sorted[pivoti:], paired)
return new_tree
def new_tree(listin, paired=False):
sorter = sort.mergesort()
listin_sorted = sorter.msort(listin)
print listin_sorted
length = len(listin_sorted)
pivoti = length/2
new_tree = tree()
if not paired:
new_tree.root.key = listin_sorted[pivoti]
new_tree.root.set_value(listin_sorted[pivoti])
else:
new_tree.root.key = listin_sorted[pivoti][0]
new_tree.root.set_value(listin_sorted[pivoti][1])
if pivoti > 0:
new_tree.root.add_list_sorted(listin_sorted[:pivoti], paired)
if pivoti < len(listin_sorted)-1:
new_tree.root.add_list_sorted(listin_sorted[pivoti:], paired)
return new_tree
def test_sort_times(self):
data_size = 1000
seed(42)
data = sample(range(data_size * 3), k=data_size)
# selection sort
test = data.copy()
start = perf_counter()
test = selection_sort(test)
selection_elapsed_time = perf_counter() - start
self.assertTrue(is_sorted(test))
# insertion sort
test = data.copy()
start = perf_counter()
test = insertion_sort(test)
insertion_elapsed_time = perf_counter() - start
self.assertTrue(is_sorted(test))
# merge sort
test = data.copy()
start = perf_counter()
test = mergesort(test)
merge_elapsed_time = perf_counter() - start
self.assertTrue(is_sorted(test))
# quick sort
test = data.copy()
start = perf_counter()
test = quicksort(test)
quick_elapsed_time = perf_counter() - start
self.assertTrue(is_sorted(test))
# tim sort
test = data.copy()
start = perf_counter()
test.sort()
tim_elapsed_time = perf_counter() - start
self.assertLess(merge_elapsed_time, insertion_elapsed_time)
self.assertLess(quick_elapsed_time, selection_elapsed_time)
self.assertLess(tim_elapsed_time, merge_elapsed_time)
def test_sort_times():
data_size = 1000
seed(42)
data = sample(range(data_size * 3), k=data_size)
# selection sort
test = data.copy()
start = perf_counter()
test = selection_sort(test)
selection_elapsed_time = perf_counter() - start
assert is_sorted(test)
# insertion sort
test = data.copy()
start = perf_counter()
test = insertion_sort(test)
insertion_elapsed_time = perf_counter() - start
assert is_sorted(test)
# merge sort
test = data.copy()
start = perf_counter()
test = mergesort(test)
merge_elapsed_time = perf_counter() - start
assert is_sorted(test)
# quick sort
test = data.copy()
start = perf_counter()
test = quicksort(test)
quick_elapsed_time = perf_counter() - start
assert is_sorted(test)
# tim sort
test = data.copy()
start = perf_counter()
test.sort()
tim_elapsed_time = perf_counter() - start
assert merge_elapsed_time < insertion_elapsed_time
assert quick_elapsed_time < selection_elapsed_time
assert tim_elapsed_time < merge_elapsed_time
def test_merge_sort():
for _ in range(500):
r = random.randint(0, 100)
arr = get_random_arr(r)
assert sort.mergesort(arr) == sorted(arr)
def main(): sayHello() arr = list(map(int, input().split())) print(arr) mergesort(arr,0,len(arr)-1) print(arr)
def testMergeSort(self):
l = [2, 3, 1]
sort.mergesort(l)
self.assertEqual(l, [1, 2, 3])
def testMergeSort2(self):
l = [2, 3, 1, 7, 8, 1 , 8 , 8, 2, 1 ,7]
sort.mergesort(l)
self.assertEqual(l, [1, 1, 1, 2, 2, 3, 7, 7, 8, 8, 8])
plt.show() # wyświetlenie wykresu
# zapisanie do pliku png, np. N_1E4 dla N = 10^4
# filename = "N_1E{:n}.png".format(potega)
# plt.savefig(filename)
if __name__ == "__main__":
lista = lists.random_integer_list
wyniki = []
ILOSC_PROBEK = 3
# Quicksort, Mergesort i Timsort
for N in [10**2, 10**3, 10**4, 10**5, 10**6]:
czas_mergesort = timeit.timeit(
lambda: sort.mergesort(lista(N), 0, N - 1),
number=ILOSC_PROBEK) / ILOSC_PROBEK
czas_quicksort = timeit.timeit(
lambda: sort.quicksort(lista(N), 0, N - 1),
number=ILOSC_PROBEK) / ILOSC_PROBEK
czas_timsort = timeit.timeit(lambda: lista(N).sort(),
number=ILOSC_PROBEK) / ILOSC_PROBEK
wyniki.append({"name": "quicksort", "N": N, "time": czas_quicksort})
wyniki.append({"name": "mergesort", "N": N, "time": czas_mergesort})
wyniki.append({"name": "timsort", "N": N, "time": czas_timsort})
# Selectsort, Insertsort, Bubblesort, Shakersort i Shellsort
for N in [10**2, 10**3, 10**4]:
czas_selectsort = timeit.timeit(
lambda: sort.selectsort(lista(N), 0, N - 1),
number=ILOSC_PROBEK) / ILOSC_PROBEK
from sort import quicksort, mergesort
if __name__ == "__main__":
test1 = [5, 4, 3, 2, 1]
test2 = [1, 4, 4, -8, 9]
# print(quicksort(test1))
# print(quicksort(test2))
print(mergesort(test1))
print(mergesort(test2))
def test_mergesort(seq):
assert_unsorted(seq)
assert_sorted(mergesort(seq))
def testMerge(self): self.assertEqual(sort.mergesort(self.test_vec()), sorted(self.test_vec()))
import sort
def load_from(filename):
with open(filename, "r") as options_file:
return [option[:-1] for option in options_file if option not in ("", "\n")]
def write_result_to(options, filename):
with open(filename, "w") as output_file:
output_file.writelines([option + "\n" for option in options])
if __name__ == "__main__":
options = load_from("options.txt")
try:
options = sort.mergesort(options)
finally:
write_result_to(options, "result.txt")
def test_mergesort(seq):
assert_unsorted(seq)
assert_sorted(mergesort(seq))
def testMergeSort3(self):
ol = range(-50, 50)
l = sorted(ol)
sort.mergesort(l)
self.assertEqual(l, ol)
def testMergeSortWithManyDuplicates(self):
ol = range(-50, 50)
ol.extend(ol)
l = ol[:]
sort.mergesort(l)
self.assertEqual(l, sorted(ol))
import random
import argparse
import sort
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(nargs='?', type=int, default=1000, dest='number')
args = parser.parse_args()
lst = []
for i in range(args.number):
lst.append(random.randint(1,100))
ans = sort.samplesort(list(lst))
qs = sort.quicksort(list(lst))
ms = sort.mergesort(list(lst))
bs = sort.bubblesort(list(lst))
ins = sort.insertionsort(list(lst))
sel = sort.selectionsort(list(lst))
print "Sample sort returns {} in {}".format(ans[0], ans[1])
print "Quicksort matches sample: {} in {}".format(ans[0] == qs[0], qs[1])
print "Mergesort matches sample: {} in {}".format(ans[0] == ms[0], ms[1])
print "Bubblesort matches sample: {} in {}".format(ans[0] == bs[0], bs[1])
print "Insertionsort matches sample: {} in {}".format(ans[0] == ins[0], ins[1])
print "Selectionsort matches sample: {} in {}".format(ans[0] == sel[0], sel[1])
def test_mergesort(self):
for _ in range(500):
raw_array = [round(random.random(), 2) for n in range(100)]
default_sort = sorted(raw_array)
sorted_array = mergesort(raw_array)
self.assertEqual(sorted_array, default_sort)
def test_mergesort():
random.shuffle(array)
sorted = sort.mergesort(array)
assert is_sorted(sorted)
