def start_algorithm(): global data, result, numbers if not data: return if (algmenu.get() == 'Selection Sort'): selection_sort(data, drawData) drawData(data, ['Green' for x in range(len(data))]) result = "Selection Sort \n" + ' '.join(map(str, data)) data = copy.deepcopy(numbers) if (algmenu.get() == 'Insertion Sort'): insertion_sort(data, drawData) drawData(data, ['Green' for x in range(len(data))]) result = "Insertion Sort \n" + ' '.join(map(str, data)) data = copy.deepcopy(numbers) if (algmenu.get() == 'Bubble Sort'): bubble_sort(data, drawData) drawData(data, ['Green' for x in range(len(data))]) result = "Bubble Sort \n" + ' '.join(map(str, data)) data = copy.deepcopy(numbers) if (algmenu.get() == 'Quick Sort'): quick_sort(data, 0, len(data)-1, drawData) drawData(data, ['Green' for x in range(len(data))]) result = "Quick Sort \n" + ' '.join(map(str, data)) data = copy.deepcopy(numbers) if (algmenu.get() == 'Merge Sort'): merge_sort(data, 0, len(data)-1, drawData) drawData(data, ['Green' for x in range(len(data))]) result = "Merge Sort \n"' '.join(map(str, data)) data = copy.deepcopy(numbers)
def wx_gauss(wx, m, sigma):
wy = []
for i in range(len(wx)):
wy.append((1 / (sigma * np.sqrt(2 * np.pi))) *
np.exp(-1 * (wx[i] - m)**2 / (2 * (sigma**2))))
bubble.bubble_sort(wx, wy)
plt.plot(wx, wy, color='r')
def get_piecewice_parabolic_interpolation(x, y, z):
print("сортировка массивов")
print(x, y)
bubble_sort(x, y)
print(x, y)
xnew = np.linspace(np.min(x), np.max(x), z)
ynew = [piecewice_parabolic_interpolation(x, y, i) for i in xnew]
return xnew, ynew
def get_by_scipy(x, y, z):
print("сортировка массивов")
print(x, y)
bubble_sort(x, y)
print(x, y)
spl = InterpolatedUnivariateSpline(x, y)
xnew = np.linspace(np.min(x), np.max(x), z)
ynew = spl(xnew)
return xnew, ynew
def wx_rayleigh(wx, sigma):
wy = []
for i in range(len(wx)):
wy.append((wx[i] / (sigma**2)) * np.exp(-1 * ((wx[i]**2) /
(2 * (sigma**2)))))
print(wx, "неотфильтр значения ")
print(wy)
bubble.bubble_sort(wx, wy)
print(wx, "отфильтр значения ")
print(wy)
plt.plot(wx, wy, color='r')
def StartAlgo():
global data
if not data:
return
if menu.get() == 'Quick Sort':
quick_sort(data, 0, len(data) - 1, drawbar, visualspeed.get())
elif menu.get() == 'Merge Sort':
merge_sort(data, drawbar, visualspeed.get())
elif menu.get() == 'Bubble Sort':
bubble_sort(data, drawbar, visualspeed.get())
drawbar(data, ['green' for x in range(len(data))])
def StartAlgo():
global data
speedforce = 0.01 * (100 - speedscale.get())
sorter = selected_algo.get()
if sorter == 'bubble SORT':
bubble_sort(data, drawdata, speedforce)
elif sorter == 'quick SORT':
quick_sort(data, 0, len(data) - 1, drawdata, speedforce)
drawdata(data, ['green' for x in range(len(data))])
elif sorter == 'merge SORT':
merge_sort(data, data, 0, len(data) - 1, drawdata, speedforce)
def merge_sort(filename, comp = cmp, key = None):
files = []
cur_line = []
f = open(filename, 'r')
RAMSIZE = 10
for line in f:
if line.isspace(): continue
cur_line.append(line)
if len(cur_line) == RAMSIZE:
bubble_sort(cur_line, comp, key)
if files == None:
temp_f = open('tmp_0.txt', 'w')
else:
temp_f = open('tmp_' + str(len(files)) + '.txt', 'w')
for i in cur_line:
temp_f.write(i)
temp_f.close()
files.append(temp_f)
cur_line = []
if cur_line:
bubble_sort(cur_line, comp, key)
if files == None:
temp_f = open('tmp_0.txt', 'w')
else:
temp_f = open('tmp_' + str(len(files)) + '.txt', 'w')
for i in cur_line:
temp_f.write(i)
temp_f.close()
files.append(temp_f)
f.close()
f2 = open('mysort.txt', 'w')
buffers = []
for i in range(len(files)):
files[i] = open('tmp_' + str(i) + '.txt', 'r')
for line in files:
buffers.append(line.readline())
while files:
min_n = 0
for i in range(1, len(buffers)):
if comp(buffers[min_n], buffers[i]) > 0:
min_n = i
f2.write(buffers[min_n])
t = files[min_n].readline()
if t == '':
del files[min_n]
del buffers[min_n]
else:
buffers[min_n] = t
f2.close()
def simulation():
bubble_time = 0
selection_time = 0
insertion_time = 0
merge_time = 0
quick_time = 0
tim_time = 0
for i in range(EXPERIMENTS):
# create a list with some number of values from the given range
my_list = random.sample(range(MAX_VALUE), LIST_SIZE)
start = time.time()
bubble_sort(my_list)
bubble_time += time.time() - start
my_list = random.sample(range(MAX_VALUE), LIST_SIZE)
start = time.time()
selection_sort(my_list)
selection_time += time.time() - start
my_list = random.sample(range(MAX_VALUE), LIST_SIZE)
start = time.time()
insertion_sort(my_list)
insertion_time += time.time() - start
my_list = random.sample(range(MAX_VALUE), LIST_SIZE)
start = time.time()
merge_sort(my_list)
merge_time += time.time() - start
my_list = random.sample(range(MAX_VALUE), LIST_SIZE)
start = time.time()
quick_sort(my_list)
quick_time += time.time() - start
my_list = random.sample(range(MAX_VALUE), LIST_SIZE)
start = time.time()
my_list.sort()
tim_time += time.time() - start
print('Bubble sort took', bubble_time/EXPERIMENTS*1000, 'ms')
print('Selection sort took', selection_time/EXPERIMENTS*1000, 'ms')
print('Insertion sort took', insertion_time/EXPERIMENTS*1000, 'ms')
print('Merge sort took', merge_time/EXPERIMENTS*1000, 'ms')
print('Quick sort took', quick_time/EXPERIMENTS*1000, 'ms')
print('Timsort took', tim_time/EXPERIMENTS*1000, 'ms')
def test_bubble_sort_sorts_big_list():
"""Test that bubble sort sorts big list."""
from bubble import bubble_sort
from random import shuffle
big_list = list(range(100))
shuffle(big_list)
assert bubble_sort(big_list) == list(range(100))
def test_merge_sort(fixtures):
for fixture in fixtures:
assert merge_sort(fixture[0]) == fixture[1]
assert quick_sort(fixture[0]) == fixture[1]
assert insertion_sort(fixture[0]) == fixture[1]
assert bubble_sort(fixture[0]) == fixture[1]
assert heap_sort(fixture[0]) == fixture[1]
def sort():
global data
if not data:
return
print("Selected Algorithm:" + option1.get())
if algoslec.get() == 'Bubble Sort':
bubble_sort(data, visualise, float(timeslec.get()))
if algoslec.get() == 'Merge Sort':
merge_sort(data, visualise, float(timeslec.get()))
if algoslec.get() == 'Selection Sort':
select_sort(data, visualise, float(timeslec.get()))
if algoslec.get() == 'Quick Sort':
quick_sort(data, 0, len(data) - 1, visualise, float(timeslec.get()))
visualise(data, ['#D5F5E3' for x in range(len(data))])
def test_bubble_sort_empty(self):
self.assertEqual(bubble_sort([]), 'Nothing to sort.')
def test_bubble_sort_none(self):
self.assertEqual(bubble_sort(None), 'Nothing to sort.')
def test_bubble_sort_nums_positive_and_negative(self):
self.assertEqual(bubble_sort([-12, -19, -20, 45, 91, 55]),
[-20, -19, -12, 45, 55, 91])
max_bubble = []
max_quick = []
max_counting_small = []
max_counting_large = []
max_radix = []
#bubble-quick
for cicle in range(5):
for size in range(Steps):
realSize = MaxSize/Steps*size if MaxSize/Steps*size > 1 else 2
size_array.append(realSize)
sequence = getSequence(realSize)
bubbleSequence = sequence[:]
startTime = time.time()
bubble.bubble_sort(bubbleSequence)
endTime = time.time()
table_bubble[size][cicle] = endTime - startTime
quickSequence = sequence[:]
startTime = time.time()
quick.quick_sort(quickSequence)
endTime = time.time()
table_quick[size][cicle] = endTime - startTime
print size
print "done-quick/bubble"
#counting - k=3
for cicle in range(5):
for size in range(Steps):
def test_sorted(self):
"""add bubble test for sorted array"""
_sorted = [1, 2, 3, 4]
self.assertEqual(_sorted, bubble_sort(_sorted))
def test_bubble_sort_short_list():
"""Test bubble with small list."""
short_list = [4, 3, 7, 6]
assert bubble_sort(short_list) == [3, 4, 6, 7]
def test_bubble_sort_negative_num():
"""Test bubble sort works with negative numbers."""
list_negative_num = [72, 4, -6]
assert bubble_sort(list_negative_num) == [-6, 4, 72]
def test_bubble_non_int_raises_error():
"""Entering an iterable containing non-integers raises an error."""
from bubble import bubble_sort
with pytest.raises(ValueError):
bubble_sort([1, 2, 3, 5, 'burp'])
print("partition_sorted_list1: " + str(partition_sorted_list1))
print("partition_sorted_list2: " + str(partition_sorted_list2))
print("partition_sorted_list3: " + str(partition_sorted_list3))
# 归并排序
list1, list2, list3 = get_list()
merge_sorted_list1 = merge_sort(list1)
merge_sorted_list2 = merge_sort(list2)
merge_sorted_list3 = merge_sort(list3)
print("merge_sorted_list1: " + str(merge_sorted_list1))
print("merge_sorted_list2: " + str(merge_sorted_list2))
print("merge_sorted_list3: " + str(merge_sorted_list3))
# 冒泡排序
list1, list2, list3 = get_list()
bubble_sorted_list1 = bubble_sort(list1)
bubble_sorted_list2 = bubble_sort(list2)
bubble_sorted_list3 = bubble_sort(list3)
print("bubble_sorted_list1: " + str(bubble_sorted_list1))
print("bubble_sorted_list2: " + str(bubble_sorted_list2))
print("bubble_sorted_list3: " + str(bubble_sorted_list3))
# 选择排序
list1, list2, list3 = get_list()
select_sorted_list1 = select_sort(list1)
select_sorted_list2 = select_sort(list2)
select_sorted_list3 = select_sort(list3)
print("select_sorted_list1: " + str(select_sorted_list1))
print("select_sorted_list2: " + str(select_sorted_list2))
print("select_sorted_list3: " + str(select_sorted_list3))
def test_bubble():
"""test bubble sort function on list of ints."""
a = [123, 55, 2, 7, 22, -10, 1]
bubble_sort(a)
assert a == [-10, 1, 2, 7, 22, 55, 123]
def is_anagram(s1, s2):
s1, s2 = list(s1), list(s2)
bubble_sort(s1), bubble_sort(s2)
return s1 == s2
def test_bubble_sort(self):
bubble_sort(self.shuffle_lst)
self.assertEqual(self.shuffle_lst, self.ordered_lst)
def test_bubble_sort_long_list():
"""Test bubble with long list."""
long_list = [72, 4, 10, 6, 20, 18, 91, 45, 3, 15]
assert bubble_sort(long_list) == [3, 4, 6, 10, 15, 18, 20, 45, 72, 91]
def test_bubble_sort_sorts_random_list():
"""Bubble sort returns an ordered list."""
from bubble import bubble_sort
input = [randint(0, 1000) for i in range(100)]
expected = sorted(input)
assert bubble_sort(input) == expected
def test_bubble_sort_decimals():
"""Test bubble sort takes a decimal float."""
list_decimals = [5.5, 5.3, 5.2, 4]
assert bubble_sort(list_decimals) == [4, 5.2, 5.3, 5.5]
def bubble(*args): return bubble_sort(*args)
def test_bubble(self):
"""add bubble tests for unsorted array"""
unsorted = [4, 3, 2, 1, 12]
_sorted = bubble_sort(unsorted)
expected_results = [1, 2, 3, 4, 12]
self.assertEqual(expected_results, _sorted)
def test_bubble_sort_nums_positive(self):
self.assertEqual(bubble_sort([20, 12, 45, 19, 91, 55]),
[12, 19, 20, 45, 55, 91])
def test_bubble_non_list_raises_error():
"""Entering a non-list/tuple param raises an error."""
from bubble import bubble_sort
with pytest.raises(TypeError):
bubble_sort('Hello')
def test_bubble_sort_nums_negative(self):
self.assertEqual(bubble_sort([-20, -12, -45, -19, -91, -55]),
[-91, -55, -45, -20, -19, -12])
def test_bubble_sort_returns_ordered_list(input, expected):
"""Bubble sort returns an ordered list."""
from bubble import bubble_sort
assert bubble_sort(input) == expected
def test_bubble_sort_not_nums(self):
self.assertEqual(bubble_sort([0, 'a', 3]),
'Can only sort lists of just numbers.')
self.assertEqual(bubble_sort(['a', 'b', 'c']),
'Can only sort lists of just numbers.')
def test_bubble_sort_sorts(input, output):
"""Check if bubble sort sorts lists given against sorted lists given as output."""
assert bubble_sort(input) == output
def test_bubble_sort_single_value(self):
self.assertEqual(bubble_sort([5]), [5])
