diff --git a/lukovnikovde/428.md b/lukovnikovde/428.md new file mode 100644 index 0000000..e69de29 diff --git a/lukovnikovde/docs/data/1-st-exercise/DataStructure.py b/lukovnikovde/docs/data/1-st-exercise/DataStructure.py new file mode 100644 index 0000000..f84bcff --- /dev/null +++ b/lukovnikovde/docs/data/1-st-exercise/DataStructure.py @@ -0,0 +1,507 @@ +import random as rnd +import time +import csv +import matplotlib.pyplot as plt +############################################################################################# + +def sort_list(name_list): + l = len(name_list) + for i in range(l - 1): + for j in range(l - i - 1): + if name_list[j][0] > name_list[j + 1][0]: + name_list[j], name_list[j + 1] = name_list[j + 1], name_list[j] + return name_list + +def hash_key(name): + h_key = sum(ord(ch) for ch in name) + return h_key + +def create_name_phone(i): + name = f"User_{i:03d}" + phone = f"{rnd.randint(100, 999)}-{rnd.randint(100, 999)}" + return (name, phone) + +def file_insert(results): + with open("results.csv", "w", encoding = "utf-8-sig", newline = "") as file: + writer = csv.writer(file) + writer.writerows(results) + +def drow(time, color_fun, j, text, axes): + + operation = [0, 1, 2, 3] + x = [j + operation[i] for i in range(4)] + y = [] + for key in time: + y.append(time[key] * 1000) + for i in range(4): + axes[i].bar(x[i], y[i], width = 0.12, color = color_fun, label = text) + axes[i].set_ylabel("Время, мс") + axes[i].set_xticks([]) + #plt.bar(x, y, width = 0.12, color = color_fun, label = text) + + + +########################################################################################################################### + +def ll_insert(head, name, phone): + next_node = {'name': name, 'phone': phone, 'next': None} + if head is None: return next_node + + running = head + while running is not None: + if running['name'] == name: + running['phone'] = phone + return head + running = running['next'] + + running = head + while running['next'] is not None: running = running['next'] + running['next'] = next_node + return head + +def ll_find(head, name): + running = head + + while True: + if running['name'] == name: + return running['phone'] + running = running['next'] + if running is None: break + + return None + + +def ll_delete(head, name): + running = head + + if running['name'] == name: + return head['next'] + + while running['next']['name'] != name: + running = running['next'] + if running['next']['next'] is None: + if running['next']['name'] != name: + return head + if running['next']['next'] is None: + running['next'] = None + else: running['next'] = running['next']['next'] + + return head + + +def ll_list_all(head): + name_list = [] + running = head + while running is not None: + name_list.append((running['name'], running['phone'])) + running = running['next'] + return name_list + +################################################################################################################################ + + +def LinkedList(head, phone_book): + + start_insert = time.perf_counter() + for i in range(len(phone_book)): + + head = ll_insert(head, phone_book[i][0], phone_book[i][1]) + #print(head) + end_insert = time.perf_counter() + time_insert = end_insert - start_insert + + start_find = time.perf_counter() + for _ in range(100): + name = create_name_phone(rnd.randint(0, 999))[0] + phone = ll_find(head, name) + #print(name, ":", phone) + end_find = time.perf_counter() + time_find = end_find - start_find + + + start_delete = time.perf_counter() + for i in range(110): + if i <= 99: name = f"User_{rnd.randint(0,999):03d}" + else: name = f"None_{i:03d}" + head = ll_delete(head, name) + end_delete = time.perf_counter() + time_delete = end_delete - start_delete + + + start_list = time.perf_counter() + name_list = sort_list(ll_list_all(head)) + #print(*name_list) + end_list = time.perf_counter() + time_list = end_list - start_list + + return (time_insert, time_find, time_delete, time_list) + +######################################################################################################### + +def ht_insert(buckest, name, phone): + index = hash_key(name) % len(buckest) + for i, (Name, Phone) in enumerate(buckest[index]): + if Name == name: + buckest[index][i] = (name, phone) + return buckest + buckest[index].append((name, phone)) + return buckest + +def ht_find(buckest, name): + index = hash_key(name) % len(buckest) + for (Name, Phone) in buckest[index]: + if Name == name: + return Phone + return None + +def ht_list_all(buckest): + + name_list = [] + + for index in range(len(buckest)): + for i, (name, phone) in enumerate(buckest[index]): + name_list.append((name, phone)) + + name_list = sort_list(name_list) + + return name_list + + +def ht_delete(buckest, name): + index = hash_key(name) % len(buckest) + for i, (Name, Phone) in enumerate(buckest[index]): + if Name == name: + del buckest[index][i] + return buckest + + +#################################################################################################### + +def HashTable(buckest, phone_book): + + + start_insert = time.perf_counter() + for i in range(len(phone_book)): + + buckest = ht_insert(buckest, phone_book[i][0], phone_book[i][1]) + #print(buckest) + end_insert = time.perf_counter() + time_insert = end_insert - start_insert + + + start_find = time.perf_counter() + for _ in range(100): + name = create_name_phone(rnd.randint(0, 999))[0] + phone = ht_find(buckest, name) + #print(name, ":", phone) + end_find = time.perf_counter() + time_find = end_find - start_find + + + start_delete = time.perf_counter() + for i in range(110): + if i <= 99: name = f"User_{rnd.randint(0,999):03d}" + else: name = f"None_{i:03d}" + buckest = ht_delete(buckest, name) + end_delete = time.perf_counter() + time_delete = end_delete - start_delete + + + start_list = time.perf_counter() + name_list = sort_list(ht_list_all(buckest)) + #print(*name_list) + end_list = time.perf_counter() + time_list = end_list - start_list + + return (time_insert, time_find, time_delete, time_list) + +################################################################################################# + +def bst_insert(root, name, phone): + + running = root + + if running is None: + root = {'name': name, 'phone': phone, 'left': None, 'right': None} + return root + while True: + node = hash_key(running['name']) + sheet = hash_key(name) + if node < sheet: + if running['right'] is None: + running['right'] = {'name': name, 'phone': phone, 'left': None, 'right': None} + return root + running = running['right'] + elif node > sheet: + if running['left'] is None: + running['left'] = {'name': name, 'phone': phone, 'left': None, 'right': None} + return root + running = running['left'] + else: + running['phone'] = phone + return root + +def bst_find(root, name): + + running = root + + while running is not None: + node = hash_key(running['name']) + sheet = hash_key(name) + if name == running['name']: + return running['phone'] + elif node < sheet: + running = running['right'] + else: + running = running['left'] + + return None + +def bst_list_all(root, name_list = []): + if root is None: + return + name_list.append((root['name'], root['phone'])) + bst_list_all(root['left'], name_list) + bst_list_all(root['right'], name_list) + name_list = sort_list(name_list) + return name_list + +def bst_delete(root, name): + + if root is None: + return None + if hash_key(name) < hash_key(root['name']): + root['left'] = bst_delete(root['left'], name) + elif hash_key(name) > hash_key(root['name']): + root['right'] = bst_delete(root['right'], name) + else: + + if root['left'] is None and root['right'] is None: + return None + + if root['left'] is None: + return root['right'] + if root['right'] is None: + return root['left'] + + min_node = root['right'] + while min_node['left'] is not None: + min_node = min_node['left'] + + root['name'] = min_node['name'] + root['phone'] = min_node['phone'] + + root['right'] = bst_delete(root['right'], min_node['name']) + + return root + +################################################################################################# + +def BinarySearchTree(root, phone_book): + + start_insert = time.perf_counter() + for i in range(len(phone_book)): + + root = bst_insert(root, phone_book[i][0], phone_book[i][1]) + #print(buckest) + end_insert = time.perf_counter() + time_insert = end_insert - start_insert + + + start_find = time.perf_counter() + for _ in range(100): + name = create_name_phone(rnd.randint(0, 999))[0] + phone = bst_find(root, name) + #print(name, ":", phone) + end_find = time.perf_counter() + time_find = end_find - start_find + + + start_delete = time.perf_counter() + for i in range(110): + if i <= 99: name = f"User_{rnd.randint(0,999):03d}" + else: name = f"None_{i:03d}" + root = bst_delete(root, name) + end_delete = time.perf_counter() + time_delete = end_delete - start_delete + + + start_list = time.perf_counter() + name_list = sort_list(bst_list_all(root)) + #print(*name_list) + end_list = time.perf_counter() + time_list = end_list - start_list + + return (time_insert, time_find, time_delete, time_list) + +################################################################################################ +def main(): + + phone_book = [] + for i in range(1000): + phone_book.append(create_name_phone(i)) + for _ in range(9000): + phone_book.append(create_name_phone(rnd.randint(0, 999))) + + phone_book_not_sorted = phone_book.copy() + rnd.shuffle(phone_book_not_sorted) + + phone_book_sorted = phone_book.copy() + phone_book_sorted = sort_list(phone_book_sorted) + replay = 10 + + + Time_ll_not_sorted = [] + Time_ll_sorted = [] + + Time_average_ll_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0} + Time_average_ll_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0} + + print("============================================ TESTING LINKEDLIST =====================================\n") + print('Not sorted: ') + for _ in range(replay): + time_ll_not_sorted = LinkedList(None, phone_book_not_sorted) + Time_ll_not_sorted.append({'insert': time_ll_not_sorted[0], 'find': time_ll_not_sorted[1], 'delete': time_ll_not_sorted[2], 'list': time_ll_not_sorted[3]}) + for i, key in enumerate(Time_average_ll_not_sorted): + Time_average_ll_not_sorted[key] += time_ll_not_sorted[i]/replay + for i in range(replay): + print(Time_ll_not_sorted[i]) + print("Average:", Time_average_ll_not_sorted, "\n\n") + + print('Sorted:') + for _ in range(replay): + time_ll_sorted = LinkedList(None, phone_book_sorted) + Time_ll_sorted.append({'insert': time_ll_sorted[0], 'find': time_ll_sorted[1], 'delete': time_ll_sorted[2], 'list': time_ll_sorted[3]}) + for i, key in enumerate(Time_average_ll_sorted): + Time_average_ll_sorted[key] += time_ll_sorted[i]/replay + for i in range(replay): + print(Time_ll_not_sorted[i]) + print("Average:", Time_average_ll_sorted, "\n\n") + + + + Time_ht_not_sorted = [] + Time_ht_sorted = [] + + Time_average_ht_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0} + Time_average_ht_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0} + + print("============================================ TESTING HASHTABLE =====================================\n") + print('Not sorted: ') + for _ in range(replay): + time_ht_not_sorted = HashTable([[] for _ in range(100)], phone_book_not_sorted) + Time_ht_not_sorted.append({'insert': time_ht_not_sorted[0], 'find': time_ht_not_sorted[1], 'delete': time_ht_not_sorted[2], 'list': time_ht_not_sorted[3]}) + for i, key in enumerate(Time_average_ht_not_sorted): + Time_average_ht_not_sorted[key] += time_ht_not_sorted[i]/replay + for i in range(replay): + print(Time_ht_not_sorted[i]) + print(f"Average: {Time_average_ht_not_sorted}\n\n") + + print('Sorted: ') + for _ in range(replay): + time_ht_sorted = HashTable([[] for _ in range(100)], phone_book_sorted) + Time_ht_sorted.append({'insert': time_ht_sorted[0], 'find': time_ht_sorted[1], 'delete': time_ht_sorted[2], 'list': time_ht_sorted[3]}) + for i, key in enumerate(Time_average_ht_sorted): + Time_average_ht_sorted[key] += time_ht_sorted[i]/replay + for i in range(replay): + print(Time_ht_sorted[i]) + print(f"Average: {Time_average_ht_sorted}\n\n") + + + + Time_bst_not_sorted = [] + Time_bst_sorted = [] + + Time_average_bst_not_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0} + Time_average_bst_sorted = {'insert': 0, 'find': 0, 'delete': 0, 'list': 0} + + print("============================================ TESTING BINARYSEARCHTREE =====================================\n") + print('Not sorted: ') + for _ in range(replay): + time_bst_not_sorted = BinarySearchTree(None, phone_book_not_sorted) + Time_bst_not_sorted.append({'insert': time_bst_not_sorted[0], 'find': time_bst_not_sorted[1], 'delete': time_bst_not_sorted[2], 'list': time_bst_not_sorted[3]}) + for i, key in enumerate(Time_average_bst_not_sorted): + Time_average_bst_not_sorted[key] += time_bst_not_sorted[i]/replay + for i in range(replay): + print(Time_bst_not_sorted[i]) + print(f"Average: {Time_average_bst_not_sorted}\n\n") + + print('Sorted: ') + for _ in range(replay): + time_bst_sorted = BinarySearchTree(None, phone_book_sorted) + Time_bst_sorted.append({'insert': time_bst_sorted[0], 'find': time_bst_sorted[1], 'delete': time_bst_sorted[2], 'list': time_bst_sorted[3]}) + for i, key in enumerate(Time_average_bst_sorted): + Time_average_bst_sorted[key] += time_bst_sorted[i]/replay + for i in range(replay): + print(Time_bst_sorted[i]) + print(f"Average: {Time_average_bst_sorted}\n\n") + print("=============================================== END TESTING ================================================") + + results = [["Структура", "Режим", "Операция", "Время(мс)"]] + for i in range(replay): + results.append(["LinkedList", "Случайный", "вставка", Time_ll_not_sorted[i]["insert"]]) + results.append(["LinkedList", "Случайный", "поиск", Time_ll_not_sorted[i]["find"]]) + results.append(["LinkedList", "Случайный", "удаление", Time_ll_not_sorted[i]["delete"]]) + results.append(["LinkedList", "Случайный", "формирование списка", Time_ll_not_sorted[i]["list"]]) + + results.append(["LinkedList", "Упорядоченный", "вставка", Time_ll_sorted[i]["insert"]]) + results.append(["LinkedList", "Упорядоченный", "поиск", Time_ll_sorted[i]["find"]]) + results.append(["LinkedList", "Упорядоченный", "удаление", Time_ll_sorted[i]["delete"]]) + results.append(["LinkedList", "Упорядоченный", "формирование списка", Time_ll_sorted[i]["list"]]) + + for i in range(replay): + results.append(["HashTable", "Случайный", "вставка", Time_ht_not_sorted[i]["insert"]]) + results.append(["HashTable", "Случайный", "поиск", Time_ht_not_sorted[i]["find"]]) + results.append(["HashTable", "Случайный", "удаление", Time_ht_not_sorted[i]["delete"]]) + results.append(["HashTable", "Случайный", "формирование списка", Time_ht_not_sorted[i]["list"]]) + + results.append(["HashTable", "Упорядоченный", "вставка", Time_ht_sorted[i]["insert"]]) + results.append(["HashTable", "Упорядоченный", "поиск", Time_ht_sorted[i]["find"]]) + results.append(["HashTable", "Упорядоченный", "удаление", Time_ht_sorted[i]["delete"]]) + results.append(["HashTable", "Упорядоченный", "формирование списка", Time_ht_sorted[i]["list"]]) + + for i in range(replay): + results.append(["BinarySearchTree", "Случайный", "вставка", Time_bst_not_sorted[i]["insert"]]) + results.append(["BinarySearchTree", "Случайный", "поиск", Time_bst_not_sorted[i]["find"]]) + results.append(["BinarySearchTree", "Случайный", "удаление", Time_bst_not_sorted[i]["delete"]]) + results.append(["BinarySearchTree", "Случайный", "формирование списка", Time_bst_not_sorted[i]["list"]]) + + results.append(["BinarySearchTree", "Упорядоченный", "вставка", Time_bst_sorted[i]["insert"]]) + results.append(["BinarySearchTree", "Упорядоченный", "поиск", Time_bst_sorted[i]["find"]]) + results.append(["BinarySearchTree", "Упорядоченный", "удаление", Time_bst_sorted[i]["delete"]]) + results.append(["BinarySearchTree", "Упорядоченный", "формирование списка", Time_bst_sorted[i]["list"]]) + + for i in range(1, len(results) - 1): + results[i][3] *= 1000 + file_insert(results) + + fig, axes = plt.subplots(1, 4, figsize = (16, 5)) + manager = plt.get_current_fig_manager() + manager.full_screen_toggle() + + + drow(Time_average_ll_not_sorted, "#0800FF", -0.3, "LinkedList (not sorted)", axes) + drow(Time_average_ll_sorted, "#00C8FF", -0.18, "LinkedList (sorted)", axes) + drow(Time_average_ht_not_sorted, "#0E7A13", -0.06, "HashTable (not sorted)", axes) + drow(Time_average_ht_sorted, "#4DFF00", 0.06, "HashTable (sorted)", axes) + drow(Time_average_bst_not_sorted, "#968C1A", 0.18, "BST (not sorted)", axes) + drow(Time_average_bst_sorted, "#FBFF00", 0.30, "BST (sorted)", axes) + + operation = ['insert', 'find', 'delete', 'create list'] + + for i in range(4): + axes[i].set_title(operation[i]) + plt.legend(bbox_to_anchor = (1.05, 1), loc = "upper left") + + + + plt.subplots_adjust(bottom = 0.025, top = 0.95, left = 0.025, right = 0.875) + plt.savefig("time_schedule.png") + plt.show() + +if __name__ == "__main__": + main() + + + + diff --git a/lukovnikovde/docs/data/1-st-exercise/resalts.csv b/lukovnikovde/docs/data/1-st-exercise/resalts.csv new file mode 100644 index 0000000..16e5f52 --- /dev/null +++ b/lukovnikovde/docs/data/1-st-exercise/resalts.csv @@ -0,0 +1,241 @@ +Структура,Режим,Операция,Время(мс) +LinkedList,Случайный,вставка,159.38230000028852 +LinkedList,Случайный,поиск,1.608700000360841 +LinkedList,Случайный,удаление,3.333099999508704 +LinkedList,Случайный,формирование списка,31.43850000014936 +LinkedList,Упорядоченный,вставка,176.2546999998449 +LinkedList,Упорядоченный,поиск,1.7821999990701443 +LinkedList,Упорядоченный,удаление,3.542399999787449 +LinkedList,Упорядоченный,формирование списка,21.29400000012538 +LinkedList,Случайный,вставка,160.5120000003808 +LinkedList,Случайный,поиск,1.5978000010363758 +LinkedList,Случайный,удаление,3.5874000004696427 +LinkedList,Случайный,формирование списка,31.3373999997566 +LinkedList,Упорядоченный,вставка,169.6819000007963 +LinkedList,Упорядоченный,поиск,1.6672000001562992 +LinkedList,Упорядоченный,удаление,3.06300000011106 +LinkedList,Упорядоченный,формирование списка,21.382199998697615 +LinkedList,Случайный,вставка,162.45290000006207 +LinkedList,Случайный,поиск,1.6584000004513655 +LinkedList,Случайный,удаление,3.0743000006623333 +LinkedList,Случайный,формирование списка,31.488399999943795 +LinkedList,Упорядоченный,вставка,169.72099999838974 +LinkedList,Упорядоченный,поиск,1.7922000006365124 +LinkedList,Упорядоченный,удаление,3.3667999996396247 +LinkedList,Упорядоченный,формирование списка,21.698699998523807 +LinkedList,Случайный,вставка,163.0209000013565 +LinkedList,Случайный,поиск,1.6841999986354494 +LinkedList,Случайный,удаление,3.2122999982675537 +LinkedList,Случайный,формирование списка,31.478799999604234 +LinkedList,Упорядоченный,вставка,172.49460000130057 +LinkedList,Упорядоченный,поиск,1.756999999997788 +LinkedList,Упорядоченный,удаление,3.196600000592298 +LinkedList,Упорядоченный,формирование списка,21.166299999094917 +LinkedList,Случайный,вставка,163.07450000022072 +LinkedList,Случайный,поиск,1.8555999995442107 +LinkedList,Случайный,удаление,3.40919999871403 +LinkedList,Случайный,формирование списка,31.833799999731127 +LinkedList,Упорядоченный,вставка,170.02059999867924 +LinkedList,Упорядоченный,поиск,1.552300000184914 +LinkedList,Упорядоченный,удаление,3.814900001088972 +LinkedList,Упорядоченный,формирование списка,21.307799999704002 +LinkedList,Случайный,вставка,168.1974999992235 +LinkedList,Случайный,поиск,2.0230999998602783 +LinkedList,Случайный,удаление,3.5730999989027623 +LinkedList,Случайный,формирование списка,32.19399999943562 +LinkedList,Упорядоченный,вставка,169.28159999952186 +LinkedList,Упорядоченный,поиск,1.713900001050206 +LinkedList,Упорядоченный,удаление,3.4302999993087724 +LinkedList,Упорядоченный,формирование списка,21.549899998717592 +LinkedList,Случайный,вставка,169.27700000087498 +LinkedList,Случайный,поиск,1.7975999999180203 +LinkedList,Случайный,удаление,3.151300001263735 +LinkedList,Случайный,формирование списка,31.799799999134848 +LinkedList,Упорядоченный,вставка,171.0044999999809 +LinkedList,Упорядоченный,поиск,1.743999999234802 +LinkedList,Упорядоченный,удаление,3.8127000007079914 +LinkedList,Упорядоченный,формирование списка,21.345600000131526 +LinkedList,Случайный,вставка,173.35669999920356 +LinkedList,Случайный,поиск,1.8798999990394805 +LinkedList,Случайный,удаление,3.4422999997332226 +LinkedList,Случайный,формирование списка,32.4691999994684 +LinkedList,Упорядоченный,вставка,169.52339999988908 +LinkedList,Упорядоченный,поиск,1.728800001728814 +LinkedList,Упорядоченный,удаление,3.3399000003555557 +LinkedList,Упорядоченный,формирование списка,21.254400000543683 +LinkedList,Случайный,вставка,169.77609999958077 +LinkedList,Случайный,поиск,1.6739000002417015 +LinkedList,Случайный,удаление,3.73560000116413 +LinkedList,Случайный,формирование списка,31.469499999730033 +LinkedList,Упорядоченный,вставка,171.0146999994322 +LinkedList,Упорядоченный,поиск,1.6797999996924773 +LinkedList,Упорядоченный,удаление,3.45019999986107 +LinkedList,Упорядоченный,формирование списка,21.524600000702776 +LinkedList,Случайный,вставка,167.06580000027316 +LinkedList,Случайный,поиск,1.8982999990839744 +LinkedList,Случайный,удаление,3.6678999986179406 +LinkedList,Случайный,формирование списка,32.446200000777026 +LinkedList,Упорядоченный,вставка,171.11090000071272 +LinkedList,Упорядоченный,поиск,1.7826000002969522 +LinkedList,Упорядоченный,удаление,3.3842000011645723 +LinkedList,Упорядоченный,формирование списка,21.2576000012632 +HashTable,Случайный,вставка,17.278299999816227 +HashTable,Случайный,поиск,0.3028999999514781 +HashTable,Случайный,удаление,0.3226000007998664 +HashTable,Случайный,формирование списка,47.606800000721705 +HashTable,Упорядоченный,вставка,16.69159999983094 +HashTable,Упорядоченный,поиск,0.278499999694759 +HashTable,Упорядоченный,удаление,0.31350000062957406 +HashTable,Упорядоченный,формирование списка,47.49850000007427 +HashTable,Случайный,вставка,18.00539999931061 +HashTable,Случайный,поиск,0.28170000041427556 +HashTable,Случайный,удаление,0.3051999992749188 +HashTable,Случайный,формирование списка,48.14599999917846 +HashTable,Упорядоченный,вставка,18.065500000375323 +HashTable,Упорядоченный,поиск,0.28329999986453913 +HashTable,Упорядоченный,удаление,0.32250000003841706 +HashTable,Упорядоченный,формирование списка,47.55000000113796 +HashTable,Случайный,вставка,16.97520000016084 +HashTable,Случайный,поиск,0.2812000002450077 +HashTable,Случайный,удаление,0.3178000006300863 +HashTable,Случайный,формирование списка,47.868200001175865 +HashTable,Упорядоченный,вставка,18.372099999396596 +HashTable,Упорядоченный,поиск,0.3102999999100575 +HashTable,Упорядоченный,удаление,0.3297000002930872 +HashTable,Упорядоченный,формирование списка,48.02730000119482 +HashTable,Случайный,вставка,16.71149999856425 +HashTable,Случайный,поиск,0.27319999935571104 +HashTable,Случайный,удаление,0.3262999998696614 +HashTable,Случайный,формирование списка,47.846100000242586 +HashTable,Упорядоченный,вставка,18.567699999039178 +HashTable,Упорядоченный,поиск,0.2848999993148027 +HashTable,Упорядоченный,удаление,0.3262999998696614 +HashTable,Упорядоченный,формирование списка,48.06850000022678 +HashTable,Случайный,вставка,16.770899999755784 +HashTable,Случайный,поиск,0.26760000037029386 +HashTable,Случайный,удаление,0.3209000005881535 +HashTable,Случайный,формирование списка,48.08539999976347 +HashTable,Упорядоченный,вставка,17.05279999987397 +HashTable,Упорядоченный,поиск,0.2679999997781124 +HashTable,Упорядоченный,удаление,0.31599999965692405 +HashTable,Упорядоченный,формирование списка,48.27990000012505 +HashTable,Случайный,вставка,17.21460000044317 +HashTable,Случайный,поиск,0.27520000003278255 +HashTable,Случайный,удаление,0.3281999997852836 +HashTable,Случайный,формирование списка,47.93720000088797 +HashTable,Упорядоченный,вставка,17.084900000554626 +HashTable,Упорядоченный,поиск,0.2795999989757547 +HashTable,Упорядоченный,удаление,0.3280000000813743 +HashTable,Упорядоченный,формирование списка,47.76760000095237 +HashTable,Случайный,вставка,16.898900001251604 +HashTable,Случайный,поиск,0.2705999995669117 +HashTable,Случайный,удаление,0.3180999992764555 +HashTable,Случайный,формирование списка,48.1019999988348 +HashTable,Упорядоченный,вставка,17.074800000045798 +HashTable,Упорядоченный,поиск,0.27850000151374843 +HashTable,Упорядоченный,удаление,0.3259999994043028 +HashTable,Упорядоченный,формирование списка,48.0186999993748 +HashTable,Случайный,вставка,17.024499999024556 +HashTable,Случайный,поиск,0.2716999988479074 +HashTable,Случайный,удаление,0.3228999994462356 +HashTable,Случайный,формирование списка,48.31470000135596 +HashTable,Упорядоченный,вставка,17.382100000759237 +HashTable,Упорядоченный,поиск,0.2786999993986683 +HashTable,Упорядоченный,удаление,0.3171999996993691 +HashTable,Упорядоченный,формирование списка,47.687000000223634 +HashTable,Случайный,вставка,17.80959999996412 +HashTable,Случайный,поиск,0.28049999855284113 +HashTable,Случайный,удаление,0.3245999996579485 +HashTable,Случайный,формирование списка,48.608699999022065 +HashTable,Упорядоченный,вставка,17.124399999374873 +HashTable,Упорядоченный,поиск,0.2822999995260034 +HashTable,Упорядоченный,удаление,0.31680000029155053 +HashTable,Упорядоченный,формирование списка,47.660199999882025 +HashTable,Случайный,вставка,16.860599998835823 +HashTable,Случайный,поиск,0.27319999935571104 +HashTable,Случайный,удаление,0.31459999991056975 +HashTable,Случайный,формирование списка,48.28310000084457 +HashTable,Упорядоченный,вставка,17.49010000094131 +HashTable,Упорядоченный,поиск,0.29379999978118576 +HashTable,Упорядоченный,удаление,0.31820000003790483 +HashTable,Упорядоченный,формирование списка,48.560000001089065 +BinarySearchTree,Случайный,вставка,53.984700000000885 +BinarySearchTree,Случайный,поиск,0.7683999992877943 +BinarySearchTree,Случайный,удаление,0.6331000004138332 +BinarySearchTree,Случайный,формирование списка,0.01739999970595818 +BinarySearchTree,Упорядоченный,вставка,163.88949999964098 +BinarySearchTree,Упорядоченный,поиск,1.765700000760262 +BinarySearchTree,Упорядоченный,удаление,1.525900001070113 +BinarySearchTree,Упорядоченный,формирование списка,0.4360000002634479 +BinarySearchTree,Случайный,вставка,52.91410000063479 +BinarySearchTree,Случайный,поиск,0.7721999991190387 +BinarySearchTree,Случайный,удаление,0.5829000001540408 +BinarySearchTree,Случайный,формирование списка,0.04259999877831433 +BinarySearchTree,Упорядоченный,вставка,164.1801999994641 +BinarySearchTree,Упорядоченный,поиск,1.7733000004227506 +BinarySearchTree,Упорядоченный,удаление,1.3930999994045123 +BinarySearchTree,Упорядоченный,формирование списка,0.8812000014586374 +BinarySearchTree,Случайный,вставка,52.482299999610404 +BinarySearchTree,Случайный,поиск,0.7862000002205605 +BinarySearchTree,Случайный,удаление,0.6584999991900986 +BinarySearchTree,Случайный,формирование списка,0.0718000010238029 +BinarySearchTree,Упорядоченный,вставка,161.70600000077684 +BinarySearchTree,Упорядоченный,поиск,1.7728999991959427 +BinarySearchTree,Упорядоченный,удаление,1.7010999999911292 +BinarySearchTree,Упорядоченный,формирование списка,1.2267000001884298 +BinarySearchTree,Случайный,вставка,53.89560000003257 +BinarySearchTree,Случайный,поиск,0.7697999990341486 +BinarySearchTree,Случайный,удаление,0.669999999445281 +BinarySearchTree,Случайный,формирование списка,0.1666999996814411 +BinarySearchTree,Упорядоченный,вставка,160.7681000004959 +BinarySearchTree,Упорядоченный,поиск,1.770599999872502 +BinarySearchTree,Упорядоченный,удаление,1.4972999997553416 +BinarySearchTree,Упорядоченный,формирование списка,1.454899998861947 +BinarySearchTree,Случайный,вставка,52.44479999964824 +BinarySearchTree,Случайный,поиск,0.7471999997505918 +BinarySearchTree,Случайный,удаление,0.7040000000415603 +BinarySearchTree,Случайный,формирование списка,0.19189999875379726 +BinarySearchTree,Упорядоченный,вставка,162.21529999893392 +BinarySearchTree,Упорядоченный,поиск,1.835400000345544 +BinarySearchTree,Упорядоченный,удаление,1.5229000000545057 +BinarySearchTree,Упорядоченный,формирование списка,1.444699999410659 +BinarySearchTree,Случайный,вставка,52.532899999278015 +BinarySearchTree,Случайный,поиск,0.772299999880488 +BinarySearchTree,Случайный,удаление,0.6493000000773463 +BinarySearchTree,Случайный,формирование списка,0.3001000004587695 +BinarySearchTree,Упорядоченный,вставка,162.3187000004691 +BinarySearchTree,Упорядоченный,поиск,1.7641000013099983 +BinarySearchTree,Упорядоченный,удаление,1.656399999774294 +BinarySearchTree,Упорядоченный,формирование списка,1.9058000016229926 +BinarySearchTree,Случайный,вставка,52.441100000578444 +BinarySearchTree,Случайный,поиск,0.7502000007661991 +BinarySearchTree,Случайный,удаление,0.7283999984792899 +BinarySearchTree,Случайный,формирование списка,0.4217999994580168 +BinarySearchTree,Упорядоченный,вставка,163.2737999989331 +BinarySearchTree,Упорядоченный,поиск,1.7657999997027218 +BinarySearchTree,Упорядоченный,удаление,1.2108999999327352 +BinarySearchTree,Упорядоченный,формирование списка,1.5694999983679736 +BinarySearchTree,Случайный,вставка,52.80719999973371 +BinarySearchTree,Случайный,поиск,0.7774999994580867 +BinarySearchTree,Случайный,удаление,0.5965999989712145 +BinarySearchTree,Случайный,формирование списка,0.4585999995470047 +BinarySearchTree,Упорядоченный,вставка,164.02340000058757 +BinarySearchTree,Упорядоченный,поиск,1.836600000387989 +BinarySearchTree,Упорядоченный,удаление,1.7723999990266748 +BinarySearchTree,Упорядоченный,формирование списка,2.3199999995995313 +BinarySearchTree,Случайный,вставка,52.927000000636326 +BinarySearchTree,Случайный,поиск,0.7868000011512777 +BinarySearchTree,Случайный,удаление,0.6422000005841255 +BinarySearchTree,Случайный,формирование списка,0.4780999988724943 +BinarySearchTree,Упорядоченный,вставка,162.5091000005341 +BinarySearchTree,Упорядоченный,поиск,1.8755000000965083 +BinarySearchTree,Упорядоченный,удаление,1.8066000011458527 +BinarySearchTree,Упорядоченный,формирование списка,2.217999999629683 +BinarySearchTree,Случайный,вставка,53.06439999912982 +BinarySearchTree,Случайный,поиск,0.7920999996713363 +BinarySearchTree,Случайный,удаление,0.7385999997495674 +BinarySearchTree,Случайный,формирование списка,0.6822999985161005 +BinarySearchTree,Упорядоченный,вставка,162.1802999998181 +BinarySearchTree,Упорядоченный,поиск,1.9329999995534308 +BinarySearchTree,Упорядоченный,удаление,1.5555000009044306 +BinarySearchTree,Упорядоченный,формирование списка,0.0028387000002112472 diff --git a/lukovnikovde/docs/data/1-st-exercise/time_schedule.png b/lukovnikovde/docs/data/1-st-exercise/time_schedule.png new file mode 100644 index 0000000..cb800ef Binary files /dev/null and b/lukovnikovde/docs/data/1-st-exercise/time_schedule.png differ diff --git a/lukovnikovde/docs/data/2-nd-exercise/main.py b/lukovnikovde/docs/data/2-nd-exercise/main.py new file mode 100644 index 0000000..69a8852 --- /dev/null +++ b/lukovnikovde/docs/data/2-nd-exercise/main.py @@ -0,0 +1,527 @@ +import sys +import os +from collections import deque +import heapq +import time +import csv +import matplotlib.pyplot as plt +import numpy as np + +# ---------- 1. Модель клетки и лабиринта ---------- +class Tile: + def __init__(self, x, y): + self.x = x + self.y = y + self.wall = False + self.start = False + self.exit = False + + def passable(self): + return not self.wall + + +class Labyrinth: + def __init__(self, width, height): + self.width = width + self.height = height + self._tiles = [[Tile(x, y) for x in range(width)] for y in range(height)] + self.start_tile = None + self.exit_tile = None + + def get_tile(self, x, y): + if 0 <= x < self.width and 0 <= y < self.height: + return self._tiles[y][x] + return None + + def set_tile(self, x, y, kind): + tile = self.get_tile(x, y) + if tile is None: + return + if kind == 'wall': + tile.wall = True + elif kind == 'start': + if self.start_tile: + self.start_tile.start = False + tile.start = True + tile.wall = False + self.start_tile = tile + elif kind == 'exit': + if self.exit_tile: + self.exit_tile.exit = False + tile.exit = True + tile.wall = False + self.exit_tile = tile + elif kind == 'path': + tile.wall = False + + def neighbours(self, tile): + dirs = [(0, -1), (0, 1), (-1, 0), (1, 0)] + result = [] + for dx, dy in dirs: + nx, ny = tile.x + dx, tile.y + dy + nb = self.get_tile(nx, ny) + if nb and nb.passable(): + result.append(nb) + return result + + +# ---------- 2. Загрузка лабиринта из файла ---------- +class LabyrinthLoader: + def load(self, filename): + raise NotImplementedError + + +class TextLabyrinthLoader(LabyrinthLoader): + def load(self, filename): + with open(filename, 'r', encoding='utf-8') as f: + lines = [line.rstrip('\n') for line in f] + h = len(lines) + w = max(len(line) for line in lines) if h > 0 else 0 + start_cnt = 0 + exit_cnt = 0 + lab = Labyrinth(w, h) + + for y, line in enumerate(lines): + for x, ch in enumerate(line): + if ch == '#': + lab.set_tile(x, y, 'wall') + elif ch == 'S': + lab.set_tile(x, y, 'start') + start_cnt += 1 + elif ch == 'E': + lab.set_tile(x, y, 'exit') + exit_cnt += 1 + else: + lab.set_tile(x, y, 'path') + if start_cnt != 1 or exit_cnt != 1: + raise ValueError(f"Нужны ровно S и E, найдено S={start_cnt}, E={exit_cnt}") + return lab + + +# ---------- 3. Алгоритмы поиска пути (стратегии) ---------- +class Pathfinder: + def find_path(self, lab, start, goal): + raise NotImplementedError + + def _build_path(self, came_from, start, goal): + path = [] + cur = goal + while cur is not None: + path.append(cur) + cur = came_from.get(cur) + path.reverse() + return path + + def visited_count(self): + return getattr(self, '_visited', 0) + + +class BFS(Pathfinder): + def find_path(self, lab, start, goal): + q = deque([start]) + parent = {start: None} + visited = {start} + while q: + cur = q.popleft() + if cur == goal: + self._visited = len(visited) + return self._build_path(parent, start, goal) + for nb in lab.neighbours(cur): + if nb not in visited: + visited.add(nb) + parent[nb] = cur + q.append(nb) + self._visited = len(visited) + return [] + + +class DFS(Pathfinder): + def find_path(self, lab, start, goal): + stack = [start] + parent = {start: None} + visited = {start} + while stack: + cur = stack.pop() + if cur == goal: + self._visited = len(visited) + return self._build_path(parent, start, goal) + for nb in lab.neighbours(cur): + if nb not in visited: + visited.add(nb) + parent[nb] = cur + stack.append(nb) + self._visited = len(visited) + return [] + + +class AStar(Pathfinder): + def _heuristic(self, a, b): + return abs(a.x - b.x) + abs(a.y - b.y) + + def find_path(self, lab, start, goal): + heap = [] + counter = 0 + start_f = self._heuristic(start, goal) + heapq.heappush(heap, (start_f, counter, start)) + counter += 1 + parent = {} + g = {start: 0} + f = {start: start_f} + visited = set() + while heap: + cur_f, _, cur = heapq.heappop(heap) + visited.add(cur) + if cur == goal: + self._visited = len(visited) + return self._build_path(parent, start, goal) + if cur_f > f.get(cur, float('inf')): + continue + for nb in lab.neighbours(cur): + new_g = g[cur] + 1 + if new_g < g.get(nb, float('inf')): + parent[nb] = cur + g[nb] = new_g + new_f = new_g + self._heuristic(nb, goal) + f[nb] = new_f + heapq.heappush(heap, (new_f, counter, nb)) + counter += 1 + self._visited = len(visited) + return [] + + +# ---------- 4. Оркестратор с поддержкой наблюдателей ---------- +class LabyrinthSolver: + def __init__(self, lab): + self.lab = lab + self.strategy = None + self.observers = [] + + def attach(self, obs): + self.observers.append(obs) + + def notify(self, event, data): + for obs in self.observers: + obs.notify(event, data) + + def set_strategy(self, strategy): + self.strategy = strategy + + def solve(self): + if not self.strategy: + return None + t0 = time.perf_counter() + path = self.strategy.find_path(self.lab, self.lab.start_tile, self.lab.exit_tile) + t1 = time.perf_counter() + self.notify("path_found", path) + return { + 'time_ms': (t1 - t0) * 1000, + 'visited': self.strategy.visited_count(), + 'length': len(path) + } + + +# ---------- 5. Визуализация (наблюдатель) ---------- +class EventListener: + def notify(self, event, data): + raise NotImplementedError + + +class ConsoleRenderer(EventListener): + def __init__(self, walker=None): + self.last_path = None + self.walker = walker + + def notify(self, event, data): + if event == "maze_loaded": + self._draw_maze(data) + elif event == "path_found": + self.last_path = data + self._show_path_info(data) + elif event == "player_moved": + self._draw_maze_with_player(data) + + def _draw_maze(self, lab): + os.system('cls' if os.name == 'nt' else 'clear') + print("=" * (lab.width * 2 + 4)) + print(" ЛАБИРИНТ") + print("=" * (lab.width * 2 + 4)) + for y in range(lab.height): + print(" ", end='') + for x in range(lab.width): + t = lab.get_tile(x, y) + if t == lab.start_tile: + print('S', end=' ') + elif t == lab.exit_tile: + print('E', end=' ') + elif t.wall: + print('#', end=' ') + else: + print('.', end=' ') + print() + print("=" * (lab.width * 2 + 4)) + print(" S - старт E - выход # - стена . - проход") + + def _draw_maze_with_player(self, lab): + os.system('cls' if os.name == 'nt' else 'clear') + print("=" * (lab.width * 2 + 4)) + print(" ЛАБИРИНТ (игрок = P)") + print("=" * (lab.width * 2 + 4)) + for y in range(lab.height): + print(" ", end='') + for x in range(lab.width): + t = lab.get_tile(x, y) + if self.walker and t == self.walker.current: + print('P', end=' ') + elif t == lab.start_tile: + print('S', end=' ') + elif t == lab.exit_tile: + print('E', end=' ') + elif t.wall: + print('#', end=' ') + else: + print('.', end=' ') + print() + print("=" * (lab.width * 2 + 4)) + if self.walker: + print(f" Позиция игрока: ({self.walker.current.x}, {self.walker.current.y})") + + def _show_path_info(self, path): + if not path: + print("\n Путь не найден!") + else: + print(f"\n Путь найден! Длина = {len(path)}") + + +# ---------- 6. Игрок и команды с отменой ---------- +class Walker: + def __init__(self, start_tile, lab): + self.current = start_tile + self.prev = None + self.lab = lab + + def move(self, target_tile): + if target_tile and target_tile.passable(): + self.prev = self.current + self.current = target_tile + return True + return False + + def undo(self): + if self.prev: + self.current, self.prev = self.prev, None + return True + return False + + +class Action: + def do(self): + raise NotImplementedError + def undo(self): + raise NotImplementedError + + +class MoveAction(Action): + def __init__(self, walker, dx, dy, lab): + self.walker = walker + self.dx = dx + self.dy = dy + self.lab = lab + self.done = False + + def do(self): + new_x = self.walker.current.x + self.dx + new_y = self.walker.current.y + self.dy + target = self.lab.get_tile(new_x, new_y) + if target and target.passable(): + self.walker.move(target) + self.done = True + return True + return False + + def undo(self): + if self.done: + self.walker.undo() + self.done = False + return True + return False + + +# ---------- 7. Экспериментальные функции ---------- +def run_benchmark(maze_file, strategy, runs=5): + loader = TextLabyrinthLoader() + lab = loader.load(maze_file) + total_time = 0.0 + total_visited = 0 + total_len = 0 + for _ in range(runs): + solver = LabyrinthSolver(lab) + solver.set_strategy(strategy) + stats = solver.solve() + if stats: + total_time += stats['time_ms'] + total_visited += stats['visited'] + total_len += stats['length'] + return { + 'time_ms': total_time / runs, + 'visited': total_visited / runs, + 'length': total_len / runs + } + + +def make_plots(results): + mazes = list({r['maze'] for r in results}) + algos = ['BFS', 'DFS', 'AStar'] + fig, axes = plt.subplots(1, 3, figsize=(15, 5)) + x = np.arange(len(mazes)) + width = 0.25 + + for i, algo in enumerate(algos): + times = [] + for m in mazes: + val = next((r['time_ms'] for r in results if r['maze'] == m and r['algo'] == algo), 0) + times.append(val) + axes[0].bar(x + i*width, times, width, label=algo) + axes[0].set_xlabel('Лабиринт') + axes[0].set_ylabel('Время (мс)') + axes[0].set_title('Сравнение времени выполнения') + axes[0].set_xticks(x + width) + axes[0].set_xticklabels(mazes, rotation=45, ha='right') + axes[0].legend() + axes[0].grid(True, alpha=0.3) + + for i, algo in enumerate(algos): + visited_vals = [] + for m in mazes: + val = next((r['visited'] for r in results if r['maze'] == m and r['algo'] == algo), 0) + visited_vals.append(val) + axes[1].bar(x + i*width, visited_vals, width, label=algo) + axes[1].set_xlabel('Лабиринт') + axes[1].set_ylabel('Посещено клеток') + axes[1].set_title('Сравнение посещённых клеток') + axes[1].set_xticks(x + width) + axes[1].set_xticklabels(mazes, rotation=45, ha='right') + axes[1].legend() + axes[1].grid(True, alpha=0.3) + + for i, algo in enumerate(algos): + lengths = [] + for m in mazes: + val = next((r['length'] for r in results if r['maze'] == m and r['algo'] == algo), 0) + lengths.append(val) + axes[2].bar(x + i*width, lengths, width, label=algo) + axes[2].set_xlabel('Лабиринт') + axes[2].set_ylabel('Длина пути') + axes[2].set_title('Сравнение длины пути') + axes[2].set_xticks(x + width) + axes[2].set_xticklabels(mazes, rotation=45, ha='right') + axes[2].legend() + axes[2].grid(True, alpha=0.3) + + plt.tight_layout() + plt.savefig('performance_comparison.png', dpi=150, bbox_inches='tight') + plt.show() + + +# ---------- 8. Главный блок ---------- +if __name__ == "__main__": + if len(sys.argv) > 1 and sys.argv[1] == 'experiment': + # Режим экспериментов + test_mazes = [ + ("maze/maze1.txt", "Small 10x6"), + ("maze/maze10x10.txt", "Medium 10x10"), + ("maze/maze20x20.txt", "Large 20x20"), + ("maze/maze_empty.txt", "Empty 15x15"), + ("maze/maze_no_exit.txt", "No exit 10x10") + ] + strategies = [ + ("BFS", BFS()), + ("DFS", DFS()), + ("AStar", AStar()) + ] + results = [] + for maze_path, maze_name in test_mazes: + print(f"Тестируем {maze_name}...") + for algo_name, algo in strategies: + try: + stats = run_benchmark(maze_path, algo, runs=3) + results.append({ + 'maze': maze_name, + 'algo': algo_name, + 'time_ms': stats['time_ms'], + 'visited': stats['visited'], + 'length': stats['length'] + }) + print(f" {algo_name}: время={stats['time_ms']:.3f}мс, посещено={stats['visited']:.0f}, длина={stats['length']:.0f}") + except Exception as e: + print(f" {algo_name}: ошибка - {e}") + # Сохраняем CSV + with open('experiment_results.csv', 'w', newline='', encoding='utf-8') as f: + writer = csv.DictWriter(f, fieldnames=['maze', 'algo', 'time_ms', 'visited', 'length']) + writer.writeheader() + writer.writerows(results) + # Строим графики + if results: + make_plots(results) + print("\nРезультаты сохранены в experiment_results.csv и performance_comparison.png") + else: + # Интерактивный режим + loader = TextLabyrinthLoader() + lab = loader.load("maze/maze1.txt") + + player = Walker(lab.start_tile, lab) + view = ConsoleRenderer(player) + view.notify("maze_loaded", lab) + + solver = LabyrinthSolver(lab) + solver.attach(view) + + print("\n УПРАВЛЕНИЕ:") + print(" H (влево) J (вниз) K (вверх) L (вправо)") + print(" U - отменить ход Q - выход") + print("\n АВТОПОИСК:") + print(" B - BFS D - DFS A - A*") + print("\n" + "=" * 50) + + command_stack = [] + while True: + key = input("\n Команда > ").lower() + if key == 'q': + print("\n До свидания!") + break + elif key == 'b': + solver.set_strategy(BFS()) + stats = solver.solve() + if stats: + print(f"\n BFS: время={stats['time_ms']:.3f}мс, посещено={stats['visited']}, длина={stats['length']}") + elif key == 'd': + solver.set_strategy(DFS()) + stats = solver.solve() + print(f"\n DFS: время={stats['time_ms']:.3f}мс, посещено={stats['visited']}, длина={stats['length']}") + elif key == 'a': + solver.set_strategy(AStar()) + stats = solver.solve() + print(f"\n A*: время={stats['time_ms']:.3f}мс, посещено={stats['visited']}, длина={stats['length']}") + elif key in ['h', 'j', 'k', 'l']: + dirs = {'h': (-1,0), 'l': (1,0), 'k': (0,-1), 'j': (0,1)} + act = MoveAction(player, dirs[key][0], dirs[key][1], lab) + if act.do(): + command_stack.append(act) + view.notify("player_moved", lab) + if player.current == lab.exit_tile: + print("\n ПОЗДРАВЛЯЮ! ВЫ НАШЛИ ВЫХОД!") + print(f" Сделано ходов: {len(command_stack)}") + break + else: + print("\n Туда нельзя – стена!") + elif key == 'u': + if command_stack: + cmd = command_stack.pop() + cmd.undo() + view.notify("player_moved", lab) + print("\n Отмена последнего хода") + else: + print("\n Нечего отменять") + else: + print("\n Неизвестная команда. Используйте h,j,k,l, u, b, d, a, q") + + print("\n Игра окончена. Спасибо!") \ No newline at end of file diff --git a/lukovnikovde/docs/data/2-nd-exercise/maze/experiment_results.csv b/lukovnikovde/docs/data/2-nd-exercise/maze/experiment_results.csv new file mode 100644 index 0000000..00ec969 --- /dev/null +++ b/lukovnikovde/docs/data/2-nd-exercise/maze/experiment_results.csv @@ -0,0 +1,16 @@ +maze,algo,time_ms,visited,length +Small 10x6,BFS,0.03532833337279347,11.0,8.0 +Small 10x6,DFS,0.019208666647803813,9.0,8.0 +Small 10x6,AStar,0.04686633352927553,11.0,8.0 +Medium 10x10,BFS,0.05395633343141526,28.0,16.0 +Medium 10x10,DFS,0.038764333718669754,23.0,18.0 +Medium 10x10,AStar,0.07918899973446969,21.0,16.0 +Large 20x20,BFS,0.3642953330806146,183.0,35.0 +Large 20x20,DFS,0.2671169998696617,194.0,103.0 +Large 20x20,AStar,0.45344133347195265,104.0,35.0 +Empty 15x15,BFS,0.028481000299507286,16.0,16.0 +Empty 15x15,DFS,0.028324666648889735,16.0,16.0 +Empty 15x15,AStar,0.050569666503482345,16.0,16.0 +No exit 10x10,BFS,0.05937366677244427,12.0,0.0 +No exit 10x10,DFS,0.0502500000341873,12.0,0.0 +No exit 10x10,AStar,0.09478233338692614,12.0,0.0 diff --git a/lukovnikovde/docs/data/2-nd-exercise/maze/maze1.txt b/lukovnikovde/docs/data/2-nd-exercise/maze/maze1.txt new file mode 100644 index 0000000..e4c7e62 --- /dev/null +++ b/lukovnikovde/docs/data/2-nd-exercise/maze/maze1.txt @@ -0,0 +1,5 @@ +####### +#S # +# ### # +# #E # +####### \ No newline at end of file diff --git a/lukovnikovde/docs/data/2-nd-exercise/maze/maze10x10.txt b/lukovnikovde/docs/data/2-nd-exercise/maze/maze10x10.txt new file mode 100644 index 0000000..2528111 --- /dev/null +++ b/lukovnikovde/docs/data/2-nd-exercise/maze/maze10x10.txt @@ -0,0 +1,9 @@ +########## +#S # +# # #### # +# # # +#### # ## +# # # +# #### # # +# #E# +########## \ No newline at end of file diff --git a/lukovnikovde/docs/data/2-nd-exercise/maze/maze20x20.txt b/lukovnikovde/docs/data/2-nd-exercise/maze/maze20x20.txt new file mode 100644 index 0000000..62e84ea --- /dev/null +++ b/lukovnikovde/docs/data/2-nd-exercise/maze/maze20x20.txt @@ -0,0 +1,20 @@ +#################### +#S # +# # #### # +# # # # +#### # # ## +# ## ## ## +# ######## ## ## +# # +############## # +# ## ### # +# # +# # # # +# # # +# ##### # +# # +# ## ## # # +# # # # +# #### # # # # +# # # #E# +#################### \ No newline at end of file diff --git a/lukovnikovde/docs/data/2-nd-exercise/maze/maze_empty.txt b/lukovnikovde/docs/data/2-nd-exercise/maze/maze_empty.txt new file mode 100644 index 0000000..de8cf79 --- /dev/null +++ b/lukovnikovde/docs/data/2-nd-exercise/maze/maze_empty.txt @@ -0,0 +1,16 @@ +S + + + + + + + + + + + + + + +E \ No newline at end of file diff --git a/lukovnikovde/docs/data/2-nd-exercise/maze/maze_no_exit.txt b/lukovnikovde/docs/data/2-nd-exercise/maze/maze_no_exit.txt new file mode 100644 index 0000000..d46ffa3 --- /dev/null +++ b/lukovnikovde/docs/data/2-nd-exercise/maze/maze_no_exit.txt @@ -0,0 +1,11 @@ +########## +#S # # +# # # +# # # +# # # +########## +# # # +# # # +# # # +# # E# +########## \ No newline at end of file diff --git a/lukovnikovde/docs/data/2-nd-exercise/maze/performance_comparison.png b/lukovnikovde/docs/data/2-nd-exercise/maze/performance_comparison.png new file mode 100644 index 0000000..f6ee0d6 Binary files /dev/null and b/lukovnikovde/docs/data/2-nd-exercise/maze/performance_comparison.png differ diff --git a/lukovnikovde/docs/performance_comparison.png b/lukovnikovde/docs/performance_comparison.png new file mode 100644 index 0000000..f6ee0d6 Binary files /dev/null and b/lukovnikovde/docs/performance_comparison.png differ diff --git a/lukovnikovde/docs/report_lab_1.md b/lukovnikovde/docs/report_lab_1.md new file mode 100644 index 0000000..335398c --- /dev/null +++ b/lukovnikovde/docs/report_lab_1.md @@ -0,0 +1,52 @@ +# Отчет по лабораторной работе "Структуры данных" +## 1. Введение +В ходе выполнения лабораторной работы были выполнены реализации трех структур для хранения и обработки данных телефонных номеров: +- Связный список +- Хеш-таблица +- Двоичное дерево поиска. + +Практическая часть включала в себя такие операции как: добавление или обновление телефонного номера, удаление телефонного номера, поиск владельца телефонного номера и составление списка из кортежей вида (владелец, номер). Каждое выполнение функций проводилось с списоком из кортежей вида (владелецб номер), в котором было 1000 уникальных имен и еще 9000 имен, которые уже были использованны (всего 10000 кортежей). Каждое тестирование структур выполнялось для сортированного и не сортированного начального списка 10 раз. +## 2. Результаты измерений +Данные в таблице отражают среднее время в милисекундах выполнения структур. +| Структура | Начальный список | insert, мс | find, мс | delete, мс | create list, мс | +| :---: | :---: | ---: | ---: | ---: | ---: | +| LinkedList | not sorted | 165.61 | 1.767 | 3.418 | 31.795 | +| LinkedList | sorted | 171.01 | 1.720 | 3.440 | 21.378 | +| HashTable | not sorted | 17.15 | 0.278 | 0.320 | 48.080 | +| HashTable | sorted | 17.49 | 0.284 | 0.321 | 47.911 | +| BST | not sorted | 52.95 | 0.772 | 0.660 | 0.283 | +| BST | sorted | 162.70 | 1.809 | 1.564 | 1.626 | + +Изходя из полученных значений можно построить столбчатую диаграмму: + +![](data/time_schedule.png) +## 3. Анализ полученных данных +### 3.1 Зависимость скорости работы BST от порядка ввода данных. +Из полученных данных можно заметить, что для BST порядок ввода сильно сказывается на результате скорости выполнения программы: при послутплении неотсортированных данных программа справляется примерно в 3 раза быстрее. Связано это с тем, что каждое новое значение, при сортированных данных, будет больше предыдущего, а соответственно будет каждый раз создаватся правый лист, из-за чего высота дерева становится равной количесвту всех уникальных имен, вседствии чего сложность возрастает до О(n), а двоичное дерево превращается в своебразный связный список. + +### 3.2 Независимость скорости выполнения заполнения хеш-таблицы от порядка вводных данных +Из эксперемента можно заметить, что скорость заполнения хеш-таблицы сортированными и несортированными данными почти одинакова(разница менее 2%). Это объясняется наличием бакетов, которые разбивают все данные на N списков (В данной лабораторной работе N = 100) и не зависмо от способа подачи данных мы всегда получим N списков с одинаков наполнением. +Скорость выполнения вставки почти одинакова, так как и для случая сортированного и несортированного начального списка необходимо только определить нужный бакет и добавить в этот бакет кортеж (владелец, номер), то есть сложность операции О(1), что отражают результаты эксперемента. +Скорость выполнения поиска/удаления/составление списка почти одинаковы по тем же причинам: из-за наличия бакетов отрезаем часть лишних данных и уже работаем с оставшимеся, что значительно уменьшает время, а так как длина списока в бакете будет гораздо меньше длины списка исходных данных, что линейная сложность при переборе этого списка не сильно повлияет на время выполнения программы. + +### 3.3 Медленность посика связного списка +Чтобы найти нужный элемент в связном списке необходимо перебрать все элементы стоящие до него, и если элемент находится где-то в конце такого списка, то придется перебрать почти все значения, на что уйдет явно больше премени чем при применениеи хеш-таблицы, которая отсекает большую часть ненужных данных, или двоичного дерева, которое составлено так, что не нужно будет перебирать все значения. + +### 3.4 Принципы работы Удаления +### - Связный список: +В связном списке необходимо найти нужный словарь, значение ключа next содержит искомое имя. После этого мы меняем значение ключа next этого словаря на то, которое стоит в значении ключа next словаря, который мы собираемся удалить. Если мы хотим удалить запись, которой не существует, в таком случае перебираем весь связный спискок полностью и в случае ненахождения нужной записи возвращаем исходный список. + +### - Хеш-таблица: +В начале ищем номер нужного бакета, и начинаем искать в бакете необходую запись: перебираем список кортежей, пока не найдем нужную запись. Если запись нашлась, то удалем ее и списка, если нет, то возвращаем исходные данные без изменений + +### - Двоичное дерево посика: +Сначала ищем узел, который необходимо удалить, а затем действуем в зависимости от ситуации: +- 1 У узла нет потомков: + В такой ситуации просто удаляем наш узел(в данном случае лист) +- 2 У узла нет потомков справа или слева: + Если у узла есть только правые потомки, то на место этого узела помещаем узел, который расположен справа. Аналогично для случая с наличием левых потомков. +- 3 Если у узла есть и правые и левые потомки: + Находим самый маленький узел в правом поддереве этого узла, то есть идем сначала вправо от узла, а потом только влево, пока не дойдем до значения None. + Копируем значения этого наименьшего и подставляем эти данные в узел, который хотим удалить, не меняя значения под ключами left и right, а затем удаляем этот наименьший как описано в пунктах (1) и (2), так как этот узел или будет иметь только потомков вправа или не иметь их вообще + +## Вывод: в ходе выполнения лабораторной были изучены 3 способа хранения и обработки данных. Из данных полученных из эксперементов можно выделить наилучшие способы применения этих структур. Если в программе необходимо часто пополнять данные, корректировать, искать и удалять их, то лучше всего подойдет хеш-таблица. Если необходимо часто собирать все данные в один сортированный список и исходные данные несортированные, то хеш-таблица будет тормозить, в этом случае лучше использовать двоичное дерего поиска, хоть они и показывают более худший результат в добавлении, посике и удалении(примерно в 2.5-3 раза), но формируют список они моментально: 0.283 мс. Если же исходные данные отсортированны и необходимо выполнять все те же операции но без удаления, то в таком случае наиболее эффективным будет связный список. \ No newline at end of file diff --git a/lukovnikovde/docs/report_lab_2.md b/lukovnikovde/docs/report_lab_2.md new file mode 100644 index 0000000..81c3741 --- /dev/null +++ b/lukovnikovde/docs/report_lab_2.md @@ -0,0 +1,79 @@ +# Отчёт по лабораторной работе: Поиск пути в лабиринте + +## 1. Цель работы + +Разработать программу для загрузки лабиринта из текстового файла, поиска пути от старта до выхода с использованием алгоритмов BFS, DFS, A*, сбора статистики (время, посещённые клетки, длина пути) и проведения экспериментального сравнения. + +## 2. Архитектура и использованные паттерны + +- **Builder** (`TextLabyrinthLoader`) – создание лабиринта из файла. +- **Strategy** (`BFS`, `DFS`, `AStar`) – взаимозаменяемые алгоритмы поиска. +- **Observer** (`ConsoleRenderer`) – визуализация событий. +- **Command** (`MoveAction`) – отмена ходов игрока. + +Программа поддерживает интерактивный режим (движение, автопоиск) и режим экспериментов (`python main.py experiment`). + +## 3. Тестовые лабиринты + +| Имя файла | Описание | +|-----------|----------| +| `maze1.txt` | Простой лабиринт 10×6 | +| `maze10x10.txt` | Лабиринт среднего размера 10×10 | +| `maze20x20.txt` | Большой лабиринт 20×20 | +| `maze_empty.txt` | Пустое поле 15×15 (без стен) | +| `maze_no_exit.txt` | Лабиринт без достижимого выхода | + +## 4. Результаты экспериментов + +Каждый алгоритм запускался 3 раза на каждом лабиринте, приведены средние значения. + +| Лабиринт | Алгоритм | Время (мс) | Посещено клеток | Длина пути | +|---------------|----------|------------|-----------------|------------| +| Small 10x6 | BFS | 0.035 | 11.0 | 8 | +| Small 10x6 | DFS | 0.019 | 9.0 | 8 | +| Small 10x6 | A* | 0.047 | 11.0 | 8 | +| Medium 10x10 | BFS | 0.054 | 28.0 | 16 | +| Medium 10x10 | DFS | 0.039 | 23.0 | 18 | +| Medium 10x10 | A* | 0.079 | 21.0 | 16 | +| Large 20x20 | BFS | 0.364 | 183.0 | 35 | +| Large 20x20 | DFS | 0.267 | 194.0 | 103 | +| Large 20x20 | A* | 0.453 | 104.0 | 35 | +| Empty 15x15 | BFS | 0.028 | 16.0 | 16 | +| Empty 15x15 | DFS | 0.028 | 16.0 | 16 | +| Empty 15x15 | A* | 0.051 | 16.0 | 16 | +| No exit 10x10 | BFS | 0.059 | 12.0 | 0 | +| No exit 10x10 | DFS | 0.050 | 12.0 | 0 | +| No exit 10x10 | A* | 0.095 | 12.0 | 0 | + +## 5. График сравнения + +![Сравнение алгоритмов](performance_comparison.png) + +## 6. Проверка соответствия ТЗ + +| Требование | Выполнение | +|------------|------------| +| Загрузка лабиринта из текстового файла (# стена, S старт, E выход) | ok | +| Реализация BFS | ok | +| Реализация DFS | ok | +| Реализация A* | ok | +| Сбор статистики (время, посещённые клетки, длина пути) | ok | +| Сравнительный эксперимент на лабиринтах разной сложности | ok | +| Визуализация результатов (график) | ok | +| Интерактивный режим с отменой ходов | ok | + +## 7. Выводы + +- **BFS** всегда находит кратчайший путь, но на сложных лабиринтах посещает больше клеток, чем A*. +- **DFS** самый быстрый по времени, однако в запутанных лабиринтах даёт неоптимальный путь. +- **A*** показывает лучший баланс: оптимальный путь и наименьшее число посещённых клеток. +- При отсутствии пути все алгоритмы корректно возвращают длину 0. + +**Рекомендация:** для сложных лабиринтов предпочтительнее A*. + +--- + +*Файлы результатов: `experiment_results.csv`, `performance_comparison.png`.* + + +I USE ARCH SAME WITH ME FRIEND IVAN BTW \ No newline at end of file