def test_sort_sorted_list_of_integers(self):
"""Test that when merge sort is passed a sorted list
of integers that the list remains sorted.
"""
merge_sort(self.sorted_list_of_integers)
self.assertEqual(self.sorted_list_of_integers,
[-7, -2, -1, 0, 1, 4, 10])
def test_sort_unsorted_list_of_integers(self):
"""Test that when merge sort is passed an unsorted list
of integers that the list is properly sorted.
"""
merge_sort(self.unsorted_list_of_integers)
self.assertEqual(self.unsorted_list_of_integers,
self.sorted_list_of_integers)
def test_merge_sort_is_stable(self):
"""Test that if two elements in a list have the same key,
that their relative ordering is still preserved after the
list is sorted.
"""
merge_sort(self.unsorted_list_of_products)
self.assertEqual(self.unsorted_list_of_products,
self.sorted_list_of_products_stable)
def test_merge_sort_merge_sort_empty():
'''
Tests merge_sort's merge_sort function with an empty list
'''
lst = []
assert_equals(merge_sort(lst), [])
def test_merge_sort_merge_sort_normal():
'''
Tests merge_sort's merge_sort function with an unordered list
'''
lst = [5, 2, 4, 6, 1, 3]
correct = [1, 2, 3, 4, 5, 6]
assert_equals(merge_sort(lst), correct)
def bucket_sort(lst, f, k):
"""
Sorts the given list with bucket sort algorithm.
:param lst: The unsorted list
:param f: A function f: element e -> [0, 1[ with f(e) <= f(e') if e <= e'
:param k: number of buckets
:return: the sorted list
"""
buckets = [None for _ in range(k)]
for item in lst:
buckets[f(item) * k].append(item)
sorted = []
for bucket in buckets:
sorted.append(merge_sort(bucket))
return sorted
def draw_chart(sort_type, original_data, frame_interval):
fig = plt.figure(1, figsize=(16, 9))
data_set = [Data(d) for d in original_data]
axs = fig.add_subplot(111)
plt.subplots_adjust(left=0.01, bottom=0.01, right=0.99, top=0.95)
if sort_type == 1:
frames = selection_sort(data_set)
elif sort_type == 2:
frames = bubble_sort(data_set)
elif sort_type == 3:
frames = insertion_sort(data_set)
elif sort_type == 4:
frames = merge_sort(data_set)
elif sort_type == 5:
frames = quick_sort(data_set)
else:
raise IndexError
def animate(frame_no):
# if fi % 2 != 0 and frame_interval < 10 and fi != len(frames)-1:
# return
bars = []
if len(frames) > frame_no:
axs.cla()
axs.set_title(s_type[sort_type])
axs.set_xticks([])
axs.set_yticks([])
bars += axs.bar(list(range(Data.length)),
[d.value for d in frames[frame_no]],
1,
color=[d.color
for d in frames[frame_no]]).get_children()
frame_no += 1
return bars
anim = animation.FuncAnimation(fig,
animate,
frames=len(frames),
interval=frame_interval,
repeat=False)
return plt, anim
def test_merge_sort_desc(self):
expected: List[int] = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
merge_sort.merge_sort(arr, True)
self.assertEqual(expected, arr)
def test_sort_empty_list(self):
"""Test that when merge sort is passed an empty list,
that nothing happens."""
merge_sort(self.empty_list)
self.assertEqual(self.empty_list, [])
def test_get_permutations(self):
input_list = [7, 23, 5, 1, 0, 65, 3, 56, -4, 22, 10, 1, 81]
expected_list = [-4, 0, 1, 1, 3, 5, 7, 10, 22, 23, 56, 65, 81]
self.assertEquals(expected_list, merge_sort.merge_sort(input_list))
def test_sort():
xs = list(np.random.randint(0, 1000, size=[1000]))
copy = xs.copy()
assert merge_sort(xs) == sorted(xs)
assert xs == copy
def main():
print(merge_sort([12, 54, 6, 32, 78, 4, 23, 1, 76, 8, 0, 43]))
def test_merge_sort_asc(self):
expected: List[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
merge_sort.merge_sort(arr)
self.assertEqual(expected, arr)
def test_merge_sort_empty(self):
arr_one: List[int] = []
merge_sort.merge_sort(arr_one)
self.assertEqual([], arr_one)
def test_for_empty(self):
expected = None
output = merge_sort(None)
self.assertEqual(output, expected)
def test_for_duplicate_values_in_input(self):
expected = [1, 3, 3, 4, 5, 6]
data_list = [4, 3, 5, 1, 6, 3]
merge_sort(data_list)
self.assertEqual(data_list, expected)
def test_for_event_list_size_input(self):
expected = [1, 2, 3, 4, 5, 6]
data_list = [4, 2, 5, 1, 6, 3]
merge_sort(data_list)
self.assertEqual(data_list, expected)
def test_for_single_input(self):
expected = [1]
merge_sort([1])
self.assertEqual([1], expected)
def test_quick_sort(self):
self.assertEqual(merge_sort.merge_sort(self.array), self.sorted_array)
def test_merge_sort_one(self):
arr_one: List[int] = [10]
merge_sort.merge_sort(arr_one)
self.assertEqual([10], arr_one)
def test_basic_merge_sort(self):
random_list = [randint(0, 1000) for _ in xrange(0, 1000)]
expected = sorted(random_list)
actual = merge_sort(random_list)
self.assertTrue(expected == actual)