def run_program(): pygame.init() screen = pygame.display.set_mode((900, 650)) sr_setting = Setting() pygame.display.set_caption("Sorting alogrithms") fnt = pygame.font.SysFont("comicsans", 25) fnt1 = pygame.font.SysFont("comicsans", 30) array = [0] * 151 arr_color = [sr_setting.Green] * 151 clr = [ sr_setting.Green, sr_setting.Red, sr_setting.Dark_blue, sr_setting.Orange, sr_setting.bg_color ] pf.shuffel_arr(array) while True: for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_q: sys.exit() if event.key == pygame.K_m: ms.mergesort(array, 1, len(array) - 1, arr_color, clr, screen, fnt, fnt1) if event.key == pygame.K_b: bs.bubblesort(array, arr_color, clr, screen, fnt, fnt1) if event.key == pygame.K_s: qs.quicksort(array, arr_color, clr, screen, fnt, fnt1) screen.fill(sr_setting.bg_color) pf.draw(screen, fnt, fnt1, array, arr_color, clr) pygame.display.flip()
def coo_to_csc(N, col, row, data): quicksort((col, row, data), 0, len(data)) k = 0 # merge same cords for i in range(1, len(data)): if col[k] != col[i] or row[k] != row[i]: k += 1 col[k], row[k], data[k] = col[i], row[i], data[i] else: data[k] += data[i] data, row = data[:k + 1], row[:k + 1] # create colptr col.resize(len(data) + 1, refcheck=False) k = 0 c = col[0] for i in range(1, len(data)): c1 = col[i] if c1 != c: k += 1 col[k] = i c = c1 col[k + 1] = len(data) col = col[:k + 2] return col, row, data
def test_random_list(self): random_sz = randint(1, 2000) a = [randint(-2000, 5000) for i in range(0, random_sz)] b = a[:] quicksort(a) b.sort() self.assertEqual(a, b)
def main(): """ bubblesort的时间复杂度是O(n^2) quicksort的时间复杂度是O(nlogn) """ # csv_path = "./bubblesort.csv" csv_path = "./quicksort.csv" nsample = 1 N = list(range(10, 10000, 10)) avg_elapsed = 0 for n in N: for _ in range(nsample): l = [random.randint(0, 10000) for _ in range(n)] start = time.clock() # bubblesort(l) quicksort(l) elapsed = (time.clock() - start) # print("Time used:", elapsed) avg_elapsed += elapsed avg_elapsed /= nsample print("n:", n) print("Average time used:", avg_elapsed) if not os.path.exists(csv_path): f = open(csv_path, "w") f_csv = csv.writer(f) f_csv.writerow(["N", "avg_elapsed"]) f_csv.writerow((n, avg_elapsed)) else: f = open(csv_path, "a") f_csv = csv.writer(f) f_csv.writerow((n, avg_elapsed)) avg_elapsed = 0
def test__sort(self): data = [1, 3, 2, 8] quicksort(data, 0, len(data) - 1) self.assertEqual([1,2,3, 8], data) data1 = [150, 4, 2, 7, 1, 9, 160] quicksort(data1, 0, 6) self.assertEqual([1, 2, 4, 7, 9, 150, 160], data1)
def test_quick(l, mid_pivot=True): result = 0 for x in range(10): arr = copy(l) t = time.time() quicksort(l, mid_pivot=mid_pivot) result += time.time() - t return result
def test_quicksort(self): for j in range(10): l = rand_list(max_list=100) # no return! quicksort(l) for i in range(0, len(l) - 1): self.assertLessEqual(l[i], l[i + 1])
def test_sorting_correctness(self): """It should sort correctly despite pivot selection strategy""" unsorted_array = [3, 8, 2, 5, 1, 4, 7, 6] sorted_array_with_first, _ = quicksort.quicksort(unsorted_array, quicksort.select_first) sorted_array_with_last, _ = quicksort.quicksort(unsorted_array, quicksort.select_last) sorted_array_with_middle, _ = quicksort.quicksort(unsorted_array, quicksort.select_middle) self.assertEqual(sorted_array_with_first, [1, 2, 3, 4, 5, 6, 7, 8]) self.assertEqual(sorted_array_with_first, sorted_array_with_last) self.assertEqual(sorted_array_with_first, sorted_array_with_middle)
def testSort(self): a = [1, 2, 3, 4, 5, 6, 7, 8, 9] self.assertEqual(quicksort.quicksort(a), [1, 2, 3, 4, 5, 6, 7, 8, 9]) b = [8, 7, 6, 5, 4, 3, 2, 1] self.assertEqual(quicksort.quicksort(b), [1, 2, 3, 4, 5, 6, 7, 8]) c = [1, 6, 3, 2, 1, 9, 7, 5, 4, 9] self.assertEqual(quicksort.quicksort(c), [1, 1, 2, 3, 4, 5, 6, 7, 9, 9])
def sortPoints(pList, coord_str): if (coord_str == "x"): # Sort by x-coords quicksort.quicksort(pList, 0, len(pList)-1, pointUtils.compareX) elif (coord_str == "y"): # Sort by y-coords quicksort.quicksort(pList, 0, len(pList)-1, pointUtils.compareY) else: # Print error and get out. print "ERROR: pointUtils.sortPoint(): Please use param x or y"
def main ( ): menu ( ) for i in range ( len ( gb.n ) + 1 ): m, gb.time = gb.n [ :i ], 0 quicksort ( m, 0, len ( m ) - 1 ) gb.parameters.append ( ( len ( m ), gb.time ) ) print ( "\n\tSorted list: ", m, "\n" ) print ( "\n\tQuicksort Parameters: ", gb.parameters ) print ( "\n\tPartition Parameters: ", gb._parameters ) graph ( )
def test_integers_sort(self): for i, input in enumerate(range(100)): input = random.sample(range(0, 1000), 16) size = len(input) - 1 expected = sorted(input) quicksort(input, 0, size) print( "\n----------Test#:{}----------\nInput: {}\nExpected: {}\nResult: {}\n" .format((i + 1), input, expected, input == expected)) self.assertEqual(input, expected)
def test_quicksort(self): # reverse order input arr = [5, 4, 3, 2, 1] sorted_arr = quicksort(arr) assert sorted_arr == [1, 2, 3, 4, 5] # already sorted arr = [1, 2, 3, 4, 5] sorted_arr = quicksort(arr) assert sorted_arr == [1, 2, 3, 4, 5]
def test_quicksort(): input = [8, 7, 4, 2, 6, 5, 3, 1] arr = input[:] quicksort(arr) assert arr, sorted(input) input = [randrange(1, 100) for x in range(100)] arr = input[:] quicksort(arr) assert arr, sorted(input)
def testRandom(): print("Beginning testRandom:") arr = [] low = 0 high = 1000 fillArrayRandom(arr, ELEMENTS, low, high) quicksort(arr) if not isSorted(arr): print(arr) assert (isSorted(arr)) print("*****\tPASS\t*****")
def test_quicksort(self): arr = [] self.assertEqual(quicksort(arr), []) arr = [i for i in range(9, -1, -1)] self.assertEqual(quicksort(arr), [i for i in range(10)]) arr = [5, 6, 1, 3, 8, 2, 1] self.assertEqual(quicksort(arr), [1, 1, 2, 3, 5, 6, 8]) arr = [10, 20, 30, 10, 12, 21, 1] self.assertEqual(quicksort(arr), [1, 10, 10, 12, 20, 21, 30])
def test_quicksort(): test_list = [randint(1, 50) for i in range(15)] test_sorted = test_list[:] quicksort(test_sorted, 0, 14) if test_sorted == sorted(test_list): print("test passes") print(test_list) print(test_sorted) else: print("test fails") print(test_list) print(test_sorted)
def test_binary_search(): items = [] for i in range(1000): items.append(random.randint(0, 999)) quicksort(items, 0, len(items) - 1) for i in range(100): assert binary_search(items, random.choice(items)) assert not binary_search(items, -1) assert not binary_search(items, 1000)
def test5(self): """ Test of other's quicksort """ numElements = 10 testlist = [random.randint(0, 10) for r in xrange(numElements)] # testlist = random.sample(xrange(999999999), numElements) answer = sorted(testlist) start = time.time() quicksort.quicksort(testlist, 0, len(testlist) - 1) elapsed = (time.time() - start) print 'In place takes %s' % str(elapsed) self.assertLessEqual(testlist, answer)
def checkpairsumaftersorting(arr, x): quicksort.quicksort(arr, 0, len(arr)-1) print arr i = 0 j = len(arr)-1 while (i<j): if arr[i]+arr[j] > x: j -= 1 if arr[i]+arr[j] < x: i += 1 if arr[i]+arr[j] == x: return True return False
def add_edge(self, from_vertex, to_vertex, weight=0): self.graph_dict[from_vertex.value].add_edge(to_vertex.value, weight) if not self.directed: self.graph_dict[to_vertex.value].add_edge(from_vertex.value, weight) if len(list(self.graph_dict[from_vertex.value].edges)) > 1: edges = list(self.graph_dict[from_vertex.value].edges.keys()) quicksort(edges, 0, len(edges) - 1) zeros = [0 for i in range(len(edges))] new_edges = {key: value for key, value in zip(edges, zeros)} self.graph_dict[from_vertex.value].edges = new_edges
def pair_sum(arr, target): quicksort(arr) start_index = 0 end_index = len(arr) - 1 while start_index < end_index: sum = arr[start_index] + arr[end_index] if sum == target: return arr[start_index], arr[end_index] elif sum < target: start_index += 1 else: end_index -= 1 return None, None
def find2num(array, sum): global global_init if not global_init: quicksort(array) global_init = True print "Init Finish" print "sort:", array length = len(array) pos = -1 for i in range(0, length - 1): pos = binarysearch(array, sum - array[i], i + 1, length - 1) if pos >= 0: print array[i], ",", array[pos] return True return False
def test_long_unsorted_list(self): long_unsorted_list = [ 12, 3, 4, 12, 4, 35, 6, 7, 23, 4, 5, 6, 46, 43, 1, 1, 111, 2, 3, 4, 535, 6, 53, 45, 2, 21, 4, 52, 3, 4, 5, 6, 345, 32, 42 ] self.assertEqual(quicksort(long_unsorted_list), sorted(long_unsorted_list))
def performRecognition(self,contour): contour = contour.replace('A','u').replace('S','r').replace('D','d') songs = midiSong.findSong(contour) if songs == None: return songs elif (len(songs) == 50): self.failuretype = True return None else: print(len(songs)) if (self.sorttype == "occ"): quicksort.quicksort(songs) songs.reverse() else: stringSort.stringSort(songs, self.sorttype) return songs
def test_swap_checks_correctness(self): """It should calculcate swap checks correctly""" # because it is in decreasing order, we will check it 5 + 4 + 3 + 2 + 1 times unsorted_array = [6, 5, 4, 3, 2, 1] _, number_of_checks = quicksort.quicksort(unsorted_array, quicksort.select_first) self.assertEqual(number_of_checks, 15)
def test_sorted_list(): """A sorted list will return unchanged""" lst = ['A', 'B', 'C', 'D', 'E'] expected = ['A', 'B', 'C', 'D', 'E'] actual = quicksort(lst) assert actual == expected
def test_single_item_list(): """A one-itemed list will return unchanged""" lst = ['A'] expected = ['A'] actual = quicksort(lst) assert actual == expected
def test_backward_list(): """A backward list will return reversed""" lst = ['E', 'D', 'C', 'B', 'A'] expected = ['A', 'B', 'C', 'D', 'E'] actual = quicksort(lst) assert actual == expected
def sorttest(N,M): attempts = 100 print("Testing...") timelist = [] for k in range(attempts): n = random.randint(2,N) array = [] for i in range(n): array.append(random.randint(0,M)) correct = bubblesort.bubblesort(array) t0 = time.time() #INPUT ALGORITHM TO TEST HERE:# testanswer = quicksort.quicksort(array) ############################### timelist.append(time.time()-t0) if testanswer != correct: print("Error detected!") print("Input Array = ",array) print("Answer: ",testanswer) print("Desired: ",correct) return print("OK! - ",attempts," trials completed.") mean_time = sum(timelist)/len(timelist) print('Average time: ', round(mean_time,8)," seconds") return
def performRecognition(self, contour): contour = contour.replace('A', 'u').replace('S', 'r').replace('D', 'd') songs = midiSong.findSong(contour) if songs == None: return songs elif (len(songs) == 50): self.failuretype = True return None else: print(len(songs)) if (self.sorttype == "occ"): quicksort.quicksort(songs) songs.reverse() else: stringSort.stringSort(songs, self.sorttype) return songs
def test_randomly_unsorted_list(): """An unsorted list returns sorted""" lst = [3, 2, 4, 5, 1, 6] expected = [1, 2, 3, 4, 5, 6] actual = quicksort(lst) assert actual == expected
def radix_sort_str(instr): """The radix sort algorithm implemented for strings. Sorts lexico- graphically. """ li = instr[:] length = 0 for i in li: if len(i) > length: length = len(i) buckets = {} i = length - 1 while i >= 0: for word in li: try: bucket = buckets.setdefault(word[i], Queue()) except IndexError: bucket = buckets.setdefault('0', Queue()) bucket.queue(word) li = [] #quicksort is used here to get the buckets out in lexicographical #order because calling radix_sort_str again would result in an #infinite recursion. for key in quicksort(buckets.keys()): while buckets[key].size(): li.append(buckets[key].dequeue()) i -= 1 return li
def test_empty_list(): """An empty list will return unchanged""" lst = [] expected = [] actual = quicksort(lst) assert actual == expected
def test_quicksort(seq: list) -> None: """Verify QuickSort works.""" expected = sorted(seq) actual = quicksort.quicksort(seq) assert actual == expected
def main(): n = int(input("Enter the number of items you would like to sort: ")) myList = [] for index in range(n): myList.append(random.randint(1, n)) # print("Unsorted List:",myList) start = time.perf_counter() quicksort(myList) endSort = time.perf_counter() # print( "Sorted List: ",myList) print("Total quick sort time of", n, "random items", endSort - start)
def createNewGen(self, prozent): list = self.shortTourlist(prozent) newlist = [] for i in range(len(self.tourlist)): a = randint(0, len(list) - 1) b = randint(0, len(list) - 1) newlist.append(self.crossover(list[a], list[b])) self.tourlist = quicksort(newlist + list, compare_fitness)[:100] self.mutiere()
def mergesort(n, size = 10): L = len(n) if L < size: return quicksort(n) else: a = mergesort(n[:L//2], size) b = mergesort(n[L//2:], size) return merge(a, b)
def test_quicksort_neg(): """Test that quicksort handles negative integers.""" assert quicksort([ 9567, 3472, 667, -200966, 34567, 87, 43334124, -2985, 287493, -245964, 1, 6, 903 ]) == [ -245964, -200966, -2985, 1, 6, 87, 667, 903, 3472, 9567, 34567, 287493, 43334124 ]
def test_quicksort_two(): """Tests quicksort output return is correctly sorted.""" assert quicksort([ 9567, 3472, 667, 200966, 34567, 87, 43334124, 2985, 287493, 245964, 1, 6, 903 ]) == [ 1, 6, 87, 667, 903, 2985, 3472, 9567, 34567, 200966, 245964, 287493, 43334124 ]
def find2num(array, sum): # init global global_init if not global_init: quicksort(array) global_init = True print "Init Finish" # check low = 0 high = len(array) - 1 while low < high: if array[low] + array[high] < sum: low += 1 elif array[low] + array[high] > sum: high -= 1 else: print "find:", array[low], ",", array[high] return True return False
def test_quicksort_with_lots_of_random_lists(): """Test quicksort with many random lists.""" from quicksort import quicksort for i in range(100): list_length = random.randint(0, 100) unsorted_list = [] for x in range(list_length): unsorted_list.append(random.randint(0, 100)) assert quicksort(unsorted_list) == sorted(unsorted_list)
def draw(self,surface, relative=0): spritedict = self.spritedict items = spritedict.items() dirty = self.lostsprites self.lostsprites = [] #Z Buffer #test if the obj is being visualized in the screen now. # if not, they dont need to be z-buffered v = self.viewport.colliderect zlevel = [item for item in items if v(item[0].rect)] if zlevel.__len__() > 0: quicksort.quicksort(zlevel,0,zlevel.__len__()-1) #zlevel.sort(cmp) a = range(zlevel.__len__()) a.reverse() for k in a: s,r = zlevel[k] r = copy.copy(s.rect) if self.relative: r.top -= self.viewport.top r.left-= self.viewport.left newrect = surface.blit(s.image,r.topleft) if r is not 0: dirty.append(newrect.union(r)) else: dirty.append(newrect) spritedict[s] = newrect return dirty
def testRandom(): arr = [] # Range for random integers low, high = 0, 1000 print("\nRunning testRandom:") # Insert random elements for _ in range(ELEMENTS): arr.append(randint(low, high)) # Sort array quicksort(arr) # Ensure we can find all the elements in the array for num in arr: if (binarySearch(arr, num) == -1): print("Error: number {} not found in array".format(\ num)) #assert(binarySearch(arr, num) != -1) print("***** PASS *****")
def main(args): numbers = get_values(args[0]) if (len(numbers) <= 0): sys.exit(84) print(len(numbers), " element", sep="", end="") print("s" if len(numbers) > 1 else "") selection(numbers[::]) insertion(numbers[::]) bubble(numbers[::]) print_res("Quicksort:", 0 if (len(numbers) <= 1) else quicksort(numbers[::])[1]) print_res("Merge sort:", merge(numbers[::])[1])
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 = qs.quicksort(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)])