Merge pull request '[2] 2-nd-exercise FINAL FINAL' (#329) from lukovnikovde/2026-rff_mp:2-nd-exercise into develop
Reviewed-on: #329
This commit is contained in:
commit
cebf01f0d8
0
lukovnikovde/428.md
Normal file
0
lukovnikovde/428.md
Normal file
507
lukovnikovde/docs/data/1-st-exercise/DataStructure.py
Normal file
507
lukovnikovde/docs/data/1-st-exercise/DataStructure.py
Normal file
|
|
@ -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()
|
||||
|
||||
|
||||
|
||||
|
||||
241
lukovnikovde/docs/data/1-st-exercise/resalts.csv
Normal file
241
lukovnikovde/docs/data/1-st-exercise/resalts.csv
Normal file
|
|
@ -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
|
||||
|
BIN
lukovnikovde/docs/data/1-st-exercise/time_schedule.png
Normal file
BIN
lukovnikovde/docs/data/1-st-exercise/time_schedule.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 36 KiB |
527
lukovnikovde/docs/data/2-nd-exercise/main.py
Normal file
527
lukovnikovde/docs/data/2-nd-exercise/main.py
Normal file
|
|
@ -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 Игра окончена. Спасибо!")
|
||||
|
|
@ -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
|
||||
|
5
lukovnikovde/docs/data/2-nd-exercise/maze/maze1.txt
Normal file
5
lukovnikovde/docs/data/2-nd-exercise/maze/maze1.txt
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
#######
|
||||
#S #
|
||||
# ### #
|
||||
# #E #
|
||||
#######
|
||||
9
lukovnikovde/docs/data/2-nd-exercise/maze/maze10x10.txt
Normal file
9
lukovnikovde/docs/data/2-nd-exercise/maze/maze10x10.txt
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
##########
|
||||
#S #
|
||||
# # #### #
|
||||
# # #
|
||||
#### # ##
|
||||
# # #
|
||||
# #### # #
|
||||
# #E#
|
||||
##########
|
||||
20
lukovnikovde/docs/data/2-nd-exercise/maze/maze20x20.txt
Normal file
20
lukovnikovde/docs/data/2-nd-exercise/maze/maze20x20.txt
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
####################
|
||||
#S #
|
||||
# # #### #
|
||||
# # # #
|
||||
#### # # ##
|
||||
# ## ## ##
|
||||
# ######## ## ##
|
||||
# #
|
||||
############## #
|
||||
# ## ### #
|
||||
# #
|
||||
# # # #
|
||||
# # #
|
||||
# ##### #
|
||||
# #
|
||||
# ## ## # #
|
||||
# # # #
|
||||
# #### # # # #
|
||||
# # # #E#
|
||||
####################
|
||||
16
lukovnikovde/docs/data/2-nd-exercise/maze/maze_empty.txt
Normal file
16
lukovnikovde/docs/data/2-nd-exercise/maze/maze_empty.txt
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
S
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
E
|
||||
11
lukovnikovde/docs/data/2-nd-exercise/maze/maze_no_exit.txt
Normal file
11
lukovnikovde/docs/data/2-nd-exercise/maze/maze_no_exit.txt
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
##########
|
||||
#S # #
|
||||
# # #
|
||||
# # #
|
||||
# # #
|
||||
##########
|
||||
# # #
|
||||
# # #
|
||||
# # #
|
||||
# # E#
|
||||
##########
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 82 KiB |
BIN
lukovnikovde/docs/performance_comparison.png
Normal file
BIN
lukovnikovde/docs/performance_comparison.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 82 KiB |
52
lukovnikovde/docs/report_lab_1.md
Normal file
52
lukovnikovde/docs/report_lab_1.md
Normal file
|
|
@ -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 |
|
||||
|
||||
Изходя из полученных значений можно построить столбчатую диаграмму:
|
||||
|
||||
|
||||
## 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 мс. Если же исходные данные отсортированны и необходимо выполнять все те же операции но без удаления, то в таком случае наиболее эффективным будет связный список.
|
||||
79
lukovnikovde/docs/report_lab_2.md
Normal file
79
lukovnikovde/docs/report_lab_2.md
Normal file
|
|
@ -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. График сравнения
|
||||
|
||||
|
||||
|
||||
## 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
|
||||
Loading…
Reference in New Issue
Block a user