def test_bubble_sort(self):
"""
Tests the bubble sort algorithm implementation.
"""
collection = [5, 1, 10, 2, 16, 1]
algorithms.bubble_sort(collection)
# first, test that it actually worked and sorted the collection in place
self.assertEqual(collection, [1, 1, 2, 5, 10, 16])
# test that it works in the worst case scenario
collection = [5, 4, 3, 2, 1]
algorithms.bubble_sort(collection)
self.assertEqual(collection, [1, 2, 3, 4, 5])
# test that it works with strings
collection = ['c', 'a', 'b']
algorithms.bubble_sort(collection)
self.assertEqual(collection, ['a', 'b', 'c'])
# test worst case with 10 ints
worst = [i for i in xrange(9, -1, -1)]
algorithms.bubble_sort(worst)
self.assertEqual([i for i in xrange(0, 10)], worst)
def test_insertion_sort(self):
"""
Tests the insertion sort algorithm implementation.
"""
collection = [5, 1, 10, 2, 16, 1]
algorithms.insertion_sort(collection)
self.assertEqual(collection, [1, 1, 2, 5, 10, 16])
# test worst case with 10 ints
collection = [i for i in xrange(9, -1, -1)]
algorithms.bubble_sort(collection)
self.assertEqual([i for i in xrange(0, 10)], collection)
def bubble_timer():
# This is the function to time(in seconds) the bubble_sort algorithm.
# Filename: 'bubble_timer_datapoints.txt'
bp = open("bubble_timer_datapoints.txt", "w")
for size in range(
1, 201): # 200 datapoints, each a list of 5000-15000 elements
#for size in range(1, 2): # range of 1-11 (10 lists[datapoints]) for testing
alist = []
for i in range(randint(5000, 15000)):
alist.append(randint(1, 1000000))
print("Starting bubble_sort on list #: {}\n".format(size))
start_time = time()
bubble_sort(alist)
end_time = time()
bubble_time = end_time - start_time
bp.write("{},{}\n".format(len(alist), bubble_time))
print("Finished bubble_sort'ing list #: {}\n".format(size))
def test_bubble_sort_strings():
assert bubble_sort([
"C59OK", "5QV09", "TCNId", "ne58v", "ges28", "EzMbM", "qdPku", "ltinw",
"Nt1Rj", "nSb8R"
]) == [
"5QV09", "C59OK", "EzMbM", "Nt1Rj", "TCNId", "ges28", "ltinw", "nSb8R",
"ne58v", "qdPku"
]
def test_bubble_sort():
answers = [
([], []),
([1], [1]),
([1, 9, 2, 8, 3, 7, 4, 6, 5], [1, 2, 3, 4, 5, 6, 7, 8, 9]),
(
["abc", "cba", "aaa", "ccc", "bbb"],
["aaa", "abc", "bbb", "cba", "ccc"],
),
([6.42, 7.1, 1.4, 9.26, 6.4], [1.4, 6.4, 6.42, 7.1, 9.26]),
]
for q, a in answers:
assert bubble_sort(q) == a
def sort(self):
self.draw_bars()
self.display_sorttext()
if self.algorithm == 'bubble':
algorithms.bubble_sort(self)
if self.algorithm == 'insertion':
algorithms.insertion_sort(self)
if self.algorithm == 'quick':
algorithms.quick_sort(self, isfirst_call = True)
if algorithms.stop_recursive_sort == False:
self.issorted = True
if self.algorithm == 'merge':
algorithms.merge_sort(self, isfirst_call = True)
if algorithms.stop_recursive_sort == False:
self.issorted = True
if self.algorithm == 'heap':
algorithms.heap_sort(self)
if algorithms.stop_recursive_sort == False:
self.issorted = True
def bucket_sort(array, bucket_size):
if bucket_size < 1 or bucket_size > len(array):
raise Exception("Incorrect bucket size")
buckets_num = math.ceil(len(array) / bucket_size)
buckets = [[] * buckets_num]
max_elem = max(array)
for elem in array:
bucket_index = math.floor(elem / (max_elem * bucket_size))
buckets[bucket_index].append(elem)
for i in range(0, len(buckets)):
buckets[i] = bubble_sort(buckets[i])
return [bucket for bucket in buckets][0]
def startAlgorithm():
global data
tick = speedScale.get()
if select_alg.get() == "Bubble sort":
sorted_data = bubble_sort(data, draw_data, tick)
print(sorted_data)
canvas.delete("all")
draw_data(sorted_data, ["white" for x in range(len(data))])
elif select_alg.get() == "Insertion Sort":
sorted_data = insertion_sort(data, draw_data, tick)
print(sorted_data)
canvas.delete("all")
draw_data(sorted_data, ["white" for x in range(len(data))])
elif select_alg.get() == "Selection Sort":
sorted_data = selection_sort(data, draw_data, tick)
print(sorted_data, )
canvas.delete("all")
draw_data(sorted_data, ["white" for x in range(len(data))])
elif select_alg.get() == "Heap Sort":
sorted_data = heap_sort(data, draw_data, tick)
print(sorted_data, )
canvas.delete("all")
draw_data(sorted_data, ["white" for x in range(len(data))])
elif select_alg.get() == "Quick Sort":
sorted_data = quick_sort(data, draw_data, tick)
print(sorted_data, )
canvas.delete("all")
draw_data(sorted_data, ["white" for x in range(len(data))])
elif select_alg.get() == "Merge Sort":
sorted_data = merge_sort(data, draw_data, tick)
print(sorted_data, )
canvas.delete("all")
draw_data(sorted_data, ["white" for x in range(len(data))])
pancake_process_time = ["Pancake Sort"]
shell_process_time = ["Shell Sort"]
entries = inputs.get_entries()
for values in entries:
# SELECTION SORT
start = time.process_time()
algorithms.selection_sort(entries[values][:])
selection_process_time.append(time.process_time() - start)
print(
f"{selection_process_time[0]} processing time with {values} values: {time.process_time() - start}"
)
# BUBBLE SORT
start = time.process_time()
result = algorithms.bubble_sort(entries[values][:])
bubble_process_time.append(time.process_time() - start)
print(
f"{bubble_process_time[0]} processing time with {values} values: {time.process_time() - start}"
)
# PANCAKE SORT
start = time.process_time()
result = algorithms.pancake_sort(entries[values][:])
pancake_process_time.append(time.process_time() - start)
print(
f"{pancake_process_time[0]} processing time with {values} values: {time.process_time() - start}"
)
# SHELL SORT
start = time.process_time()
def test_bubble_sort_with_no_items(self): iterable = [] algorithms.bubble_sort(iterable) expected = [] self.assertEqual(iterable, expected)
def call_sort_method(self, random_list, max_vet, j):
begin = time.time()
bubble_sort(random_list)
end = time.time()
print('bubble sort with {} items vet[{}]: {} seconds'.format(max_vet, j + 1, end - begin))
return end - begin
sorting_method = button
algorithms.delay = 1 if values[len(values) - 1] else 0
# reading information from GUI
size = int(values[len(values) - 2])
a = tools.generate_random_list(size)
sorting_speed = int(105 - values[len(values) - 3])
if sorting_method == "Selection Sort":
generator = algorithms.selection_sort(a)
title = "Selection Sort of {} numbers".format(size)
elif sorting_method == "Insertion Sort":
generator = algorithms.insertion_sort(a)
title = "Insertion Sort of {} numbers".format(size)
elif sorting_method == "Bubble Sort":
generator = algorithms.bubble_sort(a)
title = "Bubble Sort of {} numbers".format(size)
elif sorting_method == "Merge Sort":
generator = algorithms.merge_sort(a)
title = "Merge Sort of {} numbers".format(size)
# Generating bar graph
fig, ax = plt.subplots()
ax.set_title(title)
bar_rects = ax.bar(range(len(a)), a, align="edge", color="#61b0ff")
ax.set_xlim(0, size)
ax.set_ylim(0, 100)
text = ax.text(0.02, 0.95, "", transform=ax.transAxes)
iteration = [0]
def test_bubble_sort():
assert bubble_sort(ls1) == sorted(ls1)
assert bubble_sort(ls2) == sorted(ls2)
assert bubble_sort(ls3) == sorted(ls3)
assert bubble_sort(ls4) == sorted(ls4)
assert bubble_sort(ls5) == sorted(ls5)
def test_it_sorts_a_list_of_numbers():
list_unsorted = [9, 2, 1, 4, 8, 3, 5]
bubble_sort(list_unsorted)
assert list_unsorted == [1, 2, 3, 4, 5, 8, 9]
def test_it_sorts_a_inverse_sorted_list_of_numbers():
list_unsorted = [7, 6, 5, 4, 3, 2, 1]
bubble_sort(list_unsorted)
assert list_unsorted == [1, 2, 3, 4, 5, 6, 7]
from algorithms import bubble_sort
from algorithms import selection_sort
x = [5, 6, 4, 3, 7, 8, 9, 0, 1, 2]
print("Import 1 for bubble sort algorithms")
print("Import 2 for selection sort algorithms")
n = int(input("Which algorithms you want to use:"))
if n == 1:
bubble_sort(x)
if n == 2:
selection_sort(x)
print(x)
def test_bubble_sort_with_none_iterable_raises_type_error(self):
iterable = None
with self.assertRaises(TypeError):
algorithms.bubble_sort(iterable)
except:
print(
f"Invalid number was entered, select a number between {min_num} and {max_num}. Try again!"
)
############################################
print("How many integers would you like sorted?: ")
array_length = inputNumber(1, 2**64)
array = random.sample(range(1, array_length), k=array_length - 1)
algorithm_data = {
1: ("Selection Sort", selection_sort(array)),
2: ("Bubble Sort", bubble_sort(array)),
3: ("Insertion Sort", insertion_sort(array)),
4: ("Shell Sort", shell_sort(array)),
5: ("Merge Sort", merge_sort(array)),
6: ("Quick Sort", quick_sort(array, 0,
len(array) - 1)),
7: ("Heap Sort", heap_sort(array))
}
print("Welcome to Urmzd's Sorting Algorithm Visualizer: ")
print("Select one of the following sorting algorithms: ")
for k, v in algorithm_data.items():
print(f"Type {k} for {v[0]}")
algorithm_number = inputNumber(1, 7)
def test_bubble_sort_is_stable_1(self): iterable = [[1], [1], [1], [1]] ids = [id(item) for item in iterable] algorithms.bubble_sort(iterable) expected = [id(item) for item in iterable] self.assertEqual(ids, expected)
from algorithms import bubble_sort
from branch_predictor import BranchPredictor
history_lengths = list(range(2, 26, 2))
accuracies = collections.defaultdict(list)
movings_accs = collections.defaultdict(list)
input = list(range(10))
for i in history_lengths:
bp = BranchPredictor(i)
for _ in range(200):
random.shuffle(input)
bubble_sort(input, bp)
accs, movings = bp.get_accuracies()
for key in accs:
accuracies[key].append(accs[key])
for key in movings:
movings_accs[key].append(movings[key])
plt.figure()
plt.subplot(1, 2, 1)
for key in accuracies:
plt.plot(history_lengths, accuracies[key], label=key)
plt.legend()
plt.title("Overall Accuracy")
def test_bubble_sort_with_one_item(self): iterable = [1] algorithms.bubble_sort(iterable) expected = [1] self.assertEqual(iterable, expected)
def test_it_sorts_a_list_of_numbers_with_duplicates():
list_unsorted = [7, 7, 5, 4, 3, 3, 1]
bubble_sort(list_unsorted)
assert list_unsorted == [1, 3, 3, 4, 5, 7, 7]
def test_bubble_sort_with_two_items_2(self): iterable = [2, 1] algorithms.bubble_sort(iterable) expected = [1, 2] self.assertEqual(iterable, expected)
import random
import collections
import matplotlib.pyplot as plt
from algorithms import bubble_sort
from branch_predictor import BranchPredictor, TruePerceptron
import plotter
history_length = 64
bp = BranchPredictor(history_length, TruePerceptron)
data = list(range(64))
# for _ in range(history_length):
# random.shuffle(data)
# result, result_length = select(data, 0, 100, 16, bp)
iters = []
for _ in range(3):
random.shuffle(data)
bubble_sort(data, bp)
iters.append(len(bp.prediction_history["flip"]))
bp.print_accuracies()
plotter.generate_plot_sort(bp, "flip", iters, 200)
def test_bubble_sort_with_three_items_6(self): iterable = [3, 2, 1] algorithms.bubble_sort(iterable) expected = [1, 2, 3] self.assertEqual(iterable, expected)
def test_bubble_sort():
assert bubble_sort([]) == []
assert bubble_sort([2]) == [2]
assert bubble_sort([3, 5, 6, 7, 4, 2]) == sorted([3, 5, 6, 7, 4, 2])
assert bubble_sort([7, 4, 5, 3, 2, 6]) == sorted([7, 4, 5, 3, 2, 6])
def test_bubble_sort_with_descending_items(self): iterable = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] algorithms.bubble_sort(iterable) expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] self.assertEqual(iterable, expected)
def test_insertion_sort_is_not_stable(self): iterable = [[3], [2], [3], [1]] ids = [id(item) for item in iterable if item[0] == 1] algorithms.bubble_sort(iterable) expected = [id(item) for item in iterable if item[0] == 1] self.assertEqual(ids, expected)
def test_bubble_sort_with_strings(self): iterable = ['a', 's', 'd', 'f'] algorithms.bubble_sort(iterable) expected = ['a', 'd', 'f', 's'] self.assertEqual(iterable, expected)
if __name__ == '__main__':
test_elements = [10, 100, 1000, 10000, 100000, 300000]
print(
f'\nComparing algorithms for {len(test_elements)} lists with different lengths:\n'
)
for elements in test_elements:
list_unsorted = generate_list(elements, MIN_VALUE, MAX_VALUE)
print(f'List with {elements} elements:')
if elements < THRESHOLD_ELEMENTS_SLOW_ALGORITHMS:
bubble_sort(deepcopy(list_unsorted))
print(f'Bubble sort: \t\t{bubble_sort.execution_time}')
selection_sort(deepcopy(list_unsorted))
print(f'Selection sort: \t{selection_sort.execution_time}')
insertion_sort(deepcopy(list_unsorted))
print(f'Insertion sort: \t{insertion_sort.execution_time}')
else:
print(
'Bubble sort: \t\tSkipping algorithm because it takes a long time'
)
print(
'Selection sort: \tSkipping algorithm because it takes a long time'
)
print(
def test_bubble_sort_numbers():
assert bubble_sort(
[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50,
48]) == [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
