def test_quicksort(cases: int = 20): import test import sorts for i in range(cases): lst = test.random_array() # print('lst: ',lst) lstcopy = lst[:] sorts.quicksort(lstcopy, 0, len(lstcopy)) print('sorted lst: ', lstcopy) test.equal_list(lstcopy, sorted(lst)) print('{ message: no other things means everything is ok! }') lst = [2, 1, 2, 2, 2, 2, 2, 2, 2] sorts.quicksort(lst, 0, len(lst)) print('lst: ', lst)
def sort(self, var, loops): sort_algo = var.get() lst = [x + 1 for x in range(loops)] random.seed(time.time()) random.shuffle(lst) if sort_algo == "Insertion": A = sorts.insertionsort(lst) elif sort_algo == "Bubble": A = sorts.bubblesort(lst) elif sort_algo == "Merge": A = sorts.mergesort(lst, 0, loops - 1) elif sort_algo == "Quick": A = sorts.quicksort(lst, 0, loops - 1) elif sort_algo == "Selection": A = sorts.selectionsort(lst) title = sort_algo + " Sort" fig, ax = plt.subplots() ax.set_title(title) bar_rects = ax.bar(range(len(lst)), lst, align="edge") ax.set_xlim(0, len(lst)) ax.set_ylim(0, int(1.07 * max(lst))) text = ax.text(0.02, 0.95, "", transform=ax.transAxes) iteration = [0] def update_fig(lst, rects, iteration): for rect, val in zip(rects, lst): rect.set_height(val) iteration[0] += 1 text.set_text("# of operations: {}".format(iteration[0])) canvas = FigureCanvasTkAgg(fig, master=self) canvas.get_tk_widget().place(x=30, y=80) anim = animation.FuncAnimation(fig, func=update_fig, fargs=(bar_rects, iteration), frames=A, interval=1, repeat=False, blit=False) # return anim plt.show() """def reset():
return len(book_a['author_lower']) + len(book_a['title_lower']) > len( book_b['author_lower']) + len(book_b['title_lower']) # Comparison functions end bookshelf = utils.load_books('books_small.csv') bookshelf_v1 = bookshelf.copy() bookshelf_v2 = bookshelf.copy() long_bookshelf = utils.load_books('books_large.csv') sort_1 = sorts.bubble_sort(bookshelf, by_title_ascending) sort_2 = sorts.bubble_sort(bookshelf, by_author_ascending) # sort_3 = sorts.bubble_sort(long_bookshelf, by_total_length) ''' for book in sort_1: print(book['title']) for book in sort_2: print(book['author']) sorts.quicksort(bookshelf_v2, 0, len(bookshelf_v2) - 1, by_author_ascending) for book in bookshelf_v2: print(book['author']) ''' sorts.quicksort(long_bookshelf, 0, len(long_bookshelf) - 1, by_total_length) for book in long_bookshelf: print(len(book['author_lower']) + len(book['title_lower']))
def by_title_ascending(book_a, book_b): return book_a['title_lower'] > book_b['title_lower'] def by_author_ascending(book_a, book_b): return book_a['author_lower'] > book_b['author_lower'] def by_total_length(book_a, book_b): return len(book_a['author_lower']) + len(book_a['title_lower']) > len( book_b['author_lower']) + len(book_b['title_lower']) sort_1 = bubble_sort(bookshelf, by_title_ascending) for book in sort_1: print(book['title']) sort_2 = bubble_sort(bookshelf_v1, by_author_ascending) for book in sort_2: print(book['author']) quicksort(bookshelf_v2, 0, len(bookshelf_v2) - 1, by_author_ascending) book_2 = [book['author_lower'] for book in bookshelf_v2] print(book_2) # sort_3 = bubble_sort(long_bookshelf, by_total_length) quicksort(long_bookshelf, 0, len(long_bookshelf) - 1, by_total_length) book_3 = [book['author_lower'] for book in long_bookshelf] print(book_3)
#sort_1 = sorts.bubble_sort(bookshelf, by_title_ascending) # for book in sort_1: # print(book['title']) print( "\n-----------Start of Bubble Sort /w by_author_ascending on bookshelf_v1\n" ) sort_2 = sorts.bubble_sort(bookshelf_v1, by_author_ascending) # for book in sort_2: # print(book['author']) print( "\n-----------Start of Quick Sort /w by_author_ascending on bookshelf_v2\n" ) sorts.quicksort(bookshelf_v2, 0, len(bookshelf_v2) - 1, by_author_ascending) print("Quik sort: There were {0} swaps".format(sorts.quick_swaps)) # for book in bookshelf_v2: # print(book['author']) #### Sorts on long_bookshelf print( "\n-----------Start of Bubble Sort /w by_total_length on long_bookshelf\n") sorts.bubble_sort(long_bookshelf, by_total_length) print( "\n-----------Start of Quick Sort /w by_total_length on long_bookshelf_v1\n" ) sorts.quicksort(long_bookshelf_v1, 0, len(long_bookshelf_v1) - 1, by_total_length) print("Quik sort: There were {0} swaps".format(sorts.quick_swaps))
def test(nStart, nmax, gap): pmedia = 1 row = ['n', 'mergeTime', 'quickTime', 'heatTime'] with open('testInsert.csv', 'w') as csvFile: writer = csv.writer(csvFile) writer.writerow(row) csvFile.close() for n in range(nStart, nmax, gap): mergeTimes = np.arange(pmedia, dtype='f') heapTimes = np.arange(pmedia, dtype='f') quickTimes = np.arange(pmedia, dtype='f') for y in range(pmedia): B = np.arange(n) np.random.shuffle(B) A = sorts.heapArray(B) C = B.copy() startMerge = timer() sorts.mergesort(B, 0, n - 1) # passare lunghezza - 1 endMerge = timer() mergeTimes[y] = endMerge - startMerge startQuick = timer() sorts.quicksort(C, 0, n - 1) endQuick = timer() quickTimes[y] = endQuick - startQuick startHeap = timer() sorts.heapsort(A) endHeap = timer() heapTimes[y] = endHeap - startHeap mergeTime = np.mean(mergeTimes) quickTime = np.mean(quickTimes) heapTime = np.mean(heapTimes) dataCsv = [n, mergeTime, quickTime, heapTime] with open('testInsert.csv', 'a') as csvFile: writer = csv.writer(csvFile) writer.writerow(dataCsv) csvFile.close() data = np.loadtxt('testInsert.csv', delimiter=",", skiprows=1, usecols=[0, 1, 2, 3]) f = plt.figure(1) f.set_figheight(10) f.set_figwidth(10) plt.subplot(111) plt.plot(data[:, 0], data[:, 1], label='mergeTime') plt.plot(data[:, 0], data[:, 2], label='quickTime') plt.plot(data[:, 0], data[:, 3], label='heapTime') plt.xlabel('n') plt.ylabel('time(s)') plt.title("sort algorithms") plt.legend() plt.show()
while inicio <= fim: midrange = (inicio + fim) // 2 if x == vetor[midrange]: return print(midrange) if x < vetor[midrange]: fim = midrange - 1 else: inicio = midrange + 1 return -1 #não enncontrado #x = int(input("Valor que deseja encontrar no vetor")) vetor = random.sample(range(20000), 20000) #cria um vetor vetor2 = vetor.copy() #vetor_arrumado = bubble_sort(vetor) #chama o bubble sort #tam = len(vetor_arrumado) tama = len(vetor) #print(vetor) #bubble_sort(vetor2) #print(vetor) t1 = time.time() quicksort(vetor, 0, tama - 1) t2 = time.time() print('O algoritmo quicksort levou {} para organizar o vetor'.format(t2 - t1)) #binary_search2(vetor_arrumado, x, tam) #chama a função de busca binaria iterativa #binary_search(vetor_arrumado, 0, len(vetor_arrumado)-1, x)
for book in sort_1: print(book['title']) def by_author_ascending(book_a, book_b): return book_a['author_lower'] > book_b['author_lower'] bookshelf_v1 = bookshelf.copy() sort_2 = sorts.bubble_sort(bookshelf_v1, by_author_ascending) for book in sort_2: print(book['author']) #14.Within script.py create another copy of bookshelf as bookshelf_v2. bookshelf_v2 = bookshelf.copy() #15.Perform quicksort on bookshelf_v2 using by_author_ascending. This implementation operates on the input directly, so does not return a list. #Print the authors in bookshelf_v2 to ensure they are now sorted correctly. sorts.quicksort(bookshelf_v2, 0, len(bookshelf_v2) - 1, by_author_ascending) for book in bookshelf_v2: print(book['author']) def by_total_length(book_a, book_b): return len(book_a['author_lower']) + len(book_a['title_lower']) > len(book_b['author_lower']) + len(book_b['title_lower']) long_bookshelf = utils.load_books('books_large.csv') sort_3 = sorts.bubble_sort(long_bookshelf, by_total_length) for book in sort_3: print(book['author'])
print() def by_author_ascending(book_a, book_b): return book_a['author_lower'] > book_b['author_lower'] bookshelf_v1 = bookshelf[:] # or bookshelf_v1 = bookshelf.copy() sort2 = sorts.bubble_sort(bookshelf, by_author_ascending) for i in bookshelf: print(f'Title: {i["title"]}\nAuthor: {i["author"]}') bookshelf_v2 = bookshelf[:] sorts.quicksort(bookshelf_v2, by_author_ascending) print() for i in bookshelf: print(f'Title: {i["title"]}\nAuthor: {i["author"]}') def by_total_length(book_a, book_b): return (len(book_a['author']) + len(book_a['title'])) > ( len(book_b['author']) + len(book_b['title'])) long_bookshelf = utils.load_books('books_large.csv') print() sort3 = sorts.bubble_sort(bookshelf, by_total_length) for i in bookshelf:
if len_a > len_b: return True else: return False #testing algorithmen ordered_v1_bookshelf = sorts.bubble_sort(bookshelf, by_title_ascending) # for book in ordered_v1_bookshelf: # print(book["title"]) ordered_v2_bookshelf = sorts.bubble_sort(bookshelf, by_author_ascending) # for book in ordered_v2_bookshelf: # print(book["author"]) ordered_v3_bookshelf = bookshelf[:] sorts.quicksort(ordered_v3_bookshelf, 0, len(ordered_v3_bookshelf) - 1, by_author_ascending) # for book in ordered_v3_bookshelf: # print(book["author"]) ordered_v4_bookshelf = sorts.bubble_sort(long_bookshelf, by_total_length) # for book in ordered_v4_bookshelf: # print(book["author"] + " " + book["title"]) ordered_v5_bookshelf = long_bookshelf[:] sorts.quicksort(ordered_v5_bookshelf, 0, len(ordered_v5_bookshelf) - 1, by_total_length) for book in ordered_v5_bookshelf: print(book["author"] + " " + book["title"])
# hint #2: "Could a bit vector be useful?" (#111) # well ... the bits of each char a string would also map to unique bitstrings # the entire string itself would map to a unique bitstring # I don't see any performance improvement above O(n) though... # ------------------------------ # hint #3: "Could you solve it in O(n log n) time?" # "What might a solution look like?" (#132) # O(n log n) implies we are sorting the data using with QuickSort # (or a similar time-complexity sort algo) # A linear pass to check duplicates would add an additional O(n) algo # We have sort: some f1 that's O(N log N) and linear pass: f2 that's O(N), # Then sort + linear pass is O(max(f1, f2)) # = O(max(n, n log n)) # = O(n log n). # Implement sorts in sorts.py from sorts import quicksort print(s1) s1 = list(s1) s2 = list(s2) quicksort(s1, 0, len(s1) - 1) quicksort(s2, 0, len(s2) - 1)
def by_author_ascending(book_a, book_b): return book_a['author_lower'] > book_b['author_lower'] def by_total_length(book_a, book_b): return len(book_a['author_lower']) + len(book_a['title_lower']) > len( book_b['author_lower']) + len(book_b['title_lower']) sort_long = sorts.bubble_sort(long_bookshelf_v2, by_title_ascending) ''', number=5000) print(b) print('Quicksort') c = timeit(''' import utils import sorts from timeit import timeit bookshelf = utils.load_books('books_small.csv') bookshelf_v1 = bookshelf.copy() bookshelf_v2 = bookshelf.copy() long_bookshelf = utils.load_books('books_largs.csv') long_bookshelf_v1 = long_bookshelf.copy() for book in bookshelf: book['author_lower'] = book['author'].lower() book['title_lower'] = book['title'].lower() for book in long_bookshelf:
def by_title_ascending(book_a, book_b): return book_a['title_lower'] > book_b['title_lower'] def by_author_ascending(book_a, book_b): return book_a["author_lower"] > book_b["author_lower"] def by_total_length(book_a, book_b): return len(book_a["title_lower"]) + len(book_a["author_lower"]) > len( book_b["title_lower"]) + len(book_b["author_lower"]) sort_1 = bubble_sort(bookshelf, by_title_ascending) sort_2 = bubble_sort(bookshelf_copy_v1, by_author_ascending) quicksort(bookshelf_copy_v2, 0, len(bookshelf_copy_v2) - 1, by_author_ascending) sort_4 = bubble_sort(bookshelf, by_total_length) quicksort(bookshelf_copy_v3, 0, len(bookshelf_copy_v3) - 1, by_total_length) print("\nBubble Sort - by_title_ascending") for book in sort_1: print(book['title_lower']) print("\nBubble Sort - by_author_ascending") for book in sort_2: print(book['author_lower']) print("\nQuick Sort - by_author_ascending") for book in bookshelf_copy_v2: print(book['author_lower'])
return True else: False def by_total_length(book_a, book_b): return len(book_a['title_lower']) + len(book_a['author_lower']) > len( book_b['author_lower']) + len(book_b['title_lower']) bookshelf = utils.load_books('books_small.csv') long_bookshelf = utils.load_books('books_large.csv') bookshelf_v1 = bookshelf.copy() bookshelf_v2 = bookshelf.copy() sort_1 = sorts.bubble_sort(bookshelf, by_title_ascending) sort_2 = sorts.bubble_sort(bookshelf_v1, by_author_ascending) sorts.quicksort(bookshelf_v2, 0, len(bookshelf_v2) - 1, by_total_length) sorts.quicksort(long_bookshelf, 0, len(long_bookshelf) - 1, by_title_ascending) # for book in sort_1: # print(book['title']) # for book in sort_2: # print(book['title']) for book in long_bookshelf: print(book['title']) # print(ord("a")) # print(ord(" ")) # print(ord("A"))
print(book['title']) # Author comparison function: def by_author_ascending(book_a, book_b): return book_a['author_lower'] > book_b['author_lower'] bubble_sorted_by_author = sorts.bubble_sort(bookshelf_copy_one, by_author_ascending) print() for book in bubble_sorted_by_author: print(f"{book['title']} by {book['author']}") sorts.quicksort(bookshelf_copy_two, 0, len(bookshelf_copy_two) - 1, by_author_ascending) print() for book in bookshelf_copy_two: print(f"{book['title']} by {book['author']}") # Length comparison function: def by_total_length(book_a, book_b): return len(book_a["title"]) + len(book_a["author"]) > len( book_b["title"]) + len(book_b["author"]) long_bookshelf = utils.load_books(book_large__csv_path) # bubble_sorted_by_length= sorts.bubble_sort(long_bookshelf, by_total_length)