Compare commits
7 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| ce2b43a84e | |||
| 3f9c9f0ca8 | |||
| 3714c824e7 | |||
| 033419ac3f | |||
| dec46dcc0a | |||
| 87fa0e9c66 | |||
| db1243ce91 |
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -7,7 +7,6 @@ __pycache__/
|
|||
# C extensions
|
||||
*.so
|
||||
|
||||
.DS_Store
|
||||
# Distribution / packaging
|
||||
.Python
|
||||
build/
|
||||
|
|
|
|||
|
|
@ -1,457 +0,0 @@
|
|||
head = None
|
||||
|
||||
#node1 = {'name' : 'Ivan', 'phone' : '123-456', 'next' : None}
|
||||
#head = node1
|
||||
|
||||
#node2 = {'name' : 'Dima', 'phone' : '789-123', 'next' : None}
|
||||
#node1['next'] = node2
|
||||
|
||||
def ll_insert(head, name, phone):
|
||||
|
||||
curent = head
|
||||
while curent is not None:
|
||||
if curent['name'] == name:
|
||||
curent['phone'] = phone
|
||||
return head
|
||||
curent = curent['next']
|
||||
|
||||
|
||||
n_node = {'name' : name, 'phone' : phone, 'next' : None}
|
||||
|
||||
if head is None:
|
||||
return n_node
|
||||
|
||||
curent = head
|
||||
while curent['next'] is not None:
|
||||
curent = curent['next']
|
||||
curent['next'] = n_node
|
||||
return head
|
||||
|
||||
|
||||
|
||||
print("====== TESTING ll_insert FUNC ========")
|
||||
head = ll_insert(head,'Ivan','123-456')
|
||||
|
||||
print(head)
|
||||
|
||||
head = ll_insert(head, 'Boris', '123-456')
|
||||
|
||||
print(head)
|
||||
|
||||
head = ll_insert(head, 'Ivan', '321-654')
|
||||
|
||||
print(head)
|
||||
|
||||
head = ll_insert(head, 'Dima', '345-678')
|
||||
|
||||
print(head)
|
||||
|
||||
head = ll_insert(head, 'Boris', '111-222')
|
||||
|
||||
print(head)
|
||||
|
||||
head = ll_insert(head, 'Methody', '221-112')
|
||||
|
||||
head = ll_insert(head, 'Kiril', '112-221')
|
||||
|
||||
print(f"======= END TEST =======\n\n\n")
|
||||
|
||||
|
||||
def ll_find(head, name):
|
||||
curent = head
|
||||
while curent is not None:
|
||||
if curent['name'] == name:
|
||||
return curent['phone']
|
||||
curent = curent['next']
|
||||
return None
|
||||
|
||||
print("====== TESTING ll_find FUNC ======")
|
||||
|
||||
print("Ivan`s phone: "+ ll_find(head, 'Ivan'))
|
||||
|
||||
print("Dima`s phone: "+ ll_find(head, 'Dima'))
|
||||
|
||||
print("Boris phone: "+ ll_find(head, 'Boris'))
|
||||
|
||||
print(f"====== END TEST ======\n\n\n")
|
||||
|
||||
|
||||
def ll_delete(head, name):
|
||||
if head is None:
|
||||
return None
|
||||
|
||||
if head['name'] == name:
|
||||
return head['next']
|
||||
|
||||
prev = head
|
||||
curent = head['next']
|
||||
while curent is not None:
|
||||
if curent['name'] == name:
|
||||
prev['next'] = curent['next']
|
||||
return head
|
||||
prev = curent
|
||||
curent = curent['next']
|
||||
return head
|
||||
|
||||
|
||||
print("====== TEST ll_delete FUNC ======")
|
||||
|
||||
print("Del of Dima:", ll_delete(head, 'Dima'))
|
||||
|
||||
print("====== END TEST ======")
|
||||
|
||||
|
||||
def ll_list_all(head):
|
||||
records = []
|
||||
curent = head
|
||||
while curent is not None:
|
||||
records.append((curent['name'],curent['phone']))
|
||||
curent = curent['next']
|
||||
records.sort(key=lambda pair: pair[0])
|
||||
return records
|
||||
|
||||
print(f"\n\n\n\n")
|
||||
|
||||
print("====== TESTING ll_list_all FUNC ======")
|
||||
|
||||
print(ll_list_all(head))
|
||||
|
||||
print("====== END ======")
|
||||
|
||||
|
||||
#============================== HASH FUNCTIONS =========================
|
||||
SIZE = 5
|
||||
buckets = [None] * SIZE
|
||||
|
||||
|
||||
|
||||
def hash_function(name, size):
|
||||
return hash(name) % size
|
||||
|
||||
|
||||
def ht_insert(buckets, name, phone):
|
||||
index = hash_function(name, len(buckets))
|
||||
head = buckets[index]
|
||||
new_head = ll_insert(head, name, phone)
|
||||
buckets[index] = new_head
|
||||
return buckets
|
||||
|
||||
print(f"\n\n\n ====== TEST INSERT HASH ======")
|
||||
print(buckets)
|
||||
ht_insert(buckets, "Ivan", "123-456")
|
||||
print(buckets)
|
||||
ht_insert(buckets, "Dima", "789-123")
|
||||
print(buckets)
|
||||
ht_insert(buckets, "Boris", "456-789")
|
||||
print(buckets)
|
||||
print("====== END TEST ======\n\n\n")
|
||||
|
||||
|
||||
def ht_find(buckets, name):
|
||||
index = hash_function(name, len(buckets))
|
||||
head = buckets[index]
|
||||
return ll_find(head, name)
|
||||
|
||||
print("====== TEST FIND HASH FUN ======")
|
||||
print("find by name Ivan: ",ht_find(buckets, "Ivan"))
|
||||
print("find by name Dima: ",ht_find(buckets, "Dima"))
|
||||
print("find by name Boris: ", ht_find(buckets, "Boris"))
|
||||
print("====== END TEST ======\n\n\n")
|
||||
|
||||
def ht_list_all(buckets):
|
||||
all_records = []
|
||||
for head in buckets:
|
||||
current = head
|
||||
while current is not None:
|
||||
all_records.append((current['name'], current['phone']))
|
||||
current = current['next']
|
||||
all_records.sort(key=lambda x: x[0])
|
||||
return all_records
|
||||
|
||||
|
||||
print("====== TEST FUNC LIST ALL ======")
|
||||
print(ht_list_all(buckets))
|
||||
print("====== END TEST ======\n\n\n")
|
||||
|
||||
def ht_delete(buckets, name):
|
||||
index = hash_function(name, len(buckets))
|
||||
head = buckets[index]
|
||||
new_head = ll_delete(head, name)
|
||||
buckets[index] = new_head
|
||||
return buckets
|
||||
|
||||
|
||||
print("====== GLOBAL TEST FOR HASH BASED FUN ======")
|
||||
buckets = [None] * 10
|
||||
|
||||
ht_insert(buckets, "Ivan", "123-456")
|
||||
print(buckets)
|
||||
ht_insert(buckets, "Boris", "789-012")
|
||||
print(buckets)
|
||||
ht_insert(buckets, "Anna", "345-678")
|
||||
print(buckets)
|
||||
ht_insert(buckets, "Ivan", "111-222") # update
|
||||
print(buckets)
|
||||
|
||||
print("Find Ivan`s phone: ",ht_find(buckets, "Ivan")) # 111-222
|
||||
print("Find Petr`s phone: ",ht_find(buckets, "Petr")) # None
|
||||
|
||||
# Удаляем
|
||||
print("delite Boris from buckets")
|
||||
ht_delete(buckets, "Boris")
|
||||
print("search Boris = ",ht_find(buckets, "Boris")) # None
|
||||
|
||||
# Все записи
|
||||
print("list all records: ",ht_list_all(buckets))
|
||||
print("====== END GLOBAL TEST ======\n\n\n")
|
||||
|
||||
|
||||
|
||||
# ======================== TREE FUNC ====================
|
||||
|
||||
def create_node(name,phone):
|
||||
return {'name': name, 'phone': phone, 'left': None, 'right': None}
|
||||
|
||||
print("====== START TREE FUNC CHAPTER ======\n\n")
|
||||
print("====== TEST CREATE NODE FUNC ======")
|
||||
root = create_node('Ivan', '123-456')
|
||||
print("Create Ivan node: ",root)
|
||||
print("====== END TEST ====== \n\n\n")
|
||||
|
||||
def bst_insert(root, name, phone):
|
||||
if root is None:
|
||||
return create_node(name, phone)
|
||||
|
||||
if name == root['name']:
|
||||
root['phone'] = phone
|
||||
elif name < root['name']:
|
||||
root['left'] = bst_insert(root['left'], name, phone)
|
||||
else:
|
||||
root['right'] = bst_insert(root['right'], name , phone)
|
||||
return root
|
||||
|
||||
print("====== TEST INSERT FUNC ======")
|
||||
root = bst_insert(root, 'Dima', '456-789')
|
||||
print("add Dima: ", root)
|
||||
root = bst_insert(root, 'Boris', '789-123')
|
||||
print("add Boris: ", root)
|
||||
root = bst_insert(root, 'Eva', '321-123')
|
||||
print("add Eva: ", root)
|
||||
print("====== END TEST =======\n\n\n")
|
||||
|
||||
|
||||
def bst_find(root, name):
|
||||
if root is None:
|
||||
return None
|
||||
if name == root['name']:
|
||||
return root['phone']
|
||||
elif name<root['name']:
|
||||
return bst_find(root['left'], name)
|
||||
else:
|
||||
return bst_find(root['right'], name)
|
||||
|
||||
|
||||
print("====== START FIND TEST ======")
|
||||
print("search by Ivan`s phone: ", bst_find(root, 'Ivan'))
|
||||
print("search by Eva`s phone: ", bst_find(root,'Eva'))
|
||||
print("====== END TEST ====== \n\n\n")
|
||||
|
||||
|
||||
|
||||
def find_min(node):
|
||||
while node['left'] is not None:
|
||||
node = node['left']
|
||||
return node
|
||||
|
||||
|
||||
def bst_delete(root,name):
|
||||
if root is None:
|
||||
return None
|
||||
|
||||
if name< root['name']:
|
||||
root['left'] = bst_delete(root['left'], name)
|
||||
elif name > root['name']:
|
||||
root['right'] = bst_delete(root['right'], name)
|
||||
|
||||
else:
|
||||
if root['left'] is None:
|
||||
return root['right']
|
||||
if root['right'] is None:
|
||||
return root['left']
|
||||
|
||||
min_node = find_min(root['right'])
|
||||
root['name'] = min_node['name']
|
||||
root['phone'] = min_node['phone']
|
||||
|
||||
root['right'] = bst_delete(root['right'], min_node['name'])
|
||||
return root
|
||||
|
||||
|
||||
|
||||
def bst_list_all(root):
|
||||
result = []
|
||||
def inorder(node):
|
||||
if node is None:
|
||||
return
|
||||
inorder(node['left'])
|
||||
result.append((node['name'], node['phone']))
|
||||
inorder(node['right'])
|
||||
inorder(root)
|
||||
return result
|
||||
|
||||
|
||||
print("====== GLOBAL TEST TREES ======")
|
||||
root = None
|
||||
|
||||
root = bst_insert(root, "Ivan", "123-456")
|
||||
print("add Ivan: ", root)
|
||||
root = bst_insert(root, "Boris", "789-012")
|
||||
print("add Boris: ", root)
|
||||
root = bst_insert(root, "Anna", "345-678")
|
||||
print("add Anna: ", root)
|
||||
root = bst_insert(root, "Ivan", "111-222") # обновление
|
||||
print("update Ivan: ", root)
|
||||
|
||||
print("Find Ivan`s phone: ",bst_find(root, "Ivan")) # 111-222
|
||||
print("Find Peter`s phone: ",bst_find(root, "Petr")) # None
|
||||
|
||||
root = bst_delete(root, "Boris")
|
||||
print("Del Boris")
|
||||
print("Find Boris: ",bst_find(root, "Boris")) # None
|
||||
|
||||
print("Find ALL: ",bst_list_all(root)) # [('Anna','345-678'), ('Ivan','111-222')]
|
||||
|
||||
|
||||
print("====== END TEST ======")
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# ======================== EXPEREMENT CHAPTER ========================
|
||||
import random
|
||||
import time
|
||||
import csv
|
||||
import sys
|
||||
sys.setrecursionlimit(20000)
|
||||
|
||||
def generate_records(n, seed=42):
|
||||
random.seed(seed)
|
||||
records = []
|
||||
for i in range(1, n+1):
|
||||
name = f"User_{i:05d}"
|
||||
phone = f"{random.randint(100,999)}-{random.randint(1000,9999)}"
|
||||
records.append((name, phone))
|
||||
return records
|
||||
|
||||
def prepare_datasets(base_records):
|
||||
shuffled = base_records.copy()
|
||||
random.shuffle(shuffled)
|
||||
sorted_records = sorted(base_records, key=lambda x: x[0])
|
||||
return shuffled, sorted_records
|
||||
|
||||
def run_experiment(struct_funcs, records, mode_name, repeats=5):
|
||||
results = []
|
||||
for rep in range(repeats):
|
||||
struct = struct_funcs['create']()
|
||||
|
||||
# enter all records
|
||||
start = time.perf_counter()
|
||||
for name, phone in records:
|
||||
struct = struct_funcs['insert'](struct, name, phone)
|
||||
end = time.perf_counter()
|
||||
insert_time = end - start
|
||||
|
||||
# search for 110 records (100 real + 10 None)
|
||||
existing_names = [name for name, _ in records]
|
||||
sample_existing = random.sample(existing_names, 100)
|
||||
nonexistent = [f"None_{i}" for i in range(10)]
|
||||
search_names = sample_existing + nonexistent
|
||||
random.shuffle(search_names)
|
||||
|
||||
start = time.perf_counter()
|
||||
for name in search_names:
|
||||
_ = struct_funcs['find'](struct, name)
|
||||
end = time.perf_counter()
|
||||
find_time = end - start
|
||||
|
||||
# delete 10 random records
|
||||
to_delete = random.sample(existing_names, 10)
|
||||
start = time.perf_counter()
|
||||
for name in to_delete:
|
||||
struct = struct_funcs['delete'](struct, name)
|
||||
end = time.perf_counter()
|
||||
delete_time = end - start
|
||||
|
||||
results.append({
|
||||
'structure': struct_funcs['name'],
|
||||
'mode': mode_name,
|
||||
'repetition': rep+1,
|
||||
'insert_time': insert_time,
|
||||
'find_time': find_time,
|
||||
'delete_time': delete_time
|
||||
})
|
||||
return results
|
||||
|
||||
def main():
|
||||
N = 1000
|
||||
base_records = generate_records(N)
|
||||
shuffled, sorted_records = prepare_datasets(base_records)
|
||||
|
||||
structures = {
|
||||
'LinkedList': {
|
||||
'name': 'LinkedList',
|
||||
'create': lambda: None,
|
||||
'insert': ll_insert,
|
||||
'find': ll_find,
|
||||
'delete': ll_delete,
|
||||
'list_all': ll_list_all
|
||||
},
|
||||
'HashTable': {
|
||||
'name': 'HashTable',
|
||||
'create': lambda: [None] * 10,
|
||||
'insert': ht_insert,
|
||||
'find': ht_find,
|
||||
'delete': ht_delete,
|
||||
'list_all': ht_list_all
|
||||
},
|
||||
'BST': {
|
||||
'name': 'BST',
|
||||
'create': lambda: None,
|
||||
'insert': bst_insert,
|
||||
'find': bst_find,
|
||||
'delete': bst_delete,
|
||||
'list_all': bst_list_all
|
||||
}
|
||||
}
|
||||
|
||||
all_results = []
|
||||
repeats = 5
|
||||
|
||||
for struct_name, funcs in structures.items():
|
||||
print(f"Testing {struct_name} on random order...")
|
||||
res = run_experiment(funcs, shuffled, 'random', repeats)
|
||||
all_results.extend(res)
|
||||
|
||||
print(f"Testing {struct_name} in sorted order...")
|
||||
res = run_experiment(funcs, sorted_records, 'sorted', repeats)
|
||||
all_results.extend(res)
|
||||
|
||||
with open('experiment_results.csv', 'w', newline='', encoding='utf-8') as f:
|
||||
writer = csv.writer(f)
|
||||
writer.writerow(['Structure', 'Mode', 'Repeat', 'Insert (sec)', 'Search (sec)', 'Delete (sec)'])
|
||||
for r in all_results:
|
||||
writer.writerow([
|
||||
r['structure'],
|
||||
r['mode'],
|
||||
r['repetition'],
|
||||
f"{r['insert_time']:.6f}",
|
||||
f"{r['find_time']:.6f}",
|
||||
f"{r['delete_time']:.6f}"
|
||||
])
|
||||
|
||||
print("The experiment is complete. The results are saved in experiment_results.csv.")
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
Structure,Mode,Repeat,Insert (sec),Search (sec),Delete (sec)
|
||||
LinkedList,random,1,0.140358,0.007040,0.000844
|
||||
LinkedList,random,2,0.138009,0.009197,0.000413
|
||||
LinkedList,random,3,0.114717,0.009266,0.000744
|
||||
LinkedList,random,4,0.117224,0.006914,0.000531
|
||||
LinkedList,random,5,0.136302,0.010432,0.000582
|
||||
LinkedList,sorted,1,0.106921,0.007845,0.000566
|
||||
LinkedList,sorted,2,0.116404,0.015005,0.004900
|
||||
LinkedList,sorted,3,0.125122,0.006956,0.000708
|
||||
LinkedList,sorted,4,0.122401,0.004220,0.000474
|
||||
LinkedList,sorted,5,0.111422,0.008343,0.000551
|
||||
HashTable,random,1,0.025442,0.004652,0.000078
|
||||
HashTable,random,2,0.035477,0.000985,0.000091
|
||||
HashTable,random,3,0.015387,0.001249,0.000298
|
||||
HashTable,random,4,0.014196,0.001167,0.000096
|
||||
HashTable,random,5,0.013819,0.000910,0.000094
|
||||
HashTable,sorted,1,0.013713,0.000897,0.000060
|
||||
HashTable,sorted,2,0.016816,0.001013,0.000116
|
||||
HashTable,sorted,3,0.018408,0.001019,0.000084
|
||||
HashTable,sorted,4,0.014490,0.000886,0.000093
|
||||
HashTable,sorted,5,0.012493,0.000867,0.000075
|
||||
BST,random,1,0.006755,0.000468,0.000065
|
||||
BST,random,2,0.006454,0.000380,0.000052
|
||||
BST,random,3,0.003348,0.000266,0.000033
|
||||
BST,random,4,0.004785,0.000379,0.000053
|
||||
BST,random,5,0.005253,0.000438,0.000083
|
||||
BST,sorted,1,0.331066,0.028260,0.002915
|
||||
BST,sorted,2,0.342009,0.025769,0.003155
|
||||
BST,sorted,3,0.282425,0.031293,0.002984
|
||||
BST,sorted,4,0.313816,0.022712,0.002957
|
||||
BST,sorted,5,0.287008,0.032645,0.002415
|
||||
|
|
|
@ -1,44 +0,0 @@
|
|||
import pandas as pd
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
|
||||
# Загрузка данных
|
||||
df = pd.read_csv('experiment_results.csv')
|
||||
|
||||
# Усреднение по повторам
|
||||
mean_times = df.groupby(['Structure', 'Mode'])[['Insert (sec)', 'Search (sec)', 'Delete (sec)']].mean().reset_index()
|
||||
|
||||
# Подготовка данных для графиков
|
||||
structures = mean_times['Structure'].unique()
|
||||
modes = mean_times['Mode'].unique()
|
||||
|
||||
# Создание трех графиков (вставка, поиск, удаление)
|
||||
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
|
||||
|
||||
operations = ['Insert (sec)', 'Search (sec)', 'Delete (sec)']
|
||||
titles = ['Вставка', 'Поиск', 'Удаление']
|
||||
|
||||
for ax, op, title in zip(axes, operations, titles):
|
||||
# Для каждой структуры строим две колонки (random, sorted)
|
||||
x = np.arange(len(structures))
|
||||
width = 0.35
|
||||
|
||||
random_vals = []
|
||||
sorted_vals = []
|
||||
for s in structures:
|
||||
random_row = mean_times[(mean_times['Structure']==s) & (mean_times['Mode']=='random')]
|
||||
sorted_row = mean_times[(mean_times['Structure']==s) & (mean_times['Mode']=='sorted')]
|
||||
random_vals.append(random_row[op].values[0] if not random_row.empty else 0)
|
||||
sorted_vals.append(sorted_row[op].values[0] if not sorted_row.empty else 0)
|
||||
|
||||
ax.bar(x - width/2, random_vals, width, label='Случайный')
|
||||
ax.bar(x + width/2, sorted_vals, width, label='Отсортированный')
|
||||
ax.set_xticks(x)
|
||||
ax.set_xticklabels(structures)
|
||||
ax.set_ylabel('Время (сек)')
|
||||
ax.set_title(title)
|
||||
ax.legend()
|
||||
|
||||
plt.tight_layout()
|
||||
plt.savefig('../../performance_comparison.png', dpi=150)
|
||||
plt.show()
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 60 KiB |
|
|
@ -1,60 +0,0 @@
|
|||
# Отчёт по лабораторной работе "Структуры данных"
|
||||
|
||||
## 1. Введение
|
||||
В рамках работы были реализованы три структуры данных для хранения телефонного справочника: связный список, хеш-таблица и двоичное дерево поиска. Проведено экспериментальное сравнение производительности операций вставки, поиска и удаления на наборе из **10 000 записей**. Для каждой структуры тестирование выполнялось на двух вариантах входных данных: случайный порядок и отсортированный по имени. Каждый эксперимент повторялся 5 раз, результаты усреднены.
|
||||
|
||||
## 2. Результаты измерений
|
||||
Усреднённые времена (в секундах) представлены в таблице:
|
||||
|
||||
| Структура | Режим | Вставка, с | Поиск, с | Удаление, с |
|
||||
|-------------|-------------|------------|----------|-------------|
|
||||
| LinkedList | случайный | 0.1143 | 0.0078 | 0.00065 |
|
||||
| LinkedList | сортир. | 0.1124 | 0.0068 | 0.00065 |
|
||||
| HashTable | случайный | 0.0131 | 0.00109 | 0.000085 |
|
||||
| HashTable | сортир. | 0.0156 | 0.00110 | 0.00014 |
|
||||
| BST | случайный | 0.00532 | 0.000365 | 0.000053 |
|
||||
| BST | сортир. | 0.303 | 0.0230 | 0.00268 |
|
||||
|
||||
Графическое представление результатов приведено на рисунке ниже.
|
||||
|
||||
|
||||
|
||||
## 3. Анализ результатов
|
||||
|
||||
### 3.1. Влияние порядка данных на BST
|
||||
При вставке элементов в отсортированном порядке двоичное дерево поиска вырождается в линейный список – все новые узлы добавляются только в правое поддерево. Высота дерева становится равной количеству элементов, и сложность всех операций возрастает до **O(n)**. Эксперимент подтверждает это:
|
||||
- Вставка в BST на отсортированных данных заняла **0.303 с**, что в **57 раз** больше, чем на случайных (0.00532 с).
|
||||
- Время вставки на отсортированных данных даже превышает показатели связного списка (0.112 с), что объясняется дополнительными накладными расходами на рекурсивные вызовы.
|
||||
- Поиск и удаление также замедлились примерно в 60 раз по сравнению со случайным режимом.
|
||||
|
||||
### 3.2. Устойчивость хеш-таблицы к порядку
|
||||
Хеш-таблица использует хеш-функцию, которая равномерно распределяет ключи по корзинам независимо от порядка поступления. Поэтому производительность операций практически не зависит от того, в каком порядке приходят данные:
|
||||
- В случайном и отсортированном режимах времена вставки (0.0131 и 0.0156 с) и поиска (около 0.0011 с) близки.
|
||||
- Небольшие колебания могут быть вызваны случайным распределением коллизий.
|
||||
- Это соответствует ожидаемой средней сложности **O(1)**.
|
||||
|
||||
### 3.3. Медлительность связного списка при поиске
|
||||
Связный список не обеспечивает прямого доступа к элементам – для поиска необходимо просматривать узлы последовательно, что даёт сложность **O(n)**. В эксперименте:
|
||||
- Время поиска в списке (~0.007 с) на порядок больше, чем в хеш-таблице (0.0011 с) и BST на случайных данных (0.00037 с).
|
||||
- При увеличении объёма данных эта разница будет только расти.
|
||||
- Вставка в список также относительно медленна (0.11 с), так как требует прохода до конца (хотя обновление существующего имени выполняется быстрее, но в тесте все имена уникальны, поэтому каждая вставка проходит весь список).
|
||||
|
||||
### 3.4. Сравнение удаления
|
||||
- **Связный список**: удаление требует сначала найти элемент (O(n)), затем переставить ссылки (O(1)). Время удаления (0.00065 с) близко ко времени поиска, что логично.
|
||||
- **Хеш-таблица**: удаление выполняется за O(1) в среднем – сначала определяется корзина, затем из короткого списка удаляется элемент. Время удаления (0.000085–0.00014 с) значительно меньше, чем в списке.
|
||||
- **BST**: на случайных данных удаление очень быстрое (0.000053 с) благодаря логарифмической высоте. На отсортированных данных время возрастает до 0.00268 с (в 50 раз), что отражает деградацию до O(n).
|
||||
|
||||
## 4. Выводы и рекомендации по выбору структуры
|
||||
|
||||
На основе полученных результатов можно сформулировать следующие рекомендации:
|
||||
|
||||
- **Хеш-таблица** – оптимальный выбор, если требуется максимальная скорость поиска, вставки и удаления, а порядок хранения не важен. Примеры: реализация словарей, кэшей, индексов по ключу. В эксперименте хеш-таблица показала стабильно высокую производительность во всех режимах.
|
||||
|
||||
- **Двоичное дерево поиска** – следует применять, когда необходимо получать данные в отсортированном порядке (например, вывод телефонного справочника по алфавиту). Однако важно учитывать, что при поступлении отсортированных данных дерево вырождается, и производительность резко падает. В таких случаях лучше использовать сбалансированные деревья (AVL, красно-чёрные). В эксперименте BST на случайных данных показал отличные результаты, близкие к хеш-таблице, а на отсортированных – стал самым медленным.
|
||||
|
||||
- **Связный список** – практически непригоден для больших объёмов данных из-за линейной сложности основных операций. Может использоваться лишь для очень маленьких коллекций, при частых вставках в начало списка (здесь не рассматривалось) или в учебных целях.
|
||||
|
||||
Таким образом, для реальных задач чаще всего выбирают хеш-таблицы или сбалансированные деревья в зависимости от требований к упорядоченности данных.
|
||||
|
||||
|
||||
I use arch BTW
|
||||
|
|
@ -1 +0,0 @@
|
|||
hi
|
||||
|
|
@ -1 +0,0 @@
|
|||
428
|
||||
|
|
@ -1 +0,0 @@
|
|||
428b
|
||||
330
README.md
330
README.md
|
|
@ -16,7 +16,7 @@
|
|||
|
||||
### Крайний срок приема работ 25.05.2026 до 14:00
|
||||
|
||||
## Задание 0 -- репозиторий [отдельный срок на создание PR с папкой: 28.02.2026]
|
||||
## Задание 1 -- репозиторий [отдельный срок на создание PR с папкой: 28.02.2026]
|
||||
|
||||
0. Создай пользователя (логин — фамилия+инициалы слитно транслитом, как в терминал-классе).
|
||||
|
||||
|
|
@ -53,330 +53,4 @@
|
|||
- Базовая ветка: **develop**
|
||||
- Сравниваемая ветка: **свой форк / IvanovII**
|
||||
|
||||
8. Отправь PR.
|
||||
|
||||
## Задание 1 -- структуры данных
|
||||
***Напоминание: под каждое задание вы создаете отдельную ветку***
|
||||
|
||||
>Для оформления результатов заведи папку **docs** в своей папке и сохраняй туда отчет (в любом формате от .doc до .md, а то и .jpnb). Вспомогательные файлы клади в подпапку **data** внутри **docs**
|
||||
|
||||
**Цель работы**
|
||||
|
||||
Реализовать три различные структуры данных «с нуля», применить их для хранения записей телефонного справочника и экспериментально сравнить производительность основных операций. Вы должны собственными руками написать код, чтобы понять внутреннее устройство связного списка, хеш-таблицы и двоичного дерева поиска, а также осознать их сильные и слабые стороны на практике.
|
||||
|
||||
**!! Задание выполнять в структурной (процедурной) парадигме, не используя классы. Главное реализовать структуры данных «руками» и сравнить их производительность.**
|
||||
|
||||
### Базовые операции (обязательны для всех):
|
||||
|
||||
`insert(name, phone)` -- добавить или обновить запись.
|
||||
|
||||
`find(name)` -- phone или None.
|
||||
|
||||
`delete(name)` -- удалить запись, игнорировать отсутствие.
|
||||
|
||||
`list_all()` -- список всех записей, отсортированный по имени (для BST in‑order обход; для списка и хеш‑таблицы — собрать и отсортировать явно).
|
||||
|
||||
#### 1. Связный список (LinkedListPhoneBook)
|
||||
|
||||
Узел представляется словарём: `{'name': 'Имя', 'phone': '123', 'next': None}.`
|
||||
|
||||
**Функции:**
|
||||
|
||||
`def ll_insert(head, name, phone)` — проходит до конца (или сразу добавляет в конец) и возвращает новую голову (если вставка в начало) или изменяет список по ссылке. Удобнее возвращать новую голову, если вставка может быть в начало.
|
||||
|
||||
`def ll_find(head, name)` — ищет узел, возвращает телефон или None.
|
||||
|
||||
`def ll_delete(head, name)` — удаляет узел, возвращает новую голову.
|
||||
|
||||
`def ll_list_all(head)` — собирает все записи в список и сортирует (сортировка вынесена отдельно).
|
||||
|
||||
#### 2. Хеш-таблица
|
||||
Хранится как список buckets фиксированной длины, каждый элемент — голова связного списка (или None).
|
||||
|
||||
**Функции:**
|
||||
|
||||
`def ht_insert(buckets, name, phone)` — вычисляет индекс, вызывает ll_insert для соответствующего бакета.
|
||||
|
||||
Аналогично `ht_find, ht_delete, ht_list_all` (последняя собирает все записи из всех бакетов и сортирует).
|
||||
|
||||
#### 3. Двоичное дерево поиска
|
||||
Узел — словарь: `{'name': 'Имя', 'phone': '123', 'left': None, 'right': None}.`
|
||||
|
||||
**Функции:**
|
||||
|
||||
`def bst_insert(root, name, phone)` — рекурсивно или итеративно вставляет, возвращает новый корень (если корень меняется).
|
||||
|
||||
`def bst_find(root, name)` — поиск.
|
||||
|
||||
`def bst_delete(root, name)` — удаление, возвращает новый корень.
|
||||
|
||||
`def bst_list_all(root)` — центрированный обход (рекурсивно собирает записи в отсортированном порядке).
|
||||
|
||||
### Экспериментальная часть (подробно об измерении времени)
|
||||
#### 1. Генерация тестовых данных
|
||||
Создайте список records из N элементов (например, N = 10000). Каждый элемент — кортеж (name, phone).
|
||||
|
||||
Имена генерируйте как `f"User_{i:05d}"` (равномерное распределение) или случайные слова из небольшого набора (чтобы были повторения и коллизии). Для проверки влияния порядка подготовьте два варианта одного и того же набора:
|
||||
|
||||
`records_shuffled` — случайный порядок.
|
||||
|
||||
`records_sorted` — отсортированный по имени (по алфавиту).
|
||||
|
||||
#### 2. Инструменты замера времени
|
||||
Используйте модуль **time**:
|
||||
|
||||
```python
|
||||
import time
|
||||
|
||||
start = time.perf_counter()
|
||||
# ... операции ...
|
||||
end = time.perf_counter()
|
||||
elapsed = end - start # время в секундах
|
||||
```
|
||||
|
||||
Для многократных замеров удобен `timeit`, но в этой задаче достаточно просто обернуть код в цикл и усреднить.
|
||||
|
||||
#### 3. Проведение замеров
|
||||
Для каждой структуры данных и для каждого режима входных данных (случайный / отсортированный) выполните:
|
||||
|
||||
- А. Вставка всех записей
|
||||
|
||||
Создайте пустую структуру.
|
||||
|
||||
Засеките время, выполните insert для каждой записи из входного списка.
|
||||
|
||||
Зафиксируйте общее время вставки.
|
||||
|
||||
- Б. Поиск 100 случайных записей
|
||||
|
||||
Возьмите 100 случайных имён из того же набора (гарантированно существующих) и 10 имён, которых нет (например, "None_{i}").
|
||||
|
||||
Засеките время на выполнение всех 110 вызовов find.
|
||||
|
||||
- В. Удаление 50 случайных записей
|
||||
|
||||
Выберите 50 случайных имён из набора.
|
||||
|
||||
Засеките время на выполнение delete для каждого.
|
||||
|
||||
|
||||
**!! Важно: после вставки структура остаётся заполненной, поиск и удаление выполняются на ней же. Если нужно повторить замер для другого порядка данных — создавайте новую структуру и заполняйте заново.**
|
||||
|
||||
#### 4. Сохранение результатов
|
||||
|
||||
**!! Каждый эксперимент повторить минимум 5 раз и записывать и среднее время, и все замеры.**
|
||||
|
||||
Соберите все замеры в словарь или список, затем сохраните в CSV-файл:
|
||||
|
||||
```python
|
||||
import csv
|
||||
|
||||
results = [
|
||||
["Структура", "Режим", "Операция", "Время (сек)"],
|
||||
["LinkedList", "случайный", "вставка", 0.123],
|
||||
...
|
||||
]
|
||||
|
||||
with open("results.csv", "w", newline="") as f:
|
||||
writer = csv.writer(f)
|
||||
writer.writerows(results)
|
||||
```
|
||||
|
||||
|
||||
#### 5. Анализ результатов
|
||||
Постройте график (столбчатая диаграмма или линейный график) — можно в Excel, Google Sheets или с помощью matplotlib в Python.
|
||||
|
||||
Сравните:
|
||||
|
||||
- Как порядок входных данных влияет на скорость вставки в BST (деградация до O(n) на отсортированных данных).
|
||||
|
||||
- Почему хеш-таблица почти не чувствительна к порядку.
|
||||
|
||||
- Почему связный список всегда медленен при поиске.
|
||||
|
||||
- Как удаление работает в каждой структуре.
|
||||
|
||||
* Вывод должен содержать ответ на вопрос: какую структуру и для каких задач (частые вставки, частый поиск, необходимость получать данные в порядке) стоит выбирать в реальной жизни.*
|
||||
|
||||
## Задание: Поиск выхода из лабиринта (объектно-ориентированная реализация с паттернами)
|
||||
|
||||
### Цель работы
|
||||
Разработать гибкую, расширяемую программу для загрузки лабиринта из файла, поиска пути от старта до выхода с возможностью выбора алгоритма, визуализации процесса и экспериментального сравнения алгоритмов. В ходе работы необходимо применить минимум 3 паттерна проектирования из списка GoF, обосновать их выбор и продемонстрировать преимущества такой архитектуры.
|
||||
|
||||
### Общая схема приложения (пример)
|
||||
|
||||
```mermaid
|
||||
classDiagram
|
||||
class Maze {
|
||||
-Cell[] cells
|
||||
-int width, height
|
||||
-Cell start
|
||||
-Cell exit
|
||||
+getCell(x,y): Cell
|
||||
+getNeighbors(cell): List~Cell~
|
||||
}
|
||||
|
||||
class Cell {
|
||||
-int x, y
|
||||
-bool isWall
|
||||
-bool isStart
|
||||
-bool isExit
|
||||
+isPassable(): bool
|
||||
}
|
||||
|
||||
class MazeBuilder {
|
||||
<<interface>>
|
||||
+buildFromFile(filename): Maze
|
||||
}
|
||||
|
||||
class TextFileMazeBuilder {
|
||||
+buildFromFile(filename): Maze
|
||||
}
|
||||
|
||||
class PathFindingStrategy {
|
||||
<<interface>>
|
||||
+findPath(maze, start, exit): List~Cell~
|
||||
}
|
||||
|
||||
class BFSStrategy
|
||||
class DFSStrategy
|
||||
class AStarStrategy
|
||||
class DijkstraStrategy
|
||||
|
||||
class SearchStats {
|
||||
+timeMs: float
|
||||
+visitedCells: int
|
||||
+pathLength: int
|
||||
}
|
||||
|
||||
class MazeSolver {
|
||||
-Maze maze
|
||||
-PathFindingStrategy strategy
|
||||
+setStrategy(strategy)
|
||||
+solve(): SearchStats
|
||||
}
|
||||
|
||||
class Command {
|
||||
<<interface>>
|
||||
+execute()
|
||||
+undo()
|
||||
}
|
||||
|
||||
class MoveCommand {
|
||||
-Player player
|
||||
-Direction dir
|
||||
-Cell previousCell
|
||||
+execute()
|
||||
+undo()
|
||||
}
|
||||
|
||||
class Player {
|
||||
-Cell currentCell
|
||||
+moveTo(cell)
|
||||
}
|
||||
|
||||
class Observer {
|
||||
<<interface>>
|
||||
+update(event)
|
||||
}
|
||||
|
||||
class ConsoleView {
|
||||
+update(event)
|
||||
+render(maze, player, path)
|
||||
}
|
||||
|
||||
MazeBuilder <|.. TextFileMazeBuilder
|
||||
MazeBuilder --> Maze : creates
|
||||
PathFindingStrategy <|.. BFSStrategy
|
||||
PathFindingStrategy <|.. DFSStrategy
|
||||
PathFindingStrategy <|.. AStarStrategy
|
||||
PathFindingStrategy <|.. DijkstraStrategy
|
||||
MazeSolver --> PathFindingStrategy : uses
|
||||
MazeSolver --> Maze : uses
|
||||
Command <|.. MoveCommand
|
||||
MoveCommand --> Player
|
||||
Player --> Cell
|
||||
Observer <|.. ConsoleView
|
||||
MazeSolver --> Observer : notifies
|
||||
```
|
||||
|
||||
### Выполнение
|
||||
|
||||
#### Этап 1. Модель лабиринта (без паттернов, просто классы)
|
||||
**Задача:** Создать классы `Cell` и `Maze`, которые представляют карту лабиринта.
|
||||
- `Cell` хранит координаты (x, y), флаги `isWall`, `isStart`, `isExit`, метод `isPassable()` (возвращает `True` для прохода, если не стена).
|
||||
- `Maze` хранит двумерный массив клеток, ширину, высоту, ссылки на стартовую и выходную клетку. Методы: `getCell(x, y)`, `getNeighbors(cell)` – возвращает список соседних проходимых клеток (вверх, вниз, влево, вправо, если в пределах границ и не стена).
|
||||
|
||||
**Результат:** Лабиринт можно создать вручную в коде, но загрузку пока не делаем.
|
||||
|
||||
#### Этап 2. Загрузка лабиринта из файла – применение паттерна **Builder**
|
||||
**Задача:** Реализовать загрузку лабиринта из текстового файла, где `#` – стена, ` ` (пробел) – проход, `S` – старт, `E` – выход.
|
||||
- Создать интерфейс `MazeBuilder` с методом `buildFromFile(filename)`.
|
||||
- Реализовать класс `TextFileMazeBuilder`, который читает файл, парсит символы, создаёт объекты `Cell`, задаёт координаты и флаги, после чего возвращает готовый `Maze`.
|
||||
|
||||
Процесс построения лабиринта сложный (парсинг, валидация, установка старта/выхода). Builder скрывает детали создания от клиента. В будущем можно легко добавить другой формат (например, JSON или бинарный) через новую реализацию `MazeBuilder`.
|
||||
|
||||
#### Этап 3. Стратегии поиска пути – паттерн **Strategy**
|
||||
**Задача:** Реализовать семейство алгоритмов поиска пути от старта до выхода.
|
||||
- Создать интерфейс `PathFindingStrategy` с методом `findPath(maze, start, exit)`, возвращающим список клеток пути (от старта до выхода включительно) или пустой список, если пути нет.
|
||||
- Реализовать минимум 3 стратегии:
|
||||
- **BFS** (поиск в ширину) – гарантирует кратчайший путь по количеству шагов.
|
||||
- **DFS** (поиск в глубину) – быстрый, но не обязательно кратчайший.
|
||||
- **A*** (с эвристикой, например, манхэттенское расстояние) – компромисс между скоростью и оптимальностью.
|
||||
- (Опционально) **Дейкстра** – полезна для взвешенных лабиринтов, но в базовом варианте все шаги имеют вес 1, тогда она совпадает с BFS.
|
||||
|
||||
Каждая стратегия возвращает путь. Для BFS/DFS используйте очередь/стек, для A* – приоритетную очередь (heapq). Важно: алгоритмы не должны модифицировать сам лабиринт, только читать состояние клеток.
|
||||
|
||||
Strategy позволяет легко переключать алгоритмы во время выполнения, не меняя код остальной программы. Новый алгоритм можно добавить, реализовав интерфейс.
|
||||
|
||||
#### Этап 4. Класс-оркестратор – **MazeSolver** (использует Strategy)
|
||||
**Задача:** Создать класс, который принимает лабиринт и стратегию, выполняет поиск и собирает статистику.
|
||||
- `MazeSolver` содержит поля `maze` и `strategy`.
|
||||
- Метод `setStrategy(strategy)` для динамической смены алгоритма.
|
||||
- Метод `solve()` вызывает `strategy.findPath(...)` и возвращает объект `SearchStats` (время выполнения в миллисекундах, количество посещённых клеток, длина найденного пути).
|
||||
- Для замера времени используйте `time.perf_counter()` до и после вызова стратегии.
|
||||
|
||||
#### Этап 5. Визуализация и пошаговое управление – паттерны **Observer** и **Command** (по желанию)
|
||||
**5.1. Наблюдатель (Observer)** – обновление консольного интерфейса.
|
||||
- Создать интерфейс `Observer` с методом `update(event)`, где `event` может быть строкой или объектом с типом события (`"path_found"`, `"move"`, `"maze_loaded"`).
|
||||
- Реализовать класс `ConsoleView`, который отображает лабиринт, текущее положение игрока (если реализован пошаговый режим) и найденный путь. Метод `render(maze, player_position, path)` рисует карту в консоли.
|
||||
- `MazeSolver` (или отдельный контроллер) может иметь список наблюдателей и уведомлять их при изменении состояния.
|
||||
|
||||
**5.2. Команда (Command)** – для пошагового перемещения игрока по найденному пути (или ручного управления).
|
||||
- Создать интерфейс `Command` с методами `execute()` и `undo()`.
|
||||
- Реализовать `MoveCommand`, который принимает игрока (`Player`), направление и изменяет его позицию, сохраняя предыдущую для отмены.
|
||||
- Создать класс `Player`, хранящий текущую клетку.
|
||||
- Консольное меню позволяет вводить команды (W/A/S/D), выполнять `MoveCommand`, при необходимости отменять последний ход (Ctrl+Z). Это опционально, но очень наглядно демонстрирует паттерн.
|
||||
|
||||
*Observer можно реализовать только для вывода сообщений о начале/конце поиска, а Command – для демонстрации undo при ручном исследовании лабиринта.*
|
||||
|
||||
#### Этап 6. Экспериментальная часть (аналогично заданию со структурами данных)
|
||||
**Задача:** Сравнить эффективность реализованных стратегий на лабиринтах разной сложности.
|
||||
1. **Подготовка тестовых лабиринтов:**
|
||||
- Маленький (10×10) с простым путём.
|
||||
- Средний (50×50) с тупиками.
|
||||
- Большой (100×100) с запутанной структурой.
|
||||
- «Пустой» лабиринт (без стен) – для демонстрации максимальной производительности.
|
||||
- «Без выхода» – чтобы проверить обработку отсутствия пути.
|
||||
2. **Замеры:**
|
||||
- Для каждого лабиринта и каждой стратегии запустить `solve()` 5–10 раз, усреднить время, количество посещённых клеток, длину пути.
|
||||
- Записать результаты в CSV: `лабиринт,стратегия,время_мс,посещено_клеток,длина_пути`.
|
||||
3. **Анализ:**
|
||||
- Построить графики для каждого лабиринта.
|
||||
- Проанализировать и написать выводы по итогам (эффективность того или иного алгоритма в разных случаях).
|
||||
|
||||
4. **Дополнительное задание:** Реализовать взвешенные клетки (например, болото – вес 3, песок – вес 2, асфальт – вес 1) и сравнить Дейкстру с A* на взвешенном графе.
|
||||
|
||||
#### Этап 7. Отчёт
|
||||
**Структура отчёта:**
|
||||
1. Описание задачи и выбранных паттернов (с диаграммой классов из Mermaid).
|
||||
2. Листинги ключевых классов (можно выборочно) или ссылка на репозиторий.
|
||||
3. Результаты экспериментов (таблицы, графики).
|
||||
4. Анализ эффективности алгоритмов и применимости паттернов.
|
||||
5. Выводы: как ООП и паттерны помогли сделать код гибким и расширяемым. Что было бы сложно изменить без них.
|
||||
|
||||
### Советы
|
||||
- Для A* самая простая эвристика: `abs(x1 - x2) + abs(y1 - y2)`.
|
||||
- При поиске пути надо хранить предшественников (`parent` для каждой посещённой клетки), чтобы восстановить путь.
|
||||
- Для BFS/DFS используй `deque` (очередь) и `list` (стек).
|
||||
- Визуализацию в консоли можно сделать с помощью `os.system('cls' if os.name == 'nt' else 'clear')` для перерисовки.
|
||||
8. Отправь PR.
|
||||
|
|
@ -1 +0,0 @@
|
|||
1
|
||||
317
YanyaevAA/docs/Report_1.md
Normal file
317
YanyaevAA/docs/Report_1.md
Normal file
|
|
@ -0,0 +1,317 @@
|
|||
# Структуры данных
|
||||
Цель работы: Реализовать три различные структуры данных «с нуля», применить их для хранения записей телефонного справочника и экспериментально сравнить производительность основных операций. Вы должны собственными руками написать код, чтобы понять внутреннее устройство связного списка, хеш-таблицы и двоичного дерева поиска, а также осознать их сильные и слабые стороны на практике.
|
||||
|
||||
## Подготовка среды
|
||||
```Python
|
||||
import time
|
||||
from pathlib import Path
|
||||
import random
|
||||
import csv
|
||||
import sys
|
||||
import pandas as pd
|
||||
import matplotlib.pyplot as plt
|
||||
import seaborn as sns
|
||||
sys.setrecursionlimit(12000) #увеличивает глубину рекурсии
|
||||
```
|
||||
|
||||
# Базовые операции
|
||||
```Python
|
||||
#Связный список
|
||||
def ll_insert(head, name, phone):
|
||||
current = head
|
||||
while current:
|
||||
if current['name'] == name:
|
||||
current['phone'] = phone
|
||||
return head
|
||||
current = current['next']
|
||||
new_node = {'name': name, 'phone': phone, 'next': None}
|
||||
new_node['next'] = head
|
||||
return new_node
|
||||
|
||||
def ll_find(head, name):
|
||||
current = head
|
||||
while current:
|
||||
if current['name'] == name:
|
||||
return current['phone']
|
||||
current = current['next']
|
||||
return None
|
||||
|
||||
def ll_delete(head, name):
|
||||
if head['name'] == name:
|
||||
return head['next']
|
||||
current = head
|
||||
while current['next']:
|
||||
if current['next']['name'] == name:
|
||||
current['next'] = current['next']['next']
|
||||
break
|
||||
current = current['next']
|
||||
return head
|
||||
|
||||
def ll_list_all(head):
|
||||
data= []
|
||||
current = head
|
||||
while current:
|
||||
data.append((current['name'], current['phone']))
|
||||
current = current['next']
|
||||
return sorted(data)
|
||||
|
||||
#хеш-таблица
|
||||
def ht_insert(buckets, name, phone):
|
||||
id=hash(name)%len(buckets)
|
||||
buckets[id] = ll_insert(buckets[id], name, phone)
|
||||
|
||||
def ht_find(buckets, name):
|
||||
id= hash(name)%len(buckets)
|
||||
return ll_find(buckets[id], name)
|
||||
|
||||
def ht_delete(buckets, name):
|
||||
id= hash(name)%len(buckets)
|
||||
buckets[id] = ll_delete(buckets[id], name)
|
||||
|
||||
def ht_list_all(buckets):
|
||||
data = []
|
||||
for head in buckets:
|
||||
current = head
|
||||
while current:
|
||||
data.append((current['name'], current['phone']))
|
||||
current = current['next']
|
||||
return sorted(data)
|
||||
|
||||
|
||||
|
||||
#Двоичное дерево поиска
|
||||
def bst_insert(root, name, phone):
|
||||
if root is None:
|
||||
return {'name': name, 'phone': phone, 'left': None, 'right': None}
|
||||
if name == root['name']:
|
||||
root['phone'] = phone
|
||||
elif name < root['name']:
|
||||
root['left'] = bst_insert(root['left'], name, phone)
|
||||
else:
|
||||
root['right'] = bst_insert(root['right'], name, phone)
|
||||
return root
|
||||
|
||||
def bst_find(root, name):
|
||||
if root is None:
|
||||
return None
|
||||
if root['name'] == name:
|
||||
return root['phone']
|
||||
elif name<root['name']:
|
||||
return bst_find(root['left'], name)
|
||||
else:
|
||||
return bst_find(root['right'], name)
|
||||
|
||||
def minimum(node):
|
||||
current = node
|
||||
while current['left'] is not None:
|
||||
current = current['left']
|
||||
return current
|
||||
|
||||
def bst_delete(root, name):
|
||||
if root is None:
|
||||
return None
|
||||
if name < root['name']:
|
||||
root['left'] = bst_delete(root['left'], name)
|
||||
elif name > root['name']:
|
||||
root['right'] = bst_delete(root['right'], name)
|
||||
else:
|
||||
if root['left'] is None:
|
||||
return root['right']
|
||||
elif root['right'] is None:
|
||||
return root['left']
|
||||
min=minimum(root['right'])
|
||||
root['name']=min['name']
|
||||
root['phone']=min['phone']
|
||||
root['right']=bst_delete(root['right'], min['name'])
|
||||
return root
|
||||
|
||||
def bst_list_all(root):
|
||||
result=[]
|
||||
if root:
|
||||
result.extend(bst_list_all(root['left']))
|
||||
result.append((root['name'], root['phone']))
|
||||
result.extend(bst_list_all(root['right']))
|
||||
return result
|
||||
```
|
||||
|
||||
# Экспериментальная часть
|
||||
|
||||
## Генерация
|
||||
Создаем список records из N=10000 элементов. Каждый элемент — кортеж (name, phone).
|
||||
Имена генерируются как f"User_{i:05d}" (равномерное распределение). Для проверки влияния порядка подготовим два варианта одного и того же набора:
|
||||
|
||||
records_shuffled — случайный порядок.
|
||||
|
||||
records_sorted — отсортированный по имени (по алфавиту).
|
||||
```Python
|
||||
def generate(n=10000):
|
||||
records = [(f"User_{i:05d}", f"+7 ({random.randint(100, 999)}) {random.randint(100, 999)}-{random.randint(00, 99):02}-{random.randint(00, 99):02}") for i in range(n)]
|
||||
records_sorted =records.copy()
|
||||
records_shuffled=records.copy()
|
||||
random.shuffle(records_shuffled)
|
||||
return records_sorted, records_shuffled
|
||||
```
|
||||
## Проведение замеров
|
||||
|
||||
**А. Вставка всех записей**
|
||||
Создаем пустую структуру.
|
||||
Засекаем время, выполняем insert для каждой записи из входного списка.
|
||||
Фиксируем общее время вставки.
|
||||
```Python
|
||||
def task_A(structure_name, data):
|
||||
start =time.perf_counter()
|
||||
if structure_name=="LinkedList":
|
||||
head=None
|
||||
for name, phone in data:
|
||||
head = ll_insert(head, name, phone)
|
||||
container=head
|
||||
elif structure_name=="HashTable":
|
||||
buckets=[None]*1000
|
||||
for name, phone in data:
|
||||
ht_insert(buckets, name, phone)
|
||||
container=buckets
|
||||
elif structure_name=="BinarySearchTree":
|
||||
root=None
|
||||
for name, phone in data:
|
||||
root = bst_insert(root, name, phone)
|
||||
container=root
|
||||
end = time.perf_counter()
|
||||
elapsed = end - start
|
||||
return elapsed, container
|
||||
```
|
||||
|
||||
**Б. Поиск 100 случайных записей**
|
||||
Берем 100 случайных имён из того же набора (гарантированно существующих) и 10 имён, которых нет ("None_{i}").
|
||||
Засекаем время на выполнение всех 110 вызовов find.
|
||||
```Python
|
||||
def task_B(structure_name,container, data):
|
||||
start=time.perf_counter()
|
||||
if structure_name=="LinkedList":
|
||||
for name in data:
|
||||
ll_find(container, name)
|
||||
elif structure_name=="HashTable":
|
||||
for name in data:
|
||||
ht_find(container, name)
|
||||
elif structure_name=="BinarySearchTree":
|
||||
for name in data:
|
||||
bst_find(container, name)
|
||||
end=time.perf_counter()
|
||||
elapsed = end - start
|
||||
return elapsed
|
||||
```
|
||||
|
||||
**В. Удаление 50 случайных записей**
|
||||
Берем 50 случайных имён из набора.
|
||||
Засекаем время на выполнение delete для каждого.
|
||||
```Python
|
||||
def task_C(structure_name,container, data):
|
||||
start=time.perf_counter()
|
||||
if structure_name=="LinkedList":
|
||||
for name in data:
|
||||
container=ll_delete(container, name)
|
||||
elif structure_name=="HashTable":
|
||||
for name in data:
|
||||
ht_delete(container, name)
|
||||
elif structure_name=="BinarySearchTree":
|
||||
for name in data:
|
||||
container = bst_delete(container, name)
|
||||
end=time.perf_counter()
|
||||
elapsed = end - start
|
||||
return elapsed
|
||||
```
|
||||
|
||||
### Реализация замеров
|
||||
```Python
|
||||
results=[["Структура", "Режим", "Операция", "Время (сек)"]]
|
||||
structures_name=["LinkedList", "HashTable", "BinarySearchTree"]
|
||||
experiment_name=["Вставка", "Поиск", "Удаление"]
|
||||
mode_of_data=["Случайный", "Отсортированный"]
|
||||
|
||||
records_sorted, records_shuffled = generate()
|
||||
container_shuffled=[]#хранилище структур со случайными данными
|
||||
container_sorted=[]#хранилище структур с отсортированными данными
|
||||
names=[record[0] for record in records_shuffled]
|
||||
#Данные для задания Б
|
||||
random_names=random.sample(names, 100)
|
||||
missing_names=[f"None_{i}" for i in range(10)]
|
||||
names_for_test=random_names+missing_names
|
||||
#Данные для задания В
|
||||
names_to_delete=random.sample(names,50)
|
||||
|
||||
for i in range(3):
|
||||
container_shuffled.append(task_A(structures_name[i], records_shuffled)[1])
|
||||
container_sorted.append(task_A(structures_name[i], records_sorted)[1])
|
||||
for j in range(5):
|
||||
# Реализация задания А
|
||||
result_shuffled = task_A(structures_name[i], records_shuffled)[0]
|
||||
results.append([structures_name[i], mode_of_data[0], experiment_name[0], result_shuffled])
|
||||
|
||||
result_sorted= task_A(structures_name[i], records_sorted)[0]
|
||||
results.append([structures_name[i], mode_of_data[1], experiment_name[0], result_sorted])
|
||||
print(f"{structures_name[i]}: Время вставки всех записей {mode_of_data[0]}: {result_shuffled} {mode_of_data[1]}: {result_sorted}")
|
||||
# Реализация задания Б
|
||||
result_shuffled = task_B(structures_name[i], container_shuffled[i], names_for_test)
|
||||
results.append([structures_name[i], mode_of_data[0], experiment_name[1], result_shuffled])
|
||||
|
||||
result_sorted = task_B(structures_name[i], container_sorted[i], names_for_test)
|
||||
results.append([structures_name[i], mode_of_data[1], experiment_name[1], result_sorted])
|
||||
print(f"{structures_name[i]}: Время нахождения 110 записей для {mode_of_data[0]}: {result_shuffled} {mode_of_data[1]}: {result_sorted} ")
|
||||
#Реализация задания В
|
||||
shuffled = container_shuffled[i]
|
||||
sorted = container_sorted[i]
|
||||
result_shuffled = task_C(structures_name[i], shuffled, names_to_delete)
|
||||
results.append([structures_name[i], mode_of_data[0], experiment_name[2], result_shuffled])
|
||||
|
||||
result_sorted = task_C(structures_name[i], sorted, names_to_delete)
|
||||
results.append([structures_name[i], mode_of_data[1], experiment_name[2], result_sorted])
|
||||
print(f"{structures_name[i]}: Время удаления 50 записей для {mode_of_data[0]}: {result_shuffled} {mode_of_data[1]}: {result_sorted}")
|
||||
```
|
||||
|
||||
## Сохранение результатов
|
||||
```Python
|
||||
current_dir=Path.cwd()
|
||||
target=current_dir.parent/"docs"/"data"
|
||||
csv_file=target /"results.csv"
|
||||
with open(csv_file, "w", newline="",encoding="utf-8-sig") as f:
|
||||
writer = csv.writer(f)
|
||||
writer.writerows(results)
|
||||
```
|
||||
|
||||
# Анализ результатов
|
||||
|
||||
## Построение графиков
|
||||
```Python
|
||||
df = pd.read_csv(csv_file)
|
||||
df_avg = df.groupby(["Структура", "Режим", "Операция"])["Время (сек)"].mean().reset_index()
|
||||
fig, axes = plt.subplots(1, 3, figsize=(18, 6))
|
||||
for i, experiment in enumerate(experiment_name):
|
||||
data_experiment = df_avg[df_avg["Операция"] == experiment]
|
||||
sns.barplot(ax=axes[i],data=data_experiment, x="Структура",y="Время (сек)",hue="Режим")
|
||||
axes[i].set_title(experiment)
|
||||
axes[i].set_ylabel("Среднее время (сек)")
|
||||
axes[i].set_yscale("log")
|
||||
plt.tight_layout()
|
||||
png_file= target/"graphics.png"
|
||||
plt.savefig(png_file, dpi=300, bbox_inches='tight')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
### Как порядок входных данных влияет на скорость вставки в BST
|
||||
Если подать на вход отсортированные данные, дерево превращается в связный список: каждый новый узел становится правым потомком предыдущего. И сложность меняется с логарифмической O(log n) на линейную O(n). Вставка для неотсортированных данных заняла 0.016531 с, а для отсортированных: 7.112118 с, разница в 430 раз. Получается, что BST сильно зависит от входных данных.
|
||||
### Почему хеш-таблица почти не чувствительна к порядку
|
||||
Хеш-таблица имеет низкую чувствительность к порядку входных данных, поскольку хеш-функция вычисляет индекс в массиве на основе значения ключа, обеспечивая равномерное распределение элементов по бакетам независимо от их исходной последовательности. По графикам видно, что разница между случайными и отсортированными данными минимальна. И для всех операций сложность составляет O(1).
|
||||
### Почему связный список всегда медленен при поиске
|
||||
Связный список всегда медленен при поиске, потому что у него отсутствует прямой доступ к элементам, и нужно перебирать все элементы по порядку. И из-за этого связный список имееет сложность O(n).
|
||||
### Как удаление работает в каждой структуре
|
||||
- **Связный список:** Сначала программа ищет нужный элемент, перебирая их по порядку от головы, что занимает время O(n). Как только элемент найден, то у предыдущего обновляется ссылка на элемент, который шел после удаляемого, что занимает время O(1). По графикам видно, что время удаления близко ко времени поиска. Время удаления для отсортированных данных: 0.017500 с, а для случайных: 0.018947 с.
|
||||
- **Хеш-таблица:** Программа определяет нужный бакет и удаляет элемент из короткого связного списка внутри этого бакета за O(1). Время удаления для отсортированных данных: 0.000036 с, а для случайных: 0.000043 с.
|
||||
- **Двоичное дерево поиска:** Нет потомков: Узел просто стирается. Один потомок: Потомок занимает место удаленного родителя. Два потомка: На место удаленного узла ставится самый минимальный элемент из его правого поддерева. Для случайных данных занимает O(log n), а для отсортированных данных занимает O(n). Время удаления для отсортированных данных: 0.039463 с, а для случайных: 0.000153 с.
|
||||
|
||||
# Вывод
|
||||
На основе полученных результатов можно сделать вывод:
|
||||
- **Связный список:** всегда имеет линейную сложность O(n), что делает его неподходящим для задач частых вставок, частого поиска и получения данных в порядке. Но подходит только в узких случаях: максимально быстрая вставка и удаление элементов в начало или конец структуры(очереди, стеки).
|
||||
- **Хеш-таблица:** является лучшим выбором для максимально задач частого поиска, добавления и удаления элементов, которые имеют сложность O(1), при этом порядок входных данных не имеет значение. Она идеально подходит для словарей и кэшей.
|
||||
- **Двоичное дерево поиска:** Необходимо использовать в тех случаях, когда необходимо получать данные в отсортированном состоянии и выполнять поиск в заданном диапазоне значений. При случайных входных данных имеет хорошую сложность O(log n), но при получении отсортированных входных данных сложность возрастает до линейной O(n).
|
||||
|
||||
Таким образом, для реальных задач наиболее подходят хеш-таблицы или сбалансированные деревья, если требуется получить данные в отсортированном виде.
|
||||
BIN
YanyaevAA/docs/data/graphics.png
Normal file
BIN
YanyaevAA/docs/data/graphics.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 119 KiB |
91
YanyaevAA/docs/data/results.csv
Normal file
91
YanyaevAA/docs/data/results.csv
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
Структура,Режим,Операция,Время (сек)
|
||||
LinkedList,Случайный,Вставка,1.3509334000045783
|
||||
LinkedList,Отсортированный,Вставка,1.3042261000009603
|
||||
LinkedList,Случайный,Поиск,0.01588919999630889
|
||||
LinkedList,Отсортированный,Поиск,0.014776199997868389
|
||||
LinkedList,Случайный,Удаление,0.012387100003252272
|
||||
LinkedList,Отсортированный,Удаление,0.008979600002930965
|
||||
LinkedList,Случайный,Вставка,1.3995262999960687
|
||||
LinkedList,Отсортированный,Вставка,1.3076703999977326
|
||||
LinkedList,Случайный,Поиск,0.01563009999517817
|
||||
LinkedList,Отсортированный,Поиск,0.014876699999149423
|
||||
LinkedList,Случайный,Удаление,0.020549799999571405
|
||||
LinkedList,Отсортированный,Удаление,0.019360199999937322
|
||||
LinkedList,Случайный,Вставка,1.3874801999991178
|
||||
LinkedList,Отсортированный,Вставка,1.2993992000047
|
||||
LinkedList,Случайный,Поиск,0.015836999999010004
|
||||
LinkedList,Отсортированный,Поиск,0.014835000001767185
|
||||
LinkedList,Случайный,Удаление,0.020929600003000814
|
||||
LinkedList,Отсортированный,Удаление,0.02016870000079507
|
||||
LinkedList,Случайный,Вставка,1.3857238999989931
|
||||
LinkedList,Отсортированный,Вставка,1.3020963999952073
|
||||
LinkedList,Случайный,Поиск,0.015273999997589272
|
||||
LinkedList,Отсортированный,Поиск,0.014580000002752058
|
||||
LinkedList,Случайный,Удаление,0.0203378000005614
|
||||
LinkedList,Отсортированный,Удаление,0.019558400003006682
|
||||
LinkedList,Случайный,Вставка,1.4175892999992357
|
||||
LinkedList,Отсортированный,Вставка,1.3036662000013166
|
||||
LinkedList,Случайный,Поиск,0.015531899996858556
|
||||
LinkedList,Отсортированный,Поиск,0.014790299996093381
|
||||
LinkedList,Случайный,Удаление,0.0205294999977923
|
||||
LinkedList,Отсортированный,Удаление,0.019432499997492414
|
||||
HashTable,Случайный,Вставка,0.0048284000004059635
|
||||
HashTable,Отсортированный,Вставка,0.00405250000039814
|
||||
HashTable,Случайный,Поиск,9.529999806545675e-05
|
||||
HashTable,Отсортированный,Поиск,6.0999998822808266e-05
|
||||
HashTable,Случайный,Удаление,4.990000161342323e-05
|
||||
HashTable,Отсортированный,Удаление,3.060000017285347e-05
|
||||
HashTable,Случайный,Вставка,0.0040650000009918585
|
||||
HashTable,Отсортированный,Вставка,0.0039127000054577366
|
||||
HashTable,Случайный,Поиск,5.650000093737617e-05
|
||||
HashTable,Отсортированный,Поиск,4.53000029665418e-05
|
||||
HashTable,Случайный,Удаление,5.3499999921768904e-05
|
||||
HashTable,Отсортированный,Удаление,4.27999984822236e-05
|
||||
HashTable,Случайный,Вставка,0.004214900000079069
|
||||
HashTable,Отсортированный,Вставка,0.03241159999743104
|
||||
HashTable,Случайный,Поиск,5.999999848427251e-05
|
||||
HashTable,Отсортированный,Поиск,5.619999865302816e-05
|
||||
HashTable,Случайный,Удаление,4.2100000428035855e-05
|
||||
HashTable,Отсортированный,Удаление,3.979999746661633e-05
|
||||
HashTable,Случайный,Вставка,0.004221499999403022
|
||||
HashTable,Отсортированный,Вставка,0.004123199993046001
|
||||
HashTable,Случайный,Поиск,4.7599998652003706e-05
|
||||
HashTable,Отсортированный,Поиск,4.7299996367655694e-05
|
||||
HashTable,Случайный,Удаление,3.6600002204068005e-05
|
||||
HashTable,Отсортированный,Удаление,3.4900003811344504e-05
|
||||
HashTable,Случайный,Вставка,0.004094500000064727
|
||||
HashTable,Отсортированный,Вставка,0.0039883999997982755
|
||||
HashTable,Случайный,Поиск,4.220000118948519e-05
|
||||
HashTable,Отсортированный,Поиск,4.189999890513718e-05
|
||||
HashTable,Случайный,Удаление,3.440000000409782e-05
|
||||
HashTable,Отсортированный,Удаление,3.2000003557186574e-05
|
||||
BinarySearchTree,Случайный,Вставка,0.01629050000337884
|
||||
BinarySearchTree,Отсортированный,Вставка,7.1500338000041666
|
||||
BinarySearchTree,Случайный,Поиск,0.00027830000180983916
|
||||
BinarySearchTree,Отсортированный,Поиск,0.05988200000138022
|
||||
BinarySearchTree,Случайный,Удаление,0.0001686000032350421
|
||||
BinarySearchTree,Отсортированный,Удаление,0.03961960000015097
|
||||
BinarySearchTree,Случайный,Вставка,0.016419899999164045
|
||||
BinarySearchTree,Отсортированный,Вставка,7.092110900004627
|
||||
BinarySearchTree,Случайный,Поиск,0.0002615000048535876
|
||||
BinarySearchTree,Отсортированный,Поиск,0.060809999995399266
|
||||
BinarySearchTree,Случайный,Удаление,0.00014789999841013923
|
||||
BinarySearchTree,Отсортированный,Удаление,0.039564300001075026
|
||||
BinarySearchTree,Случайный,Вставка,0.016564800003834534
|
||||
BinarySearchTree,Отсортированный,Вставка,7.115889100001368
|
||||
BinarySearchTree,Случайный,Поиск,0.000284100002318155
|
||||
BinarySearchTree,Отсортированный,Поиск,0.06236229999922216
|
||||
BinarySearchTree,Случайный,Удаление,0.00015389999316539615
|
||||
BinarySearchTree,Отсортированный,Удаление,0.03888590000133263
|
||||
BinarySearchTree,Случайный,Вставка,0.01672099999996135
|
||||
BinarySearchTree,Отсортированный,Вставка,7.124367500000517
|
||||
BinarySearchTree,Случайный,Поиск,0.00027630000113276765
|
||||
BinarySearchTree,Отсортированный,Поиск,0.06082099999912316
|
||||
BinarySearchTree,Случайный,Удаление,0.00014789999841013923
|
||||
BinarySearchTree,Отсортированный,Удаление,0.03982890000042971
|
||||
BinarySearchTree,Случайный,Вставка,0.016656699997838587
|
||||
BinarySearchTree,Отсортированный,Вставка,7.078189200001361
|
||||
BinarySearchTree,Случайный,Поиск,0.0002753000007942319
|
||||
BinarySearchTree,Отсортированный,Поиск,0.05944880000606645
|
||||
BinarySearchTree,Случайный,Удаление,0.00014619999274145812
|
||||
BinarySearchTree,Отсортированный,Удаление,0.039416899999196175
|
||||
|
256
YanyaevAA/task1/[1].py
Normal file
256
YanyaevAA/task1/[1].py
Normal file
|
|
@ -0,0 +1,256 @@
|
|||
import time
|
||||
from pathlib import Path
|
||||
import random
|
||||
import csv
|
||||
import sys
|
||||
import pandas as pd
|
||||
import matplotlib.pyplot as plt
|
||||
import seaborn as sns
|
||||
sys.setrecursionlimit(12000)
|
||||
#Связный список
|
||||
def ll_insert(head, name, phone):
|
||||
current = head
|
||||
while current:
|
||||
if current['name'] == name:
|
||||
current['phone'] = phone
|
||||
return head
|
||||
current = current['next']
|
||||
new_node = {'name': name, 'phone': phone, 'next': None}
|
||||
new_node['next'] = head
|
||||
return new_node
|
||||
|
||||
def ll_find(head, name):
|
||||
current = head
|
||||
while current:
|
||||
if current['name'] == name:
|
||||
return current['phone']
|
||||
current = current['next']
|
||||
return None
|
||||
|
||||
def ll_delete(head, name):
|
||||
if head['name'] == name:
|
||||
return head['next']
|
||||
current = head
|
||||
while current['next']:
|
||||
if current['next']['name'] == name:
|
||||
current['next'] = current['next']['next']
|
||||
break
|
||||
current = current['next']
|
||||
return head
|
||||
|
||||
def ll_list_all(head):
|
||||
data= []
|
||||
current = head
|
||||
while current:
|
||||
data.append((current['name'], current['phone']))
|
||||
current = current['next']
|
||||
return sorted(data)
|
||||
|
||||
#хэш-таблица
|
||||
def ht_insert(buckets, name, phone):
|
||||
id=hash(name)%len(buckets)
|
||||
buckets[id] = ll_insert(buckets[id], name, phone)
|
||||
|
||||
def ht_find(buckets, name):
|
||||
id= hash(name)%len(buckets)
|
||||
return ll_find(buckets[id], name)
|
||||
|
||||
def ht_delete(buckets, name):
|
||||
id= hash(name)%len(buckets)
|
||||
buckets[id] = ll_delete(buckets[id], name)
|
||||
|
||||
def ht_list_all(buckets):
|
||||
data = []
|
||||
for head in buckets:
|
||||
current = head
|
||||
while current:
|
||||
data.append((current['name'], current['phone']))
|
||||
current = current['next']
|
||||
return sorted(data)
|
||||
|
||||
|
||||
|
||||
#Двоичное дерево поиска
|
||||
def bst_insert(root, name, phone):
|
||||
if root is None:
|
||||
return {'name': name, 'phone': phone, 'left': None, 'right': None}
|
||||
if name == root['name']:
|
||||
root['phone'] = phone
|
||||
elif name < root['name']:
|
||||
root['left'] = bst_insert(root['left'], name, phone)
|
||||
else:
|
||||
root['right'] = bst_insert(root['right'], name, phone)
|
||||
return root
|
||||
|
||||
def bst_find(root, name):
|
||||
if root is None:
|
||||
return None
|
||||
if root['name'] == name:
|
||||
return root['phone']
|
||||
elif name<root['name']:
|
||||
return bst_find(root['left'], name)
|
||||
else:
|
||||
return bst_find(root['right'], name)
|
||||
|
||||
def minimum(node):
|
||||
current = node
|
||||
while current['left'] is not None:
|
||||
current = current['left']
|
||||
return current
|
||||
|
||||
def bst_delete(root, name):
|
||||
if root is None:
|
||||
return None
|
||||
if name < root['name']:
|
||||
root['left'] = bst_delete(root['left'], name)
|
||||
elif name > root['name']:
|
||||
root['right'] = bst_delete(root['right'], name)
|
||||
else:
|
||||
if root['left'] is None:
|
||||
return root['right']
|
||||
elif root['right'] is None:
|
||||
return root['left']
|
||||
min=minimum(root['right'])
|
||||
root['name']=min['name']
|
||||
root['phone']=min['phone']
|
||||
root['right']=bst_delete(root['right'], min['name'])
|
||||
return root
|
||||
|
||||
def bst_list_all(root):
|
||||
result=[]
|
||||
if root:
|
||||
result.extend(bst_list_all(root['left']))
|
||||
result.append((root['name'], root['phone']))
|
||||
result.extend(bst_list_all(root['right']))
|
||||
return result
|
||||
|
||||
|
||||
|
||||
#1. Генерация тестовых данных
|
||||
def generate(n=10000):
|
||||
records = [(f"User_{i:05d}", f"+7 ({random.randint(100, 999)}) {random.randint(100, 999)}-{random.randint(00, 99):02}-{random.randint(00, 99):02}") for i in range(n)]
|
||||
records_sorted =records.copy()
|
||||
records_shuffled=records.copy()
|
||||
random.shuffle(records_shuffled)
|
||||
return records_sorted, records_shuffled
|
||||
|
||||
#3.Проведение замеров
|
||||
#А. Вставка всех записей
|
||||
def task_A(structure_name, data):
|
||||
start =time.perf_counter()
|
||||
if structure_name=="LinkedList":
|
||||
head=None
|
||||
for name, phone in data:
|
||||
head = ll_insert(head, name, phone)
|
||||
container=head
|
||||
elif structure_name=="HashTable":
|
||||
buckets=[None]*1000
|
||||
for name, phone in data:
|
||||
ht_insert(buckets, name, phone)
|
||||
container=buckets
|
||||
elif structure_name=="BinarySearchTree":
|
||||
root=None
|
||||
for name, phone in data:
|
||||
root = bst_insert(root, name, phone)
|
||||
container=root
|
||||
end = time.perf_counter()
|
||||
elapsed = end - start
|
||||
return elapsed, container
|
||||
|
||||
#Б. Поиск 100 случайных записей
|
||||
def task_B(structure_name,container, data):
|
||||
start=time.perf_counter()
|
||||
if structure_name=="LinkedList":
|
||||
for name in data:
|
||||
ll_find(container, name)
|
||||
elif structure_name=="HashTable":
|
||||
for name in data:
|
||||
ht_find(container, name)
|
||||
elif structure_name=="BinarySearchTree":
|
||||
for name in data:
|
||||
bst_find(container, name)
|
||||
end=time.perf_counter()
|
||||
elapsed = end - start
|
||||
return elapsed
|
||||
|
||||
#В. Удаление 50 случайных чисел
|
||||
def task_C(structure_name,container, data):
|
||||
start=time.perf_counter()
|
||||
if structure_name=="LinkedList":
|
||||
for name in data:
|
||||
container=ll_delete(container, name)
|
||||
elif structure_name=="HashTable":
|
||||
for name in data:
|
||||
ht_delete(container, name)
|
||||
elif structure_name=="BinarySearchTree":
|
||||
for name in data:
|
||||
container = bst_delete(container, name)
|
||||
end=time.perf_counter()
|
||||
elapsed = end - start
|
||||
return elapsed
|
||||
results=[["Структура", "Режим", "Операция", "Время (сек)"]]
|
||||
structures_name=["LinkedList", "HashTable", "BinarySearchTree"]
|
||||
experiment_name=["Вставка", "Поиск", "Удаление"]
|
||||
mode_of_data=["Случайный", "Отсортированный"]
|
||||
|
||||
records_sorted, records_shuffled = generate()
|
||||
container_shuffled=[]#хранилище структур со случайными данными
|
||||
container_sorted=[]#хранилище структур с отсортированными данными
|
||||
names=[record[0] for record in records_shuffled]
|
||||
#Данные для задания Б
|
||||
random_names=random.sample(names, 100)
|
||||
missing_names=[f"None_{i}" for i in range(10)]
|
||||
names_for_test=random_names+missing_names
|
||||
#Данные для задания В
|
||||
names_to_delete=random.sample(names,50)
|
||||
|
||||
for i in range(3):
|
||||
container_shuffled.append(task_A(structures_name[i], records_shuffled)[1])
|
||||
container_sorted.append(task_A(structures_name[i], records_sorted)[1])
|
||||
for j in range(5):
|
||||
# Реализация задания А
|
||||
result_shuffled = task_A(structures_name[i], records_shuffled)[0]
|
||||
results.append([structures_name[i], mode_of_data[0], experiment_name[0], result_shuffled])
|
||||
|
||||
result_sorted= task_A(structures_name[i], records_sorted)[0]
|
||||
results.append([structures_name[i], mode_of_data[1], experiment_name[0], result_sorted])
|
||||
print(f"{structures_name[i]}: Время вставки всех записей {mode_of_data[0]}: {result_shuffled} {mode_of_data[1]}: {result_sorted}")
|
||||
# Реализация задания Б
|
||||
result_shuffled = task_B(structures_name[i], container_shuffled[i], names_for_test)
|
||||
results.append([structures_name[i], mode_of_data[0], experiment_name[1], result_shuffled])
|
||||
|
||||
result_sorted = task_B(structures_name[i], container_sorted[i], names_for_test)
|
||||
results.append([structures_name[i], mode_of_data[1], experiment_name[1], result_sorted])
|
||||
print(f"{structures_name[i]}: Время нахождения 110 записей для {mode_of_data[0]}: {result_shuffled} {mode_of_data[1]}: {result_sorted} ")
|
||||
#Реализация задания В
|
||||
shuffled = container_shuffled[i]
|
||||
sorted = container_sorted[i]
|
||||
result_shuffled = task_C(structures_name[i], shuffled, names_to_delete)
|
||||
results.append([structures_name[i], mode_of_data[0], experiment_name[2], result_shuffled])
|
||||
|
||||
result_sorted = task_C(structures_name[i], sorted, names_to_delete)
|
||||
results.append([structures_name[i], mode_of_data[1], experiment_name[2], result_sorted])
|
||||
print(f"{structures_name[i]}: Время удаления 50 записей для {mode_of_data[0]}: {result_shuffled} {mode_of_data[1]}: {result_sorted}")
|
||||
|
||||
#4. Сохранение результатов\
|
||||
current_dir=Path.cwd()
|
||||
target=current_dir.parent/"docs"/"data"
|
||||
csv_file=target /"results.csv"
|
||||
with open(csv_file, "w", newline="",encoding="utf-8-sig") as f:
|
||||
writer = csv.writer(f)
|
||||
writer.writerows(results)
|
||||
|
||||
#Построение графиков
|
||||
df = pd.read_csv(csv_file)
|
||||
df_avg = df.groupby(["Структура", "Режим", "Операция"])["Время (сек)"].mean().reset_index()
|
||||
fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharey=True)
|
||||
for i, experiment in enumerate(experiment_name):
|
||||
data_experiment = df_avg[df_avg["Операция"] == experiment]
|
||||
sns.barplot(ax=axes[i],data=data_experiment, x="Структура",y="Время (сек)",hue="Режим")
|
||||
axes[i].set_title(experiment)
|
||||
axes[i].set_ylabel("Среднее время (сек)")
|
||||
axes[i].set_yscale("log")
|
||||
plt.tight_layout()
|
||||
png_file= target/"graphics.png"
|
||||
plt.savefig(png_file, dpi=300, bbox_inches='tight')
|
||||
plt.show()
|
||||
|
|
@ -1 +0,0 @@
|
|||
428
|
||||
|
|
@ -1 +0,0 @@
|
|||
429
|
||||
|
|
@ -1 +0,0 @@
|
|||
428b.md
|
||||
|
|
@ -1 +0,0 @@
|
|||
428b
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
{\rtf1\ansi\ansicpg1251\cocoartf2869
|
||||
\cocoatextscaling0\cocoaplatform0{\fonttbl}
|
||||
{\colortbl;\red255\green255\blue255;}
|
||||
{\*\expandedcolortbl;;}
|
||||
\paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
|
||||
}
|
||||
Binary file not shown.
|
|
@ -1 +0,0 @@
|
|||
428b
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
{\rtf1\ansi\ansicpg1251\cocoartf2761
|
||||
\cocoatextscaling0\cocoaplatform0{\fonttbl}
|
||||
{\colortbl;\red255\green255\blue255;}
|
||||
{\*\expandedcolortbl;;}
|
||||
\paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
<EFBFBD>¥¦¨¬ ¢כ¢®₪ ×®¬ ₪ ם×א (ECHO) ¢×«מח¥.
|
||||
|
|
@ -1 +0,0 @@
|
|||
|
||||
|
|
@ -1 +0,0 @@
|
|||
<EFBFBD>¥¦¨¬ ¢כ¢®₪ ×®¬ ₪ ם×א (ECHO) ¢×«מח¥.
|
||||
|
|
@ -1 +0,0 @@
|
|||
428b
|
||||
|
|
@ -1 +0,0 @@
|
|||
|
||||
|
|
@ -1 +0,0 @@
|
|||
ыфыв
|
||||
Loading…
Reference in New Issue
Block a user