def test_alg(alg, size_array): """ Tests """ t_arrays = [] # Create the random arrays for i in range(N_TESTS_ALG): a = [randint(-2**N_BITS, 2**N_BITS) for i in range(size_array)] t_arrays.append(a) # Insertion Sort if alg == INSERTION_SORT: print("INSERTION_SORT", end=",") print("N=%d" % (size_array)) # Test N times to get a more precise average time for test in range(N_TESTS_ALG): A = list.copy(t_arrays[test]) t1 = time() insertion_sort(A) t2 = time() print("T%d," % test, t2 - t1) elif alg == MERGE_SORT: print("MERGE_SORT", end=",") print("N=%d" % (size_array)) # Test N times to get a more precise average time for test in range(N_TESTS_ALG): A = list.copy(t_arrays[test]) t1 = time() merge_sort(A, 0, len(A) - 1) t2 = time() print("T%d," % test, t2 - t1) elif alg == RADIX_SORT: print("RADIX_SORT", end=",") print("N=%d" % (size_array)) # Test N times to get a more precise average time for test in range(N_TESTS_ALG): A = list.copy(t_arrays[test]) t1 = time() radix_sort(A) t2 = time() print("T%d," % test, t2 - t1) elif alg == BUCKET_SORT: print("BUCKET_SORT", end=",") print("N=%d" % (size_array)) # Test N times to get a more precise average time for test in range(N_TESTS_ALG): A = list.copy(t_arrays[test]) t1 = time() bucket_sort(A, len(A)) t2 = time() print("T%d," % test, t2 - t1)
def test_merge_sort_error(self): # arrange arr = 'good morning' # action & assert with self.assertRaises(TypeError): merge_sort(arr)
def iterations(sort_type, n): # This function sorts randomly generated numbers of length n that range from -500 to 500 if sort_type == "selection sort": selection_sort.selection_sort([random.randint(-500,500) for number in range(n)]) elif sort_type == "merge sort": merge_sort.merge_sort([random.randint(-500,500) for number in range(n)]) elif sort_type == "quick sort": quick_sort.quick_sort([random.randint(-500,500) for number in range(n)])
def test_merge_sort_tests(self): '''Test the merge_sort function.''' # Test is_sorted for i in range(50): self.assertTrue(is_sorted(list(range(i)))) # A basic example: L = [4,1,0,3,2] L = merge_sort(L) self.assertTrue(L == list(range(5))) # The empty list should be okay L = [] L = merge_sort(L) self.assertTrue(L == []) # Hopefully it does nothing to already sorted lists: L = list('aeiou') L = merge_sort(L) s = ''.join(L) self.assertTrue(s == 'aeiou') # Does it shine with multisets? L = list('redrum') L = merge_sort(L) s = ''.join(L) self.assertTrue(s == 'demrru') # Do a few tests on lists of random integers for i in range(3,100): L = [] for j in range(2,i): L.append(randint(1,j)) L = merge_sort(L) self.assertTrue(is_sorted(L))
def test_merge(self): unsorted = [5, 4, 3, 2, 1] sorted_lst = [1, 2, 3, 4, 5] high = len(unsorted) - 1 low = 0 merge_sort(unsorted, low, high) self.assertEqual(sorted_lst, unsorted)
def testMerge(self): result = copy(self.original) before = time.time() merge_sort(result) after = time.time() print("Merge Sort, size: %d time: %f" % (self.list_length, after-before)) self.assertEqual(self.sorted_list, result, "Merge Sort Failed")
def test_merge_sort(seq): """Test insertion sort results equal build-in python sort results.""" from merge_sort import merge_sort seq = list(seq) sorted_copy = sorted(seq) merge_sort(seq) assert seq == sorted_copy
def test_big_merge_sort(): ints = [i for i in range(0, 10000)] mixed_ints = [i for i in range(0, 10000)] assert ints == mixed_ints random.shuffle(mixed_ints) assert ints != mixed_ints merge_sort(mixed_ints) assert ints == mixed_ints
def sum_search(items, value): merge_sort.merge_sort(items, 0, len(items) - 1) for i in xrange(0, len(items)): last_item = items[-i-1] index = binary_search.binary_search(items, value - last_item, 0, len(items) - i - 1) if None != index: return (items[index], last_item) return None
def has_pair_of_sum_is_v(A, v): B = list(A) merge_sort(B) for i in range(0, len(B) - 1): if binary_search(B[i + 1:], v - B[i]) is not None: return True else: return False
def sum_exist(a,x): merge_sort(a,0,len(a)-1) ##print a for i in range(len(a)): #binary_search(list,begin,end,key) if binary_search(a,i,len(a)-1,x-a[i]): return True return False
def test_merge_sort_edge_case_two(): arr = ['a', 'c', 'bond', 'b'] merge_sort(arr) assert arr == [ 'a', 'b', 'bond', 'c', ]
def test_stable(): """Test identical items in list retain stable position on sort.""" from merge_sort import merge_sort check_list = [1, 0, 2, 3, 2] two_a = check_list[2] two_b = check_list[4] merge_sort(check_list) assert check_list[2] is two_a assert check_list[3] is two_b
def test_merge_sort(self): # reverse order input arr = [5, 4, 3, 2, 1] sorted_arr = merge_sort(arr) assert sorted_arr == [1, 2, 3, 4, 5] # already sorted arr = [1, 2, 3, 4, 5] sorted_arr = merge_sort(arr) assert sorted_arr == [1, 2, 3, 4, 5]
def test_stable_random(seq): """Test stability property on random lists.""" from merge_sort import merge_sort seq = list(seq) index_a, index_b = sorted(random.sample(range(len(seq)), 2)) val_a, val_b = -1, -1 seq[index_a], seq[index_b] = val_a, val_b merge_sort(seq) assert seq[0] is val_a assert seq[1] is val_b
def test_stable_random_2(seq): """Test that stability fails when sorting to end of list.""" from merge_sort import merge_sort seq = list(seq) index_a, index_b = sorted(random.sample(range(len(seq)), 2)) val_a, val_b = 1000, 1000 seq[index_a], seq[index_b] = val_a, val_b merge_sort(seq) assert seq[-1] is val_a assert seq[-2] is val_b
def test(l1, algorithm_no=1): start = time.time() if algorithm_no == 1: ms.merge_sort(l1) elif algorithm_no == 2: bs.bub_sort(l1) end = time.time() return (end - start)
def test_merge_sort_edge_case(): arr = [ 2.5, -5, 0, 8, 7, 9, ] merge_sort(arr) assert arr == [-5, 0, 2.5, 7, 8, 9]
def test_merge_sort(): assert (merge_sort([5, 2, 4, 6, 1, 3]) == [1, 2, 3, 4, 5, 6].sort()) assert (merge_sort([5, 2, 4, 6]) == [2, 4, 5, 6].sort()) assert (merge_sort([5, 6, 1, 3]) == [1, 3, 5, 6].sort()) assert (merge_sort([5, 2, 6, 1]) == [1, 2, 5, 6].sort()) assert (merge_sort([2, 1]) == [1, 2].sort()) assert (merge_sort([1, 2]) == [1, 2].sort()) assert (merge_sort([2, 1, 1, 1, 2, 1, 3]) == [1, 1, 1, 1, 2, 2, 3].sort()) assert (merge_sort([2, 1, 1, 1, 3, 2, 1]) == [1, 1, 1, 1, 2, 2, 3].sort()) assert (merge_sort([1]) == [1].sort()) assert (merge_sort([1, 0, -1]) == [1, 0, -1].sort())
def permute_by_sorting(A): B = A.copy() n = len(A) n3 = n * n * n P = [None] * n for i in range(n): P[i] = (randint(1, n3), i) merge_sort(P) for i in range(n): A[i] = B[P[i][1]]
def StartAlgorithm(): global data if not data: return if algMenu.get() == 'Merge Sort': merge_sort(data, drawData, speedScale.get()) elif algMenu.get() == 'Bubble Sort': bubble_sort(data, drawData, speedScale.egt()) elif algMenu.get() == 'Quick Sort': quick_sort(data, 0, len(data) - 1, drawData, speedScale.get()) drawData(data, ['green' for i in range(len(data))])
def measure_runtime(alg, arr): if alg == 'merge': start_time = time.time() merge_sort(arr, 0, len(arr)) res = time.time() - start_time elif alg == 'insert': start_time = time.time() insertion_sort(arr) res = time.time() - start_time return res
def choose_pivot(alist): medians = [] index = 0 length = len(alist) while length > index: sorted_group = merge_sort(alist[index:index + 5]) medians.append(sorted_group[len(sorted_group) / 2]) index += 5 sorted_medians = merge_sort(medians) return sorted_medians[len(sorted_medians) / 2]
def test_merge_sort(self): arr1 = [1, 5, 8, 4, 2, 9, 6, 0, 3, 7] arr2 = [] arr3 = [2] arr4 = [0, 1, 2, 3, 4, 5] arr5 = random.sample(range(200), 50) self.assertEqual(merge_sort(arr1), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) self.assertEqual(merge_sort(arr2), []) self.assertEqual(merge_sort(arr3), [2]) self.assertEqual(merge_sort(arr4), [0, 1, 2, 3, 4, 5]) self.assertEqual(merge_sort(arr5), sorted(arr5))
def test_merge_sort(): # even element count assert merge_sort([5, 4, 2, 1]) == [1, 2, 4, 5] # uneven element count assert merge_sort([ 3, 4, 5, 1, 2, ]) == [1, 2, 3, 4, 5]
def test_merge_sort(self): size = 1000000 l = list(range(size)) _l = l[:] shuffle(l) l2 = l[:] t1 = timeit(lambda: merge_sort2(l, 0, len(l) - 1), number=1) merge_sort(l, 0, size - 1) print("Time to sort with mergesort: " + str(t1)) # t2 = timeit(lambda: insertion_sort(l2, 0, len(l2)-1), number=1) # print("Time to sort with insertionsort: " + str(t2)) self.assertEqual(_l, l)
def test_merge_sort(): for i in range(500): array = [] for j in range(i): array.append(random.randrange(-i, i, 1)) temp = array.copy() temp.sort() merge_sort(array) assert temp == array
def decorated_merge_sort(data, key=None): """Sort a sequence using merge-sort, and an optional 'key' to define how sorting should be done.""" if key is not None: for j in range(len(data)): data[j] = _Item(k=key(data[j]), v=data[j]) merge_sort(data) # Can use any sorting function. if key is not None: for j in range(len(data)): data[j] = data[j]._value
def StartAlgorithm(): global data if not data: return if algMenu.get() == 'Quick Sort': quick_sort(data, 0, len(data) - 1, drawData, speedScale.get()) drawData(data, ['green' for x in range(len(data))]) elif algMenu.get() == "Bubble Sort": bubble_sort(data, drawData, speedScale.get()) elif algMenu.get() == "Merge Sort": merge_sort(data, drawData, speedScale.get()) elif algMenu.get() == "Insertion Sort": insertion_sort(data, drawData, speedScale.get()) drawData(data, ['green' for x in range(len(data))])
def test_stable_random_3(seq): """Test stability property on random lists with random duplicate values.""" from merge_sort import merge_sort if len(seq) < 2: return seq = list(seq) index_a = random.randrange(len(seq) - 1) index_b = random.randrange(index_a + 1, len(seq)) val_a = seq[index_a] val_b = int(val_a) seq[index_b] = val_b merge_sort(seq) index_a = seq.index(val_a) assert seq[index_a + 1] is val_b
def merge_sort_complexity(): x, y = [], [] for i in range(10000, 100000, 10000): sample_data = random.sample(range(i), i) start_time = time.time() merge_sort(sample_data) end_time = time.time() x.append(i) y.append(end_time - start_time) plt.plot(x, y) plt.show()
def test_compare(): """ Takes 4 different random lists with 10,000 terms in each and runs them through each sorting method (insertion, merge, merge_quick, and quick). When doing this, the function times how long it takes for each method to process each list. The function prints the trials for each list into sectioned blocks showing the results for each list for every sorting method. :return: None """ print("Time comparison test begins.") print("All lists used in this test are of length 10000.") print("\n") n = 10000 list_num = 1 test_lists = [get_list1(n), get_list2(n), get_list3(n), get_list4(n)] for i in test_lists: if list_num == 1: print("Testing with list 1 - random elements") elif list_num == 2: print("Testing with list 2 - repeated elements") elif list_num == 3: print( "Testing with list 3 - overall increasing elements, not favorable to quick sort" ) elif list_num == 4: print("Testing with list 4 - not favorable to quick sort") insertion_lst = i[:] start = time.time() insertion_sort.insertion_sort(insertion_lst) end = time.time() print("selection_sort Elapsed Time: ", end - start, "seconds") merge_lst = i[:] start = time.time() merge_sort.merge_sort(merge_lst) end = time.time() print("merge_sort Elapsed Time: ", end - start, "seconds") merge_quick_lst = i[:] start = time.time() merge_quick_sort(merge_quick_lst) end = time.time() print("merge_quick_sort Elapsed Time: ", end - start, "seconds") quick_lst = i[:] start = time.time() quick_sort.quick_sort(quick_lst) end = time.time() print("quick_sort Elapsed Time: ", end - start, "seconds") print("\n") list_num += 1
def test_backward_list(): """A backward list will return reversed.""" lst = ['E', 'D', 'C', 'B', 'A'] expected = ['A', 'B', 'C', 'D', 'E'] actual = merge_sort(lst) assert actual == expected
def testcase(index, input_array, expected_output): print("\n-- testcase {} --".format(index)) input_array_copy = input_array print("input array : {}".format(input_array)) print("expected output : {}\n".format(expected_output)) # bst sort bst_sort_result = bst_sort(input_array) print("bst sort: {}, {}".format(bst_sort_result, bst_sort_result == expected_output)) # merge sort merge_sort_result = merge_sort(input_array) print("merge sort: {}, {}".format(merge_sort_result, merge_sort_result == expected_output)) # quick sort quick_sort(input_array, 0, len(input_array) - 1) print("quick sort: {}, {}".format(input_array, input_array == expected_output)) input_array = input_array_copy # heap sort heap_sort_result = heap_sort(input_array) print("heap sort: {}, {}".format(heap_sort_result, heap_sort_result == expected_output))
def test_empty_list(): """An empty list will return unchanged.""" lst = [] expected = [] actual = merge_sort(lst) assert actual == expected
def main(): """Função principal que será rodada quando o script for passado para o interpretador.""" # A função abaixo abre o arquivo texto numeros.txt em modo leitura e lê as linhas dele separando # elas em uma lista de strings. with open('números.txt', 'r', encoding='utf8') as arquivo: linhas_do_arquivo = arquivo.readlines() # Pegue a lista de strings e converta todos os valores dentro dela para inteiros. # TODO COLOQUE SEU CÓDIGO AQUI E APAGUE ESSE COMENTÁRIO DEPOIS. for lis in linhas_do_arquivo: linhas_do_arquivo.append(int(lis)) # O Código abaixo chama cada um dos métodos de ordenação na lista original. # Para garantir que a lista original não muda depois de cada uma das chamadas. # Fazemos cópias dela antes de fazer a chamada. # A função process_time serve para marcar o tempo entre uma e outra chamada das funções e vermos # qual das três é mais rápida. lista_copiada = linhas_do_arquivo.copy() tempo_bubble = time.process_time() lista_ordenada_bubble = bubble_sort(lista_copiada) tempo_bubble = time.process_time() - tempo_bubble lista_copiada = linhas_do_arquivo.copy() tempo_merge = time.process_time() lista_ordenada_merge = merge_sort(lista_copiada) tempo_merge = time.process_time() - tempo_merge lista_copiada = linhas_do_arquivo.copy() tempo_selection = time.process_time() lista_ordenada_selection = selection_sort(lista_copiada) tempo_selection = time.process_time() - tempo_selection print('Tempo de demora do Bubble Sort:', tempo_bubble) print('Tempo de demora do Merge Sort:', tempo_merge) print('Tempo de demora do Selection Sort:', tempo_selection) return lista_ordenada_bubble, lista_ordenada_merge, lista_ordenada_selection
def test_randomly_unsorted_list(): """An unsorted list returns sorted.""" lst = ['C', 'B', 'D', 'E', 'A'] expected = ['A', 'B', 'C', 'D', 'E'] actual = merge_sort(lst) assert actual == expected
def dselect(array, istat): if len(array) <= 5: # should this be 10? sorted_array = merge_sort.merge_sort(array) return sorted_array[istat] else: groups_of_5 = [] for group_start in range(0, len(array) - 4, 5): group = array[group_start:group_start + 5] group_median_pos = math.ceil(len(group) / 2) - len(group) % 2 groups_of_5.append(dselect(group, int(group_median_pos))) median_of_medians = dselect(groups_of_5, len(array)//10) below = [] above = [] pivot = [] for num in range(len(array)): if array[num] == median_of_medians: pivot.append(array[num]) elif array[num] < median_of_medians: below.append(array[num]) else: above.append(array[num]) if istat < len(below): return dselect(below, istat) elif istat >= len(below) + len (pivot): return dselect(above, istat - len(below) - len(pivot)) else: return median_of_medians
def test_merge(): sorted_list = [i for i in range(19000)] unsorted = sorted_list.copy() random.shuffle(unsorted) assert_list_equal(sorted_list, merge_sort(unsorted))
def main(): sample = list(np.random.randint(1000, size=2000)) target = sorted(sample) start = timer() bubble = bubble_sort(sample.copy()) end = timer() assert bubble == target print("bubble sort time (ms) %.4f" % ((end - start) * 1000)) start = timer() selection = selection_sort(sample.copy()) end = timer() assert selection == target print("selection sort time (ms) %.4f" % ((end - start) * 1000)) start = timer() merge = merge_sort(sample.copy()) end = timer() assert merge == target print("merge sort time (ms) %.4f" % ((end - start) * 1000)) start = timer() quick = quick_sort(sample.copy(), 0, len(sample) - 1) end = timer() assert quick == target print("quick sort time (ms) %.4f" % ((end - start) * 1000))
def test_single_item_list(): """A one-itemed list will return unchanged.""" lst = ['A'] expected = ['A'] actual = merge_sort(lst) assert actual == expected
def test_list_gets_sorted_correctly() -> None: to_sort = [random.random() for _ in range(1_000_000)] expected = sorted(to_sort) actual = merge_sort.merge_sort(to_sort) assert actual == expected
def search(arr, item): """Performs binary search on an array with the given item and returns True or False. >>> search([5, 4, 1, 6, 2, 3, 9, 7], 2) True >>> search([5, 4, 1, 6, 2, 3, 9, 7], 8) False """ arr1 = merge_sort(arr) first = 0 last = len(arr1) - 1 found = False while first <= last and not found: midpoint = (first + last) // 2 if arr1[midpoint] == item: found = True else: if item < arr1[midpoint]: last = midpoint - 1 else: first = midpoint + 1 return found
def test_sorting(): import random datalist = [random.randint(0, 1e6) for i in xrange(100)] datalist = merge_sort(datalist) previous = datalist[0] for i in datalist[1:]: assert previous <= i previous = i
def sort_merge(self): """Sorts the cards in this deck in ascending order Uses my my merge_sort""" if self.cards: self.cards = merge_sort(self.cards) return True else: return False
def run_all(input_directory, output_directory): if not os.path.exists(output_directory): os.makedirs(output_directory) def rel(filename): return os.path.join(output_directory, filename) # parse_xml(input_directory, rel('articles-raw.csv'), rel('citations-raw.csv')) # sanitize(rel('articles-raw.csv'), rel('articles-sanitized.csv')) unify_identifiers(rel("articles-sanitized.csv"), rel("articles-id-unified.csv")) merge_sort(rel("articles-id-unified.csv"), rel("articles-id-unified-sorted.csv")) return load_solr(rel("articles-id-unified-sorted.csv")) merge_solr(rel("articles-id-unified-sorted.csv"), rel("articles-solr-unified.csv")) merge_sort(rel("articles-solr-unified.csv"), rel("articles-solr-unified-sorted.csv")) combine_articles(rel("articles-solr-unified-sorted.csv"), rel("articles-tidy.csv"), rel("id-mapping.csv")) combine_articles(rel("articles-id-unified-sorted.csv"), rel("articles-tidy.csv"), rel("id-mapping.csv")) map_identifiers(rel("citations-raw.csv"), rel("citations-tidy.csv"), rel("id-mapping.csv"))
def find_dup_via_sort(array): """ :type array: list of int :return the smallest duplicates """ sorted_array = merge_sort.merge_sort(array) for i in range(len(sorted_array)): if i > 0: if sorted_array[i - 1] == sorted_array[i]: return sorted_array[i] return None
def test_stability(): """A.""" from merge_sort import merge_sort lst = [(2, 'ab'), (1, 'ba'), (3, 'ab'), (2, 'ba'), (5, 'ab')] one = lst[0] two = lst[3] sort_lst = merge_sort(lst) assert sort_lst == [(1, 'ba'), (2, 'ab'), (2, 'ba'), (3, 'ab'), (5, 'ab')] assert sort_lst[1] is one assert sort_lst[2] is two
def test_quick_sort(build_list): x, y = build_list assert quick_sort(x) == y import random for i in xrange(100): x = [random.randint(10,100) for i in xrange(20)] y = merge_sort(x) z = quick_sort(x) assert y == z
def test_randomly(self): for each_pass in range(0, 1000): random_list = [] for each_number in range(0, random.randint(3, 40)): random_number = random.randint(0, random.randint(1, 1000)) random_list.append(random_number) sorted_random_list = m_s.merge_sort(random_list) assert len(random_list) == len(sorted_random_list) for each_number in range(0, (len(sorted_random_list) - 1)): assert (sorted_random_list[each_number] <= sorted_random_list[(each_number + 1)])
def main(): if len(sys.argv) != 2: print 'usage: ./compare_sort_algos.py --len_of_array' sys.exit(1) len_of_array = sys.argv[1] # This argument has length of the array to be sorted. print len_of_array # Create Random numbers of this length. The random numbers generated are unique. array = random.sample(xrange(10000000), int(len_of_array)) #print array sorted_array = insertion_sort.insertion_sort(array) insertion_time = time.clock() insertion_tot = insertion_time - start_time print ("Insertion Sort %s" % insertion_tot) sorted_array = selection_sort.selection_sort(array) selection_time = time.clock() selection_tot = selection_time - insertion_time print ("Selection Sort %s" % (selection_tot)) sorted_array = bubble_sort.bubble_sort(array) bubble_time = time.clock() bubble_tot = bubble_time - selection_time print ("Bubble Sort %s" % (bubble_tot)) sorted_array_m = merge_sort.merge_sort(array) merge_time = time.clock() merge_tot = merge_time - bubble_time print ("Merge Sort %s" % (merge_tot)) sorted_array_q = quick_sort.quick_sort(array) quick_time = time.clock() quick_tot = quick_time - merge_time print ("Quick Sort %s" % (quick_tot)) sorted_array_h = heap_sort.heap_sort(array) heap_time = time.clock() heap_tot = heap_time - quick_time print ("Heap Sort %s" % (heap_tot)) objects = ('Insertion', 'Selection', 'Bubble', 'Merge','Quick','Heap') y_pos = np.arange(len(objects)) performance = [insertion_tot/merge_tot,selection_tot/merge_tot,bubble_tot/merge_tot,merge_tot/merge_tot,quick_tot/merge_tot,heap_tot/merge_tot] if (sorted_array_m == sorted_array_q): print "Merge and Quick sorts are giving the same sorted array results" plt.bar(y_pos, performance, align='center', alpha=0.5) plt.xticks(y_pos, objects) plt.ylabel('Time taken w.r.t merge sort') plt.title('Sorting Techniques') plt.show()
def test_input(): # Checks that it needs a list with pytest.raises(TypeError): merge_sort() d = {1: 'one', 2: 'two'} with pytest.raises(TypeError): merge_sort(d) with pytest.raises(TypeError): merge_sort(None)
def test_merge_sort(): # get data from file print("test merge sort.") in_data = [] for line in fileinput.input("../../data/sort1.dat"): in_data.append(int(line)) print("in_data", in_data) target_data = in_data.copy() target_data.sort() print("target_data", target_data) from merge_sort import merge_sort out_data = merge_sort(in_data) print("out_data", out_data) assert (out_data == target_data)
def test_predictably(self): dict_of_lists = { 'list_zero': [0, 0, 0, 0, 0, 0, 0, 0], 'list_one': [0, 0, 0, 0, 1, 1, 1, 1], 'list_two': [0, 1, 0, 1, 0, 1, 0, 1], 'list_three': [0, 1, 1, 0, 1, 1, 0, 0], 'list_four': [10, 100, 1000000, 10000, 1, 100000, 0, 1000], 'list_five': [0001, 0010, 0100, 1000, 1100, 0011, 0101, 0110], } for each_key in dict_of_lists: each_list = dict_of_lists[each_key] sorted_list = m_s.merge_sort(each_list) assert len(sorted_list) == len(each_list) for each_number in range(0, (len(each_list) - 1)): assert (sorted_list[each_number] <= sorted_list[(each_number + 1)])
def deterministic_pivot(): """ This deterministic method of choosing a pivot is from 1973 by Blum, Floyd, Pratt, Rivest, and Tarjan. Outputs 'median of medians' as pivot. This is O(n) time despite recursive calls within (!). Downsides: it has worse constants in running time than randomized pivot and it is not in-place. """ n = right - left + 1 l = a[left:right+1] while len(l) > 5: # breaks l into chunks of 5 l = [l[i:i+5] for i in xrange(0, n, 5)] # this is O(n), not O(nlogn), because each chunk is small, constant # time for each chunk l = [merge_sort(chunk) for chunk in l] l = [chunk[len(chunk)/2] for chunk in l] median_of_medians = l[len(l)/2] return next(i for i,v in enumerate(l) if v == median_of_medians)
def test_merge_sort(self): self.assertEqual(merge_sort.merge_sort(self._arr), self._res)
def test_sort_simple(): """Test on simple case.""" from merge_sort import merge_sort a_list = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] merge_sort(a_list) assert a_list == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
def merge_arrays(array1, array2): return merge_sort(merge(array1, array2))
def test_merge_sort_correctly_sorts(self): sorted_values = merge_sort(self.unsorted_values) self.assertEqual(sorted(self.unsorted_values), sorted_values)