def run(): numbers = range(10000) datas = [] times = [] sizes = [10, 100, 500, 1000, 5000, 10000, 20000, 30000] for s in sizes: datas.append(random.choices(numbers, k=int(s))) print('Insertion Sort\n') for data in datas: startTime = time_ns() insertionSort(data) endTime = time_ns() executionTime = endTime - startTime print(len(data), 'Datas ->', executionTime, 'nanoseconds') times.append(executionTime / 1000000000) plotSort(sizes, times, 'Insertion Sort') times.clear() print('\n\nMerge Sort\n') for data in datas: startTime = time_ns() mergeSort(data, 0, len(data) - 1) endTime = time_ns() executionTime = endTime - startTime print(len(data), 'Datas ->', executionTime, 'nanoseconds') times.append(executionTime / 1000000000) plotSort(sizes, times, 'Merge Sort')
def test_insertion_sort(self): input = [10, 2, 13, 8, 16, 14] output = [2, 8, 10, 13, 14, 16] #insertionSort(input) mergeSort(input, 0, 5) self.assertListEqual(input, output)
def run(n): data = sample(range(n + 1), n) start_time = time_ns() mergeSort(data, 0, n - 1) end_time = time_ns() time_taken = end_time - start_time print(time_taken) execution_time.append(time_taken)
def sortedHist(hist, minT=0): "Actually returns a sorted list of (key, value) tuples" tuples = hist.items() if minT > 0: tuples = filter(lambda kvtuple: kvtuple[1] > minT, tuples) # True implies reverse=True, aka DESCENDING return mergeSort(tuples, __hist_cmp, True)
def assignment2(): l = createRandomList(10) l1 = l[:] l2 = l[:] l3 = l[:] l4 = l[:] ls = sorted(l) sorting.quickSort(l1, 0, len(l1) - 1) sorting.quickSort(l2, 0, len(l2) - 1, True) sorting.mergeSort(l3) sorting.countingSort(l4) print("Unsorted: ", l) print("Epected: ", ls) print("After quick: ", l1) print("After modified quick: ", l2) print("after merge: ", l3) print("after counting: ", l4)
def findMedian(lis): """ find the median of a sequence by simply sorting them and obtain the item in the cell with index at the middle. """ m=len(lis)//2 l=sorting.mergeSort(lis) return l[m] if len(l)%2!=0 else (l[m-1]+l[m])/2
def do_merge_sort(self): if not self.start and not self.sorted: self.start = True self.bars = sorting.mergeSort(self.bars, self) self.start = False self.sorted = True return True else: return False
def generar_tiempos(n): lista_insertion = [random.random() for i in range(0, n)] lista_selection = copy.deepcopy(lista_insertion) lista_bubble = copy.deepcopy(lista_insertion) lista_merge = copy.deepcopy(lista_insertion) lista_quick = copy.deepcopy(lista_insertion) tiempo_1 = time.process_time() sorting.insertionSort(lista_insertion) tiempo_2 = time.process_time() sorting.selectionSort(lista_selection) tiempo_3 = time.process_time() sorting.bubbleSort(lista_bubble) tiempo_4 = time.process_time() sorting.mergeSort(lista_merge) tiempo_5 = time.process_time() sorting.quickSort(lista_quick) tiempo_6 = time.process_time() return np.asarray( (n, tiempo_2 - tiempo_1, tiempo_3 - tiempo_2, tiempo_4 - tiempo_3, tiempo_5 - tiempo_4, tiempo_6 - tiempo_5))
def main(): randomList = createRandomList(10) randomList2 = randomList[:] randomList3 = randomList[:] randomList4 = randomList[:] randomList5 = randomList[:] expectedResult = sorted(randomList[:]) print("Generated list: ", randomList) print("Expected result: ", expectedResult) sorting.bubbleSort(randomList) print("After Bubble sort: ", randomList) sorting.selectionSort(randomList2) print("After selection sort: ", randomList2) sorting.shakerSort(randomList3) print("After shaker sort: ", randomList3) sorting.mergeSort(randomList4) print("After merge sort: ", randomList4) sorting.quickSort(randomList5, 0, len(randomList5) - 1) print("After quick sort: ", randomList5)
def main(): if len(sys.argv) > 4: problem = loadProblem(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]) else: filename = utils.getOpenFileName("problem.txt") delimeter = utils.getDelimeter(",") data_type = utils.getDataType("int") problem = loadProblem(filename, delimeter, data_type) comparisson_function = utils.getComparissonFunction("lambda x,y: x>y") print("Sample items in the problem: %s" % problem[:10]) f = eval(comparisson_function) insertion_sorted = sorting.insertionSort([x for x in problem], f) merge_sorted = sorting.mergeSort([x for x in problem], f) quick_sorted = sorting.quickSort([x for x in problem], f, 0, len(problem)-1) print("insertion sorted: %s" % insertion_sorted) print("merge sorted: %s" % merge_sorted)
def main(): number_of_random_tests = 100 size_of_problems = 5 filename = "test.txt" f = lambda x,y: x>y errors = {"insertion sort":0, "merge sort":0, "quick sort":0} for _ in range(number_of_random_tests): A = random.sample(range(size_of_problems), size_of_problems) insertion_sort = sorting.insertionSort([x for x in A], f) merge_sort = sorting.mergeSort([x for x in A], f) quick_sort = [x for x in A] sorting.quickSort(quick_sort, f, 0, len(A)-1) testAlgo(A, insertion_sort, "insertion sort", errors, f) testAlgo(A, merge_sort, "merge sort", errors, f) testAlgo(A, quick_sort, "quick sort", errors, f) print("errors: \n {}".format(errors))
def binarySearch(array, targval): """ Performs binary search. """ L, R = 0, len(array) - 1 while True: m = (L+R) // 2 if array[m] < targval: L = m + 1 continue if array[m] > targval: R = m - 1 continue break return m userarray = input("Enter a series of numbers, divided by space, to have it " "sorted, then have a binary search performed.\n") userarray = userarray.split(" ") for i in range(len(userarray)): userarray[i] = int(userarray[i]) if len(userarray) > 1: uservalue = int(input("\nNow enter a value to search its index.\n")) userarray = mergeSort(userarray) print("\nAfter sorting, first occurence of element " + str(uservalue) + " has index of " + str(binarySearch(userarray, uservalue)) + ": " + str(userarray)) else: print("Not enough elements in the array.\n") input("Press Enter to close the program.")
from sorting import mergeSort import matplotlib.pyplot as plt n = 1000 mergeTimeArrayRandom = [] mergeTimeArrayBest = [] mergeTimeArrayWorst = [] sizeArr = [] for i in range(n, n * 11, n): sizeArr.append(i) randomValues = random.sample(range(i), i) bestCase = randomValues worstCase = randomValues startTime = time() mergeSort(randomValues) endTime = time() totalTime = endTime - startTime mergeTimeArrayRandom.append(totalTime) print("For", i, "the time is", totalTime) bestCase.sort() startTime = time() mergeSort(bestCase) endTime = time() totalTime = endTime - startTime mergeTimeArrayBest.append(totalTime) print("For", i, "the time is", totalTime) worstCase.sort(reverse=True) startTime = time()
def test_merge_sort_descending(self): """ test the merge sort in descending order """ self.assertEqual(mergeSort(self.initA, False), self.decreasing)
def test4(self): '''Test 4 checks that the merge sort can sort a list of 4 items reversed. ''' inlist = [4,3,2,1] outlist = [1,2,3,4] assert (sorting.mergeSort(inlist)==outlist) #test 4 fails - list not sorted by merge sort.
def sortedSubstrHist(hist, minT=0): tuples = hist.items() if minT > 0: tuples = filter(lambda kvtuple: kvtuple[1] > minT, tuples) # True implies reverse=True, aka DESCENDING return mergeSort(tuples, __substr_hist_cmp, True)
def test_merge_sort(self): arr=[6,1,0,3,8,2,4,7,5,9] sortedArr = [0,1,2,3,4,5,6,7,8,9] mergeSort(arr) self.assertListEqual(arr,sortedArr)
def test_merge_sort_ascending(self): """ test the merge sort in ascending order """ self.assertEqual(mergeSort(self.initA), self.increasing)