def sort_array(array, array_size, method='quick'): if method == 'quick': quick_sort(array, 0, array_size - 1) elif method == 'heap': heap_sort(array) elif method == 'cocktail': cocktail_sort(array)
def quick_vs_selec_vs_insr(): lista = [] for i in range(40000): aleatorio = random.randint(0, 40000) lista.append(aleatorio) tempo = time.time() quick_sort(lista, 0, len(lista) - 1) fim = time.time() print("[QUICKSORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo)) lista = [] for i in range(40000): aleatorio = random.randint(0, 40000) lista.append(aleatorio) tempo = time.time() selection_sort(lista, len(lista)) fim = time.time() print("[SELECTIONSORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo)) lista = [] for i in range(40000): aleatorio = random.randint(0, 40000) lista.append(aleatorio) tempo = time.time() insertion_sort(lista, len(lista)) fim = time.time() print("[INSERTIONSORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo)) print("\n")
def quicksort_vs_mergesort(): data = [] for i in range(4000000): random_num = random.randint(0, 4000000) data.append(random_num) start = time.time() quick_sort(data, 0, len(data) - 1) end = time.time() print( "[QUICKSORT] 4000000 (4 million) integers random numbers \n [start] " + str(end - start)) print("\n") data = [] for i in range(4000000): random_num = random.randint(0, 4000000) data.append(random_num) start = time.time() merge_sort(data) end = time.time() print( "[MERGESORT] 4000000 (4 million) integers random numbers \n [start] " + str(end - start)) print("\n")
def assess(result): quicksort.quick_sort(result) tpr = 0 fpr = 0 for elem in result: if elem[1] == 1: tpr += 1 else: fpr += 1 pos_area = 0 neg_area = 0 i = len(result) - 1 x = 0 y = 0 while i >= 0: if result[i][1] == 1: y += 1 else: x += 1 pos_area += y / tpr neg_area += 1 - y / tpr i -= 1 print("pos_area:" + str(pos_area)) print("neg_area:" + str(neg_area)) return pos_area / (pos_area + neg_area)
def StartAlgorithm(): global data speed = int(speedScale.get()) if speed == 2: speed = 0.5 elif speed == 3: speed = 0.1 elif speed == 4: speed = 0.05 elif speed == 5: speed = 0.01 elif speed == 6: speed = 0.005 elif speed == 7: speed = 0.001 if selected_algo.get() == "Bubble Sort": bubble_sort(data, drawData, speed) elif selected_algo.get() == "Selection Sort": selection_sort(data, drawData, speed) elif selected_algo.get() == "Insertion Sort": insertion_sort(data, drawData, speed) elif selected_algo.get() == "Merge Sort": merge_sort(data, 0, len(data) - 1, drawData, speed) drawData(data, ['light green' for x in range(len(data))]) time.sleep(speed) elif selected_algo.get() == "Quick Sort": quick_sort(data, drawData, speed)
def quicksort_vs_bubble(): lista = [] for i in range(40000): random_num = random.randint(0, 40000) lista.append(random_num) start = time.time() quick_sort(lista, 0, len(lista) - 1) end = time.time() print("[QUICKSORT] 40000 (40K) integers random numbers \n [TIME] " + str(end - start)) lista = [] for i in range(40000): random_num = random.randint(0, 40000) lista.append(random_num) start = time.time() bubble_sort(lista, len(lista)) end = time.time() print("[BUBBLESORT] 40000 (40K) integers random numbers \n [TIME] " + str(end - start)) print("\n")
def StartAlgorithm(): global data speed = int(speedScale.get()) if speed == 2: speed = 1.5 elif speed == 3: speed = 0.1 elif speed == 4: speed = 0.05 elif speed == 5: speed = 0.01 elif speed == 6: speed = 0.005 elif speed == 7: speed = 0.001 search = int(searchEntry.get()) if selected_algo.get() == "Bubble Sort": bubble_sort(data, drawData, speed) elif selected_algo.get() == "Selection Sort": selection_sort(data, drawData, speed) elif selected_algo.get() == "Insertion Sort": insertion_sort(data, drawData, speed) elif selected_algo.get() == "Merge Sort": merge_sort(data, 0, len(data) - 1, drawData, speed) drawData(data, ['light green' for x in range(len(data))]) time.sleep(speed) elif selected_algo.get() == "Quick Sort": quick_sort(data, drawData, speed) elif algMenu.get() == 'Linear Search': linear_search(data, search, drawData, speedScale.get()) elif algMenu.get() == 'Binary Search': merge_sort(data, 0, len(data) - 1, drawData, speed) drawData(data, ['red' for x in range(len(data))]) binary_search(data, search, drawData, speedScale.get())
def run_single_test(algorithm, list_type, list_size): sort_list = get_list(list_type, list_size) pr = cProfile.Profile() pr.enable() if algorithm == "merge_sort": mergesort.merge_sort(sort_list, 0, len(sort_list) - 1) elif algorithm == "quicksort": quicksort.quick_sort(sort_list, 0, len(sort_list) - 1) elif algorithm == "revised_quicksort": revised_quicksort.revised_quick_sort(sort_list, 0, len(sort_list) - 1, 50) elif algorithm == "shell_sort": shellsort.shell_sort(sort_list, get_shellsort_gaps(list_size)) pr.disable() s = io.StringIO() ps = pstats.Stats(pr, stream=s).sort_stats("cumulative") ps.strip_dirs().print_stats() results = s.getvalue() for line in results.splitlines(): if "_sort)" in line: print(line) split_line = line.split() return (split_line[4])
def main(): A = [12, 3, 5, 7, 4, 19, 26] order = int(raw_input("Enter Order :")) print RSelection(A, 0, len(A) - 1, order) quicksort.quick_sort(A, 0, len(A) - 1) print A print A[order + 1]
def quick_insert_sort(A, p, r): if p<r: q = parition(A, p, r) if q>k(): quick_sort(A, p, q-1) quick_sort(A, q+1, r) else: insertion_sort(A) return A
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())
def startAlgorithm(): global data disableWidgets() if algMenu.get()=='Bubble Sort': bubbleSort(data, drawData, speedScale.get()) elif algMenu.get() == 'Merge Sort': merge_sort(data, drawData, speedScale.get()) elif algMenu.get() == 'Quick Sort': quick_sort(data, 0, len(data)-1, drawData, speedScale.get()) drawData(data, ['green' for x in range(len(data))])
def test1(): data = [] for i in range(400000): data.append(i) start = time.time() quick_sort(data, 0, len(data) - 1) end = time.time() print("[TEST] 400000 (400K) integers \ n [TIME] " + str(end - start)) print("\n")
def StartAlgorithm(): #print("Starting Algorithm .....") global data if not data: return if (algoMenu.get() == "Quick Sort"): quick_sort(data, 0, len(data)-1, drawData, speedScale.get()) drawData(data, ['green' for x in range(len(data))]) elif (algoMenu.get() == 'Bubble Sort'): bubble_sort(data, drawData, speedScale.get())
def teste3(): lista = [] for i in range(40000000): lista.append(i) tempo = time.time() quick_sort(lista, 0, len(lista)-1) fim = time.time() print("[TESTE] 400000000 (40 milhoes) inteiros\n[TEMPO] "+ str(fim - tempo)) print("\n")
def startAlgo(): global list_numbers global selected_algo global speedscale global colorArray if selected_algo.get()==av_list[0]: bubble_sort(list_numbers,draw_in_canvas,float(speedscale.get()),colorArray) elif selected_algo.get()==av_list[1]: merge_sort(list_numbers,0, len(list_numbers)-1,draw_in_canvas,float(speedscale.get())) else: quick_sort(list_numbers,0,len(list_numbers)-1,draw_in_canvas,float(speedscale.get()))
def teste2(): lista = [] for i in range(400000): random_num = random.randint(0, 400000) lista.append(random_num) tempo = time.time() quick_sort(lista, 0, len(lista) - 1) fim = time.time() print("[TESTE] 400000 (400 mil) inteiros\n[TEMPO] " + str(fim - tempo)) print("\n")
def test1(): data = [] for i in range(40000): random_num = random.randint(0, 40000) data.append(random_num) start = time.time() quick_sort(data, 0, len(data) - 1) end = time.time() print("[TEST] 40,000 (40,000) integers \n [start] " + str(end - start)) print("\n")
def teste4(): lista = [] for i in range(40000000): aleatorio = random.randint(0, 40000000) lista.append(aleatorio) tempo = time.time() quick_sort(lista, 0, len(lista) - 1) fim = time.time() print("[TESTE] 40000000 (40 milhoes) inteiros\n[TEMPO] "+ str(fim - tempo)) print("\n")
def startalgorithm(): global data if n.get() == "Bubble Sort": bubblesort(data, speedy.get(), drawdata) if n.get() == "Selection Sort": selectionsort(data, speedy.get(), drawdata) if n.get() == "Insertion Sort": insertionsort(data, speedy.get(), drawdata) if n.get() == "Merge Sort": mergesort(data, speedy.get(), drawdata) if n.get() == "Quick Sort": quick_sort(data, drawdata, speedy.get())
def start_algo(): print("Starting Algorithm") global data ss = speedEntry.get() ss = float(ss) # ss = 0.1 if algMenu.get() == 'quick sort': quick_sort(data, 0, len(data) - 1, drawData, ss) elif algMenu.get() == 'Bubble sort': bubble_sort(data, drawData, ss) else: merge_sort(data, drawData, ss)
def test3(): data = [] for i in range(40000000): data.append(i) start = time.time() quick_sort(data, 0, len(data) - 1) end = time.time() print("[TEST] 400000000 (40 million) whole \ n [TIME] " + str(end - start)) print("\n")
def test_quick_sort_string(): """Test quick sort on a string.""" from quicksort import quick_sort test_list = ['Joe', 'Jared', 'Mike'] lo = 0 hi = len(test_list) - 1 assert quick_sort(test_list, lo, hi) == ['Jared', 'Joe', 'Mike']
def test_quick_sort(): """Test quick sort on random list.""" from quicksort import quick_sort test_list = [0, 5, 6, 2, 4] lo = 0 hi = len(test_list) - 1 assert quick_sort(test_list, lo, hi) == [0, 2, 4, 5, 6]
def test_quick_sort(self): self.assertRaises(TypeError, quick_sort, (1, 2, 3)) self.assertRaises(TypeError, quick_sort, 1) self.assertRaises(TypeError, quick_sort, 'helloworld!') random.shuffle(self.seq) self.seq = quick_sort(self.seq) self.assertEqual(self.seq, range(self.N))
def test_quick_sort_rand_list(): """test quick sort on random list.""" from quicksort import quick_sort import random x = random.sample(range(100), 10) k = quick_sort(x) x.sort() assert k == x
def combo_type(self, combo): if len(combo) == 1: return "Single" elif len(combo) == 2: if len({card.name for card in combo}) == 1: return "Pair" return False elif len(combo) == 3: if len({card.name for card in combo}) == 1: return "Triple" return False elif len(combo) == 5: quicksort.quick_sort(combo, 0, 4) if combo[0].name not in ("J", "Q", "K") and all( (card_x.rank - 1) % 13 == card_y.rank % 13 for card_x, card_y in zip(combo, combo[1:])) and all( card.suit == combo[0].suit for card in combo): return "Straight Flush" if combo[0].name not in ("J", "Q", "K") and all( (card_x.rank - 1) % 13 == card_y.rank % 13 for card_x, card_y in zip(combo, combo[1:])): return "Straight" if all(card.suit == combo[0].suit for card in combo): return "Flush" if len({card.name for card in combo}) == 2: if [card.name for card in combo].count(combo[0].name) == 2 or 3: return "Full House" else: return "Quad" return False else: return False
def calc_freq(L): ''' This function sorts the word list and increments the frequency of the words in the hashtable, creates a final unique word list and sorts it :param: We pass the hashtable through as an argument :precondition: The word_list and hashtable must exist with the respective words and values :postcondition: The hashtable now contains the words with their respective frequencies and the word_list is also sorted, and a new unique sorted list is created :return: Sorted word list and the hashtable :complexity: Best Case = Worst Case = O(n), where n is the length of the list ''' word_list, L = read_file(L) final_word_list = [] for word in word_list: L[word] += 1 if word not in final_word_list: final_word_list.append(word) quick_sort(final_word_list) return final_word_list, L
def start_algo(): global data if not data: return if algoMenu.get() == 'Quick Sort': quick_sort(data, 0, len(data) - 1, draw_Data, speedScale.get()) elif algoMenu.get() == 'Bubble sort': bubble_sort(data, draw_Data, speedScale.get()) elif algoMenu.get() == 'Merge Sort': merge_sort(data, draw_Data, speedScale.get()) elif algoMenu.get() == 'Insertion Sort': insertion_sort(data, draw_Data, speedScale.get()) elif algoMenu.get() == 'Heap Sort': heap_sort(data, draw_Data, speedScale.get()) draw_Data(data, ['green' for x in range(len(data))])
def startAlgorithm(): global data if not data: return if algMenu.get() == 'Quick Sort': quick_sort(data, 0, len(data) - 1, drawData, speedScale.get()) 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() == 'Selection Sort': selection_sort(data, drawData, speedScale.get()) elif algMenu.get() == 'Heap Sort': heap_sort(data, drawData, speedScale.get()) elif algMenu.get() == 'Insertion Sort': insertion_sort(data, drawData, speedScale.get()) elif algMenu.get() == 'Shell Sort': shell_sort(data, drawData, speedScale.get()) drawData(data, ['green' for x in range(len(data))])
def quick_vs_selec_vs_insr(): data = [] for i in range(40000): random_num = random.randint(0, 40000) data.append(random_num) start = time.time() quick_sort(data, 0, len(data) - 1) end = time.time() print("[QUICKSORT] 40000 (40K) integers random numbers \n [start] " + str(end - start)) print("\n") data = [] for i in range(40000): random_num = random.randint(0, 40000) data.append(random_num) start = time.time() selection_sort(data, len(data)) end = time.time() print("[SELECTIONSORT] 40000 (40 mil) integers random_nums\n[start] " + str(end - start)) print("\n") data = [] for i in range(40000): random_num = random.randint(0, 40000) data.append(random_num) start = time.time() insertion_sort(data, len(data)) end = time.time() print("[INSERTIONSORT] 40000 (40 mil) integers random numbers \n[start] " + str(end - start)) print("\n")
def quicksort_vs_mergesort(): lista = [] for i in range(4000000): aleatorio = random.randint(0, 4000000) lista.append(aleatorio) tempo = time.time() quick_sort(lista, 0, len(lista) - 1) fim = time.time() print("[QUICKSORT] 4000000 (4 milhoes) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo)) lista = [] for i in range(4000000): aleatorio = random.randint(0, 4000000) lista.append(aleatorio) tempo = time.time() merge_sort(lista) fim = time.time() print("[MERGESORT] 4000000 (4 milhoes) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo)) print("\n")
def quicksort_vs_bubble(): lista = [] for i in range(40000): aleatorio = random.randint(0, 40000) lista.append(aleatorio) tempo = time.time() quick_sort(lista, 0, len(lista) - 1) fim = time.time() print("[QUICKSORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo)) lista = [] for i in range(40000): aleatorio = random.randint(0, 40000) lista.append(aleatorio) tempo = time.time() bubble_sort(lista, len(lista)) fim = time.time() print("[BUBBLESORT] 40000 (40 mil) inteiros Aleatorios\n[TEMPO] "+ str(fim - tempo)) print("\n")
def sort(filename,month): """ Given a csv file of interest and a month, this ranks the neighborhoods based on their electricity and gas consumption. """ neighborhoods = determine_ranking(filename,month) l=[] for neighborhood in neighborhoods: for key in neighborhood.keys(): l.append(round(key,10)) sorted_values = quicksort.quick_sort(l,0,len(l)-1) rv = [] for value in sorted_values: for neighborhood in neighborhoods: for key in neighborhood.keys(): if value == round(key,10): rv.append(neighborhood[key]) return rv
def sort(filename, month): """ Given a csv file of interest and a month, this ranks the neighborhoods based on their electricity and gas consumption. """ neighborhoods = determine_ranking(filename, month) l = [] for neighborhood in neighborhoods: for key in neighborhood.keys(): l.append(round(key, 10)) sorted_values = quicksort.quick_sort(l, 0, len(l) - 1) rv = [] for value in sorted_values: for neighborhood in neighborhoods: for key in neighborhood.keys(): if value == round(key, 10): rv.append(neighborhood[key]) return rv
def sort_census(filename,month): """ Given a csv file of interest and a month, this ranks the neighborhoods based on their electricity and gas consumption using a quicksort algorithm. """ blocks = determine_census_ranking(filename,month) l=[] for key in blocks.keys(): l.append(round(key,10)) sorted_values = quicksort.quick_sort(l,0,len(l)-1) rv = [] for value in sorted_values: rv.append(blocks[value]) return rv
def main(): # a = [5,3,17,10,84,19,6,22,9] # a = [13,11,9,12,12,4,9,4,21,2,6,11] print("Quick-Insertion sort :", end=' ') a = rand(100000) # print_list(a) start = time.clock() a = quick_insert_sort(a, 0, len(a)-1) end = time.clock() # print_list(a) print(end - start) print("Quick sort :", end=' ') a = rand(100000) start = time.clock() a = quick_sort(a, 0, len(a)-1) end = time.clock() print(end - start) print("Insertion sort :", end=' ') a = rand(100000) start = time.clock() insertion_sort(a) end = time.clock() print(end - start)
from quicksort import quick_sort from version import Version import re T = int(raw_input()) versions = [] for x in xrange(0,T): version = raw_input() versions.append(Version.fromstring(version)) versions = quick_sort(versions) print 'Sorted Versions:' for x in versions: print x
def test_ordered(): ordered = [0,1,2,3,4,5,6,7,8,9] quick_sort(ordered) for index, number in enumerate(ordered): if index != 0: assert number >= ordered[index-1]
def test_empty(): newarray = [] quick_sort(newarray) assert len(newarray) == 0
def test_unordered(): unordered = [3,4,5,3,2,2,445,3,3,5,67,8,9,87,654,0,-50] quick_sort(unordered) for index, number in enumerate(unordered): if index != 0: assert number >= unordered[index-1]
def test_decending(): decending = [9,8,7,6,5,4,3,2,1] quick_sort(decending) for index, number in enumerate(decending): if index != 0: assert number >= decending[index-1]
output.append(item1) p1 += 1 elif item2 < item1: output.append(item2) p2 += 1 else: output.append(item1) p1 += 1 p2 += 1 if p1 == len(list1): output += list2[-(len(list2)-p2):] elif p2 == len(list2): output += list1[-(len(list1)-p2):] return output if __name__ == '__main__': # list1 = input('Enter first list of items: ').split(',') # list2 = input('Enter second list of items: ').split(',') list1 = ['apple','damson','pear','orange','banana','plumb','carrot'] list2 = ['cat','zebra','frog','dog','mouse'] list1 = quick_sort(list1, 0, len(list1)-1) list2 = quick_sort(list2, 0, len(list2)-1) print(merge_sort(list1, list2))
else: return binary_search(lst[:middle], key) if __name__ == "__main__": easy = [1,2,3,4,5,6,7,8] print easy for item in easy: print binary_search(easy, item) print print binary_search(easy, 0) print binary_search(easy, 100) print "\n----------------\n" even_length = [8,5,6,2,4,-10,3,100] even_length = quicksort.quick_sort(even_length) print even_length for item in even_length: print binary_search(even_length, item) print print binary_search(even_length, 0) print binary_search(even_length, 1000) print "\n----------------\n" odd_length = [2.3, 1.1, 6.5, 3.2, 9.9] odd_length = quicksort.quick_sort(odd_length) print odd_length for item in odd_length: print binary_search(odd_length, item) print