def binary_search_array(curr_arr, value, full_arr): ''' :param value: Query value :param curr_arr: Input Array that is assumed to be unsorted :return: Sorted array and Index of value within array(Index will be based on SORTED output array) ''' # Exit if array is empty if len(curr_arr) == 0: print("Value not in list") return None # Heap sort input array heap_sort(curr_arr) # Size and Middle value size = len(curr_arr) middle = size // 2 if curr_arr[middle] == value: print("Found value at index :", full_arr.index(value)) return middle # Recursively search right or left children until either value is found or list is empty if value < curr_arr[middle]: binary_search_array(curr_arr[:middle], value, full_arr) elif value > curr_arr[middle]: binary_search_array(curr_arr[middle + 1:], value, full_arr)
def array_to_binarytree(self, arr): ''' Use to converted array to Binary Search Tree. :param arr: Array of integer elements to pass in :return: Node and all right and left (sub)trees ''' # Append only when there is a value assigned and within index of the array if len(arr) == 0: return None # Heap sort input array heap_sort(arr) # Size, Middle value, and appropriate nodes from current input array size = len(arr) middle = size // 2 new_node = Node(arr[middle]) # Recursively call to append all Left and Right (sub) children new_node.left = self.array_to_binarytree(arr[:middle]) new_node.right = self.array_to_binarytree(arr[middle + 1:]) # Set the tree's root to arr[middle] # Return the current node and it's children self.root = new_node return new_node
def approach_naive(num): container.append(num) heap_sort(container) n = len(container) if n % 2 == 0: print((container[n // 2] + container[n // 2 - 1]) / 2) else: print(container[math.floor(n / 2)])
def test_heap_sort(): for i in range(500): array = [] for j in range(i): array.append(random.randrange(-i, i, 1)) temp = array.copy() temp.sort() heap_sort(array) assert array == temp
def test_cases(): # Random Arrays to test rand_arr1 = np.random.randint(256, size=8) rand_arr2 = np.random.randint(256, size=8) # Given Test Cases sorted_arr = [0, 1, 2, 3, 4, 5, 7, 9, 10, 12, 14, 18, 20] unsorted_arr = [3, 0, 1, 10, 18, 4, 7, 20, 15, 9, 2, 12, 14, 5] print(heap_sort(sorted_arr)) binary_search_array(sorted_arr, 188, sorted_arr) binary_search_array(sorted_arr, 188, sorted_arr) print(heap_sort(unsorted_arr)) binary_search_array(unsorted_arr, 4, unsorted_arr)
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_heap_sort(self): """ Test that it can sort a list of numbers with the heap algorithm. """ data = [4, 78, 2, 33, 0, 99, 86, 4, 21, 3] expected = [0, 2, 3, 4, 4, 21, 33, 78, 86, 99] output = heap_sort(data) self.assertEqual(output, expected)
def main(): print "MAIN:" print "*"*40 print_menu() print "*"*40 input_list = [] try: f = open(sys.argv[1], 'r') n = int(f.readline()) for i in range(n): input_list.append(int(f.readline().strip('\n'))) print "IP", input_list except: print "Error : Opening file" print "Exiting the program" sys.exit() try: option = int(raw_input("Select an option : ")) except ValueError: print "Error in selecting the option" if int(option) in [ i+1 for i in range(len(SORTING_LIST)) ]: print "OPTION", option print "SYS", sys.argv if option == 1: print "Bubble Sort" print bubble_sort(input_list) print "DDD", input_list elif option == 4: print "HEAP" print heap_sort(input_list) print input_list from heap_class import MyHeap h = MyHeap() for i in input_list: h.push(i) print h.max_element() h.push(34) h.push(134) h.push(2) print h.max_element() h.extract_max_element() print h.max_element()
def search_heuristic(init_state, set_of_operation): open_list = [] relation = {} open_list.append(init_state) while 1: if open_list == []: # 判断open表是否为空 print("失败!open表为空,不存在可用节点,无解。") return vertex = open_list[0] open_list = open_list[1:-1] # 更新open表 if vertex == [0, 0, 1]: result = [] # 存储整个路径 result.append(vertex) res = [] # 存储路径中的单个节点 print("渡河成功!路径为:") while res != init_state: res = relation[str(result[-1])] if res: result.append(res) else: break for i in result[::-1]: if i != result[0]: print(i, '->', end='') else: print(i) return else: if vertex != init_state: sons = whether_expandable(vertex, set_of_operation, relation[str(vertex)]) else: sons = whether_expandable(vertex, set_of_operation, [0, 0, 0]) if sons: # 判断当前节点是否可扩展 sort_list = [] for i in sons: relation[str(i)] = vertex # 用字典存储节点间的亲属关系,子节点为键,父节点为值 i.append(get_d(i, init_state, relation) + get_w(i)) # 使用启发函数对生成的子节点进行标注,并将标注的权值加到子节点列表内 sort_list.append(i) heap_sort(sort_list) for i in sort_list: i = i[:-1] open_list.append(i)
def test_heap_sort_3(self): lst = [ 84, 69, 61, 63, 48, 23, 51, 44, 52, 37, 23, 7, 5, 24, 18, 32, 8, 17, 48, 36 ] exp = [ 5, 7, 8, 17, 18, 23, 23, 24, 32, 36, 37, 44, 48, 48, 51, 52, 61, 63, 69, 84 ] self.assertEqual(heap_sort.heap_sort(lst), exp)
def merge_sort_composite(arr, left, right): if right - left <= 1: return if right - left <= 1024: arr[left:right] = heap_sort(arr[left:right]) return center = left + (right - left) // 2 merge_sort_composite(arr, left, center) merge_sort_composite(arr, center, right) merge(arr, left, center, right)
def test_heap_sort_4(self): lst = [ 216, 435, 238, 766, 116, 225, 243, 637, 479, 983, 851, 846, 906, 629, 120, 960, 573, 381, 361, 949, 599, 168, 997, 487, 669, 565, 667, 635, 27, 269, 642, 81, 14, 988, 108, 418, 625, 821, 166, 592, 530, 686, 850, 664, 719, 465, 236, 709, 510, 449, 971, 664, 994, 670, 410, 550, 501, 61, 37, 810, 332, 324, 39, 30, 485, 318, 611, 546, 398, 852, 71, 904, 887, 540, 402, 985, 265, 859, 76, 265, 772, 592, 819, 859, 359, 140, 990, 217, 850, 11, 198, 807, 780, 488, 410, 328, 521, 697, 364, 778 ] self.assertEqual(heap_sort.heap_sort(lst), sorted(lst))
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 tester(): fle = open("test_results", 'w') for i in range(20): testing_lst = [ randrange( 1, (100) - 1) for x in range( randrange( 1, 200000))] res = heap_sort(testing_lst) other_res = sorted(testing_lst) if res != other_res: # fle.write(str(testing_lst)) # fle.write('\n') print(testing_lst) fle.close()
def merge_sort_composite_out(file, left, right): if right - left <= 1: return if right - left <= 1024: arr = [] with open(file, 'r+b') as f: f.seek(left, 0) for i in range(right - left): num = f.read(2) arr.append(num) arr = heap_sort(arr) with open(file, 'r+b') as f: f.seek(left, 0) for i in range(right - left): f.write(arr[i]) return center = left + (right - left) // 2 merge_sort_composite_out(file, left, center) merge_sort_composite_out(file, center, right) merge_out(file, left, center, right)
def sort1(source): return heap_sort(source)
def test_sorted(self): self.assertEqual(heap_sort([2, 4, 7]), [2, 4, 7])
def gen_a_big_list(): alist = [randint(0, 1000) for x in range(0, 10000)] return alist if __name__ == '__main__': iList = gen_a_big_list() #start = time.time() quick_sort(iList) #end = time.time() #print("Quick Sort Calculation time: {}".format(end-start)) #start = time.time() merge_sort(iList) #end = time.time() #print("Merge Sort Calculation time: {}".format(end-start)) #start = time.time() heap_sort(iList) #end = time.time() #print("Heap Sort Calculation time: {}".format(end-start))
def test_heap_sort_2(self): self.case_name = inspect.currentframe().f_code.co_name lst = create_random_int_list(10000, 10) exp = sorted(lst) self.assertEqual(heap_sort.heap_sort(lst), exp)
def test_heap_sort_sorted(self): self.assertTrue(is_sorted(heap_sort(create_sorted(10000))))
from heap_sort import heap_sort import sys import timeit def load_file(f): file_reader = open(f, 'r') s = file_reader.readline() str_array = s.split() return list(map(int, str_array)) if __name__ == "__main__": print_nums = False if len(sys.argv) > 1: if sys.argv[1] == "--print": print_nums = True ip_list = load_file("random_files/test-file1000000.txt") n = len(ip_list) print("Length of list: " + str(n)) if print_nums: print("List before sorting: " + str(ip_list)) start = timeit.default_timer() heap_sort(ip_list) stop = timeit.default_timer() if print_nums: print("List after sorting: " + str(ip_list)) print("Runtime: " + str(stop - start))
from bubble_sort import bubble_sort from heap_sort import heap_sort from insertion_sort import insertion_sort if __name__ == '__main__': arr = [3, 5, 2, 4, 1, 6] arr_for_ss = copy.deepcopy(arr) selection_sort(arr_for_ss) print(f'selection_sort: {arr_for_ss}') arr_for_qs = copy.deepcopy(arr) arr_for_qs = quick_sort(arr_for_qs) print(f'quick_sort : {arr_for_qs}') arr_for_ms = copy.deepcopy(arr) arr_for_ms = merge_sort(arr_for_ms) print(f'merge_sort : {arr_for_ms}') arr_for_bs = copy.deepcopy(arr) arr_for_bs = bubble_sort(arr_for_bs) print(f'bubble_sort : {arr_for_bs}') arr_for_hs = copy.deepcopy(arr) arr_for_hs = heap_sort(arr_for_hs) print(f'heap_sort : {arr_for_hs}') arr_for_is = copy.deepcopy(arr) arr_for_is = insertion_sort(arr_for_is) print(f'insertion_sort: {arr_for_is}')
def test_unsorted(self): self.assertEqual(heap_sort([8, 4, 5, 1, 6]), [1, 4, 5, 6, 8])
bars = None generator = None B = [0 for x in range(N)] if algo == 'quick': generator = quicksort(A, 0, len(A) - 1) bars = ax.bar(range(len(A)), A, align='edge', color='red') elif algo == 'randomized_quick': generator = randomized_quicksort(A, 0, len(A) - 1) bars = ax.bar(range(len(A)), A, align='edge', color='orange') elif algo == 'merge': generator = merge_sort(A, 0, len(A) - 1) bars = ax.bar(range(len(A)), A, align='edge', color='magenta') elif algo == 'heap': generator = heap_sort(A) bars = ax.bar(range(len(A)), A, align='edge', color='yellow') elif algo == 'bubble': generator = bubble_sort(A) bars = ax.bar(range(len(A)), A, align='edge', color='cyan') elif algo == 'insertion': generator = insertion(A) bars = ax.bar(range(len(A)), A, align='edge', color='black') elif algo == 'bucket': generator = bucket_sort(A) bars = ax.bar(range(len(A)), A, align='edge', color='brown') elif algo == 'counting': generator = counting_sort(A, B, N + 1) bars = ax.bar(range(len(B)), B, align='edge', color='grey') title = algo.replace('_', ' ').title()
def test_unsorted_with_duplication(self): self.assertEqual(heap_sort([7, 1, 3, 3, 8, 3, 4, 1]), [1, 1, 3, 3, 3, 4, 7, 8])
def handle_updates(updates): # andando no json para para chegar no text enviado for update in updates["result"]: if 'message' in update: message = update['message'] elif 'edited_message' in update: message = update['edited_message'] else: print('Can\'t process! {}'.format(update)) # pega o valor da mensagem mandada para o bot e a quebra return command = message["text"].split(" ", 1)[0] print(command) msg = '' chat = message["chat"]["id"] if len(message["text"].split(" ", 1)) > 1 and len( message["text"].split(" ")) == 3: try: msg = message["text"].split(" ", 1)[1].strip() positions = msg.split(" ")[0].strip() number = msg.split(" ")[1].strip() except: return send_message( 'Somente um argumento foi passado para o calculo da busca', chat) elif (len(message["text"].split(" ")) == 2): msg = message["text"].split(" ", 1)[1].strip() print(msg) if command == '/Buscas': send_message( "*-------> Busca Sequencial Simples(BSS)*\n*-------> Busca Sequencial Com Sentinela(BSCS)*\n*-------> Busca Sequencial Indexada(BSI)*\n*-------> Busca Binária(BB)*\n*-------> Busca Por Salto(BPS)**\n*-------> Busca Por Interpolaçao(BPS)*", chat) send_message( " Digite '/' a sigla entre parentêses da busca \n ex:*/BSS* (Busca Sequencial Simples)", chat) send_message( " Caso queira comparar uma busca com a outra basta inserir um @ entre as buscas,por exemplo", chat) elif command == '/BSS': search(simple_sequence_search, positions, number, 'Busca Sequencial Simples', chat) # print('telegram') elif command == '/BSCS': try: search(sentry_sequence_search, positions, number, 'Busca Sequencial Com Sentinela', chat) except: send_message('argumentos inválidos', chat) elif command == '/BB': try: search(binary_search, positions, number, 'Busca Binária', chat) except: send_message('argumentos inválidos', chat) elif command == '/BPS': try: search(jump_search, positions, number, 'Busca por Salto', chat) except: send_message('argumentos inválidos', chat) elif command == '/BPI': try: search(interpolation_search, positions, number, 'Busca por Interpolação', chat) except: send_message('argumentos inválidos', chat) elif command == '/BSS@BSCS' or command == '/BSCS@BSS': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) elif command == '/BSS@BB' or command == '/BB@BSS': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/BSS@BPI' or command == '/BPI@BSS': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/BSS@BPS' or command == '/BPS@BSS': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = search(list_identify[0], positions, number, list_names[0], chat) second_time = search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/BSCS@BB' or command == '/BB@BSCS': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/BSCS@BPS' or command == '/BPS@BSCS': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/BSCS@BPI' or command == '/BPI@BSCS': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/BB@BPI' or command == '/BPI@BB': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/BB@BPS' or command == '/BPS@BB': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/BPS@BPI' or command == '/BPI@BPS': try: b = command b_n = b.replace("@", " ") b_new = b_n.replace("/", " ") search_list = b_new.split() list_names = print_search(search_list) list_identify = identify(search_list) first_time = compare_search(list_identify[0], positions, number, list_names[0], chat) second_time = compare_search(list_identify[1], positions, number, list_names[1], chat) compare_graph(first_time, second_time) bot.send_photo(chat_id=chat, photo=open('./compare_methods.png', 'rb')) if first_time > second_time: eficiencia = (first_time / second_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[1], int(eficiencia), list_names[0]), chat) elif first_time < second_time: eficiencia = (second_time / first_time) send_message( 'A {} foi {} vezes mais rápida que a {}'.format( list_names[0], int(eficiencia), list_names[1]), chat) except: return send_message( 'OPS.... algum argumento foi passado errado,tente novamente', chat) # print("passa") elif command == '/SS': shell_sort_gif = 'https://media.giphy.com/media/UtQLqAMr6K7052rPxS/giphy.gif' send_message( 'Criado por Donald Shell em 1959, o método ShellSort é considerado um refinamento do método Insertion Sort.', chat) send_message( 'Ao invés de considerar o vetor a ser ordenado como um único segmento, ele divide o vetor em sub-grupos.', chat) send_message( 'Geralmente divide-se o tamanho do vetor ao meio e guarda o valor em uma variável h os grupos vão sendo ordenados, decrementando o valor de h até que os saltos sejam de elemento em elemento', chat) send_message('O gif a seguir ilustra bem o ShellSort', chat) sendGif(chat, shell_sort_gif) vector = fill_vector_disorder(int(msg)) before = time.time() shell_sort(vector) after = time.time() total = (after - before) * 1000 return send_message( "O tempo gasto para ordenar o vetor foi: {:6f} mili-segundos". format(total), chat) elif command == '/QS': quick_sort_gif = 'https://media.giphy.com/media/m9R2QuROJ1RkToo6P7/giphy.gif' send_message( 'O QuickSort é um algoritmo que aplica o conceito de dividir e conquistar.', chat) send_message( 'Para particionar um vetor, escolhe-se um elemento pivô e move-se todos os valores menores para a esquerda e os maiores para a direita', chat) send_message( 'Ordena-se recursivamente os valores menores e os maiores,O gif a seguir ilustra bem o QuickSort', chat) sendGif(chat, quick_sort_gif) vector = fill_vector_disorder(int(msg)) before = time.time() quicksort(vector) after = time.time() total = (after - before) * 1000 return send_message( "O tempo gasto para ordenar o vetor foi: {:6f} mili-segundos". format(total), chat) elif command == '/BS': insertion_sort_gif = 'https://media.giphy.com/media/lT4aB9tDZU4jkoVXiZ/giphy.gif' send_message( 'O BucketSort é um algoritmo que aplica o conceito de dividir e conquistar.', chat) send_message( 'Vamos particionar o vetor em um número finitos de baldes. Cada balde é ordenado individualmente, por diferentes algoritmos ou usando o bucket sort recursivamente', chat) bot.send_photo(chat_id=chat, photo=open('../bucket.png', 'rb')) send_message( 'É eficiente em dados cujos valores são limitados. Na nossa implementação cada balde foi ordenado usando o método insertion sort. Relembre através desse gif:', chat) sendGif(chat, insertion_sort_gif) vector = fill_vector_disorder(int(msg)) before = time.time() bucket_sort(vector) after = time.time() total = (after - before) * 1000 return send_message( "O tempo gasto para ordenar o vetor foi: {:6f} mili-segundos". format(total), chat) elif command == '/HS': send_message( 'Heap Sort é um algoritmo de ordenação popular e eficiente em programação de computadores. Aprender a escrever o ', chat) time.sleep(3) send_message( 'algoritmo de classificação de pilha requer conhecimento de dois tipos de estruturas de dados - arrays e árvores.', chat) time.sleep(3) send_message( 'Seu funcionamento é fundamentado na visualização dos elementos do array em uma forma especial,chamada heap.', chat) time.sleep(3) send_message('Entendendo uma árvore binária', chat) time.sleep(3) send_message( 'Uma árvore binária é uma estrutura de dados em que cada pai (um nó da árvore) pode ter no máximo dois filhos. ', chat) time.sleep(4) send_message('Na imagem, cada elemento possui 2 filhos ', chat) time.sleep(3) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_1.jpg', 'rb')) time.sleep(2) send_message('Árvore binária cheia', chat) time.sleep(2) send_message( 'Uma árvore binária cheia (full binary tree) é um tipo especial de árvore binária,em que todos os pais tem dois filhos ou nenhum.', chat) time.sleep(2) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_2.jpg', 'rb')) time.sleep(2) send_message('Árvore binária completa', chat) time.sleep(1) send_message( 'Uma árvore binária completa (Complete binary tree) é como uma árvore binária cheia,mas com duas grandes diferenças:', chat) time.sleep(4) send_message( '1. Cada nível deve ser completamente preenchido \n 2. Todos os elementos da folha devem inclinar-se para a esquerda.\n 3. O último elemento de folha não pode ter um certo irmão, isto é, uma árvore binária completa não precisa ser uma árvore binária cheia.', chat) time.sleep(4) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_3.jpg', 'rb')) send_message( 'Como criar uma árvore binária completa de uma lista não-ordenada (array)?', chat) time.sleep(3) send_message( '1.Selecione o primeiro elemento da lista para ser o nó raiz. (Primeiro nível - 1 elemento)', chat) time.sleep(3) send_message( '2.Coloque o segundo elemento como um filho à esquerda do nó raiz e o terceiro elemento como um filho a direita,2.Coloque o segundo elemento como um filho à esquerda do nó raiz e o terceiro elemento como um filho a direita.', chat) time.sleep(3) send_message( '3. Colocar em seguida dois elementos como filhos do nó esquerdo do segundo nível. Mais uma vez,colocar os dois próximos elementos como filhos do nó direito do segundo nível (nível 3 - 4 elementos).', chat) time.sleep(3) send_message('4. Continue repetindo até chegar o último elemento.', chat) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_4.jpg', 'rb')) time.sleep(2) send_message( 'Relação entre índices do array e elementos da árvore', chat) time.sleep(3) send_message( 'Relação entre índices do array e elementos da árvore', chat) time.sleep(3) send_message( 'Árvore binária completa tem uma propriedade interessante que podemos usar para encontrar os filhos e os pais de qualquer nó.', chat) time.sleep(3) send_message( 'Se o índice de qualquer elemento do array é i, o elemento do índice 2i + 1 vai se tornar a criança esquerda ' 'enquanto que o elemento do índice a direita se dará por 2i + 2. Além disso, o pai de qualquer elemento no ' 'índice é dada pelo limite inferior de (i-1) / 2.', chat) time.sleep(5) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_5.jpg', 'rb')) time.sleep(3) send_message('A estrutura do heap', chat) time.sleep(3) send_message( 'Heap é uma estrutura de dados baseados em árvores especiais. Uma árvore binária é dito a seguir ' 'uma estrutura de dados heap se:', chat) time.sleep(5) send_message('Deve ser uma árvore binária completa.', chat) send_message( 'Todos os nós na árvore seguem a propriedade que eles são superiores a seus filhos, ou seja, ' 'o elemento maior é a raiz e ambos os seus filhos assumem lugar de nós, ligados a elementos menores que a raiz ' 'e assim por diante. Esse processo é um heap chamado max-heap. Se em vez disso, todos os nós são menores do que ' 'seus filhos, é chamado de min-heap.', chat) time.sleep(5) send_message( 'A imagem a seguir mostra bem o max-heap e o min-heap', chat) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_6.jpg', 'rb')) time.sleep(3) send_message('Como fazer o processo de heapify', chat) send_message( 'A partir de uma árvore binária completa, nós podemos modificá-lo para se tornar um Max-Heap, executando uma ' 'função chamada heapify sobre todos os elementos não-folha do heap.', chat) time.sleep(5) send_message( 'Na imagem executamos o heapify em uma árvore com apenas três elementos.', chat) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_7.jpg', 'rb')) time.sleep(3) send_message( 'O exemplo acima mostra dois cenários - um em que a raiz é o elemento maior e não precisamos fazer nada.' 'E outra na qual raiz tinha o maior elemento como um filho e precisava trocar para manter a propriedade de ' 'max-heap.', chat) time.sleep(5) send_message( 'Agora vamos pensar em outro cenário a partir da imagem a seguir', chat) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_8.jpg', 'rb')) time.sleep(3) send_message( 'O elemento superior não é um max-heap, mas todas as sub-árvores são max-heaps.', chat) send_message( 'Para manter a propriedade de max-heap para a árvore inteira, temos que continuar puxando 2 posições para ' 'baixo até que ele atinja sua posição correta.', chat) time.sleep(4) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_9.jpg', 'rb')) time.sleep(3) send_message( 'Assim, para manter a propriedade de max-heap em uma árvore, onde ambas as sub-árvores são max-heaps, ' 'precisamos executar o heapify no elemento raiz, repetidamente, até que o mesmo seja maior do que seus ' 'filhos ou se torne um nó folha.', chat) time.sleep(6) send_message('Construindo o max-heap', chat) send_message( 'Para construir um max-heap de qualquer árvore, podemos começar aplicar o processo de heapify para cada ' 'sub-árvore de baixo a cima e finalizar com um max-heap depois que a função é aplicada em todos os elementos, ' 'incluindo o elemento raiz.', chat) time.sleep(6) send_message( 'No caso de uma árvore completa, o primeiro índice do nó não-folha é dada por n/2 - 1.' ' Todos os outros nós depois que são nós de folha não precisam passar pelo heapify.', chat) time.sleep(3) send_message( 'A imagem a seguir representa a construção do max-heap', chat) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_10.jpg', 'rb')) time.sleep(3) send_message( 'Como mostra no diagrama acima, começamos por heapifying as árvores das menores para os mais baixas e ' 'mover-las gradualmente até chegarmos ao elemento raiz.', chat) send_message('Enfim, o heap sort', chat) send_message('Etapas para execução do heap sort:', chat) send_message( '1. Desde que a árvore satisfaça a propriedade de Max-Heap, então, o maior item é armazenado no nó raiz.', chat) send_message( '2. Remover o elemento raiz e colocar no final do array (n-ésima posição. Colocar o último item da árvore (heap) ' 'no lugar vago.', chat) send_message( '3. Reduzir o tamanho do heap por 1 e aplicar o heapify no elemento raiz novamente para que possamos ter ' 'o maior elemento como raiz.', chat) send_message( '4. O processo é repetido até que todos os itens da lista é classificada.', chat) bot.send_photo(chat_id=chat, photo=open('../imagens/imagem_11.jpg', 'rb')) send_message( 'Depois dessa explicação,executaremos o HeapSort para você ver o tempo que demora para a ordenação por completa do vetor', chat) arr = fill_vector_disorder(int(msg)) before = time.time() heap_sort(arr) after = time.time() total = (after - before) * 1000 # Segundos multiplicados em 10000 return send_message( "O tempo gasto para ordenar o vetor foi: {:6f} mili-segundos". format(total), chat)
def test_heap_sort_1(self): lst = [21, 15, 10, 8, 5] exp = [5, 8, 10, 15, 21] self.assertEqual(heap_sort.heap_sort(lst), exp)
def test_heap_sort_6(self): lst = create_random_int_list(1000, 10) self.assertEqual(heap_sort.heap_sort(lst), sorted(lst))
def test_one(self): self.assertEqual(heap_sort([1]), [1])
def test_can_it_work(self): self.test_array = range(0,11,1) sorted_array = heap_sort.heap_sort(self.test_array) self.assertEqual(sorted_array,range(10,-1,-1))
def test_heap_sort_correctly_sorts(self): sorted_values = heap_sort(self.unsorted_values) self.assertEqual(sorted(self.unsorted_values), sorted_values)
def test_heap_sort_should_sort_a_list(self): self.assertEqual([1, 2, 3, 4, 5], heap_sort([4, 2, 3, 5, 1]))
def test_heap_sort_does_not_mutate_input(self): values = list(self.unsorted_values) sorted_values = heap_sort(self.unsorted_values) self.assertEqual(self.unsorted_values, values)
print('Bubble Sort: ' + str(bubble_sort(lst))) lst = generate_random_list(100) print('Selection Sort: ' + str(selection_sort(lst))) lst = generate_random_list(100) print('Insertion Sort: ' + str(insertion_sort(lst))) lst = generate_random_list(100) print('Merge Sort: ' + str(merge_sort(lst))) lst = generate_random_list(100) print('Quick Sort: ' + str(quick_sort(lst))) lst = generate_random_list(100) print('Heap Sort: ' + str(heap_sort(lst))) lst = generate_random_list(100) print('Counting Sort: ' + str(counting_sort(lst))) lst = generate_random_list(100) print('Radix Sort: ' + str(radix_sort(lst)))
1.冒泡排序 2.快速排序 3.插入排序 4.选择排序 5.堆排序 6.归并排序 ''') sel = input() start = time.time() #计算运行时间 if (sel == '1'): print(bubble_sort.bubble_sort(listin)) elif (sel == '2'): deallist = listin[:] quick_sort.quick_sort(deallist, 0, len(deallist) - 1) print(deallist) elif (sel == '3'): print(insertion_sort.insertion_sort(listin)) elif (sel == '4'): print(selection_sort.selection_sort(listin)) elif (sel == '5'): print(heap_sort.heap_sort(listin)) elif (sel == '6'): deallist = listin[:] print(merge_sort.merge_sort(deallist)) else: raise ValueError end = time.time() print('程序运行时间:%f ns' % ((end - start) * 1000000)) print('输入Q/q退出,或继续尝试其他算法') if input().lower() == 'q': exit(0) except ValueError: print('请输入正确的值!')
def test_heap_sort(self): result = heap_sort(self.arr) self.assertEqual(result, self.answer)
def test_heap_sort_returns_an_array(self): sorted_values = heap_sort(self.unsorted_values) assert isinstance(sorted_values, list)
def test_heap_sort_for_a_huge_input(self): expected = self.test_kit.huge_set_of_n() input_nums = self.test_kit.huge_sample_of_n() actual = heap_sort(input_nums) self.assertListEqual(expected, actual)
def test_reverse_order(self): items = [9, 8, 7, 6, 5, 4, 3, 2, 1] sorted_items = [1, 2, 3, 4, 5, 6, 7, 8, 9] self.assertEqual(sorted_items, heap_sort(items))
def test_heap_sort(self): self.assertEqual(heap_sort.heap_sort(self._arr), self._res)
def test_heap_sort_2(self): lst = [8, 5, 4, 3, 2, 3, 0, 1, 3, 2] exp = [0, 1, 2, 2, 3, 3, 3, 4, 5, 8] self.assertEqual(heap_sort.heap_sort(lst), exp)