433 lines
10 KiB
Python
433 lines
10 KiB
Python
import sys
|
||
sys.setrecursionlimit(30000)
|
||
|
||
csv_path = '/stepinim/docs/data/lab1_results.csv'
|
||
|
||
#Связный список
|
||
def ll_insert(head, name, phone):
|
||
new_node = {'name': name, 'phone': phone, 'next': None}
|
||
if head is None:
|
||
return new_node
|
||
|
||
curr = head
|
||
prev = None
|
||
while curr is not None:
|
||
if curr['name'] == name:
|
||
curr['phone'] = phone
|
||
return head
|
||
prev = curr
|
||
curr = curr['next']
|
||
prev['next'] = new_node
|
||
return head
|
||
|
||
def ll_find(head, name):
|
||
curr = head
|
||
while curr:
|
||
if curr['name'] == name:
|
||
return curr['phone']
|
||
curr = curr['next']
|
||
return None
|
||
|
||
def ll_delete(head, name):
|
||
if head is None:
|
||
return None
|
||
if head['name'] == name:
|
||
return head['next']
|
||
curr = head
|
||
while curr['next']:
|
||
if curr['next']['name'] == name:
|
||
curr['next'] = curr['next']['next']
|
||
return head
|
||
curr = curr['next']
|
||
return head
|
||
|
||
def ll_list_all(head):
|
||
result = []
|
||
curr = head
|
||
while curr:
|
||
result.append((curr['name'], curr['phone']))
|
||
curr = curr['next']
|
||
result.sort(key=lambda x: x[0])
|
||
return result
|
||
|
||
#Хэш-таблица
|
||
HASH_SIZE = 1009
|
||
def _hash_name(name):
|
||
return hash(name) % HASH_SIZE
|
||
|
||
def ht_insert(buckets, name, phone):
|
||
idx = _hash_name(name)
|
||
buckets[idx] = ll_insert(buckets[idx], name, phone)
|
||
|
||
def ht_find(buckets, name):
|
||
idx = _hash_name(name)
|
||
return ll_find(buckets[idx], name)
|
||
|
||
def ht_delete(buckets, name):
|
||
idx = _hash_name(name)
|
||
buckets[idx] = ll_delete(buckets[idx], name)
|
||
|
||
def ht_list_all(buckets):
|
||
all_entries = []
|
||
for bucket in buckets:
|
||
if bucket is not None:
|
||
curr = bucket
|
||
while curr:
|
||
all_entries.append((curr['name'], curr['phone']))
|
||
curr = curr['next']
|
||
all_entries.sort(key=lambda x: x[0])
|
||
return all_entries
|
||
|
||
#Двоичное дерево поиска
|
||
def bst_insert(root, name, phone):
|
||
if root is None:
|
||
return {'name': name, 'phone': phone, 'left': None, 'right': None}
|
||
if name < root['name']:
|
||
root['left'] = bst_insert(root['left'], name, phone)
|
||
elif name > root['name']:
|
||
root['right'] = bst_insert(root['right'], name, phone)
|
||
else:
|
||
root['phone'] = phone
|
||
return root
|
||
|
||
def bst_find(root, name):
|
||
curr = root
|
||
while curr:
|
||
if name == curr['name']:
|
||
return curr['phone']
|
||
elif name < curr['name']:
|
||
curr = curr['left']
|
||
else:
|
||
curr = curr['right']
|
||
return None
|
||
|
||
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 = root['right']
|
||
while min_node['left']:
|
||
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 bst_list_all(root):
|
||
result = []
|
||
def inorder(node):
|
||
if node:
|
||
inorder(node['left'])
|
||
result.append((node['name'], node['phone']))
|
||
inorder(node['right'])
|
||
inorder(root)
|
||
return result
|
||
|
||
# ============================================================
|
||
# TECT
|
||
# ============================================================
|
||
|
||
import os
|
||
import random
|
||
import time
|
||
import csv
|
||
import pandas as pd
|
||
import matplotlib.pyplot as plt
|
||
|
||
# ============================================================
|
||
# ПОДГОТОВКА ПАПОК
|
||
# ============================================================
|
||
|
||
DATA_DIR = os.path.join("docs", "data")
|
||
os.makedirs(DATA_DIR, exist_ok=True)
|
||
|
||
csv_path = os.path.join(DATA_DIR, "lab1_results.csv")
|
||
graph_path = os.path.join(DATA_DIR, "lab1_graph.png")
|
||
|
||
# ============================================================
|
||
# ТЕСТОВЫЕ ДАННЫЕ
|
||
# ============================================================
|
||
|
||
random.seed(42)
|
||
|
||
N = 3000
|
||
|
||
base_records = [
|
||
(f"User_{i:05d}", f"123-{i:05d}")
|
||
for i in range(N)
|
||
]
|
||
|
||
records_shuffled = base_records.copy()
|
||
random.shuffle(records_shuffled)
|
||
|
||
records_sorted = sorted(base_records, key=lambda x: x[0])
|
||
|
||
# Поиск
|
||
search_existing = [
|
||
name for name, _ in random.sample(base_records, 100)
|
||
]
|
||
|
||
search_nonexist = [
|
||
f"None_{i}"
|
||
for i in range(10)
|
||
]
|
||
|
||
# Удаление
|
||
delete_names = [
|
||
name for name, _ in random.sample(base_records, 50)
|
||
]
|
||
|
||
# ============================================================
|
||
# СОЗДАНИЕ СТРУКТУР
|
||
# ============================================================
|
||
|
||
def build_structure(records, struct_type):
|
||
|
||
if struct_type == "ll":
|
||
structure = None
|
||
|
||
for name, phone in records:
|
||
structure = ll_insert(structure, name, phone)
|
||
|
||
return structure
|
||
|
||
elif struct_type == "ht":
|
||
structure = [None] * HASH_SIZE
|
||
|
||
for name, phone in records:
|
||
ht_insert(structure, name, phone)
|
||
|
||
return structure
|
||
|
||
elif struct_type == "bst":
|
||
structure = None
|
||
|
||
for name, phone in records:
|
||
structure = bst_insert(structure, name, phone)
|
||
|
||
return structure
|
||
|
||
|
||
# ============================================================
|
||
# INSERT
|
||
# ============================================================
|
||
|
||
def measure_insert(records, struct_type):
|
||
|
||
start = time.perf_counter()
|
||
|
||
build_structure(records, struct_type)
|
||
|
||
end = time.perf_counter()
|
||
|
||
return end - start
|
||
|
||
|
||
# ============================================================
|
||
# SEARCH
|
||
# ============================================================
|
||
|
||
def measure_search(records, struct_type):
|
||
|
||
structure = build_structure(records, struct_type)
|
||
|
||
start = time.perf_counter()
|
||
|
||
if struct_type == "ll":
|
||
for name in search_existing + search_nonexist:
|
||
ll_find(structure, name)
|
||
|
||
elif struct_type == "ht":
|
||
for name in search_existing + search_nonexist:
|
||
ht_find(structure, name)
|
||
|
||
elif struct_type == "bst":
|
||
for name in search_existing + search_nonexist:
|
||
bst_find(structure, name)
|
||
|
||
end = time.perf_counter()
|
||
|
||
return end - start
|
||
|
||
|
||
# ============================================================
|
||
# DELETE
|
||
# ============================================================
|
||
|
||
def measure_delete(records, struct_type):
|
||
|
||
structure = build_structure(records, struct_type)
|
||
|
||
start = time.perf_counter()
|
||
|
||
if struct_type == "ll":
|
||
for name in delete_names:
|
||
structure = ll_delete(structure, name)
|
||
|
||
elif struct_type == "ht":
|
||
for name in delete_names:
|
||
ht_delete(structure, name)
|
||
|
||
elif struct_type == "bst":
|
||
for name in delete_names:
|
||
structure = bst_delete(structure, name)
|
||
|
||
end = time.perf_counter()
|
||
|
||
return end - start
|
||
|
||
|
||
# ============================================================
|
||
# ЗАМЕРЫ
|
||
# ============================================================
|
||
|
||
all_data = []
|
||
|
||
experiments = [
|
||
("LinkedList", "ll"),
|
||
("HashTable", "ht"),
|
||
("BST", "bst")
|
||
]
|
||
|
||
modes = [
|
||
("shuffled", records_shuffled),
|
||
("sorted", records_sorted)
|
||
]
|
||
|
||
for struct_name, struct_type in experiments:
|
||
|
||
for mode_name, records in modes:
|
||
|
||
for rep in range(1, 4):
|
||
|
||
insert_time = measure_insert(records, struct_type)
|
||
|
||
search_time = measure_search(records, struct_type)
|
||
|
||
delete_time = measure_delete(records, struct_type)
|
||
|
||
all_data.append([
|
||
struct_name,
|
||
mode_name,
|
||
rep,
|
||
"insert",
|
||
insert_time
|
||
])
|
||
|
||
all_data.append([
|
||
struct_name,
|
||
mode_name,
|
||
rep,
|
||
"search",
|
||
search_time
|
||
])
|
||
|
||
all_data.append([
|
||
struct_name,
|
||
mode_name,
|
||
rep,
|
||
"delete",
|
||
delete_time
|
||
])
|
||
|
||
# ============================================================
|
||
# CSV
|
||
# ============================================================
|
||
|
||
with open(csv_path, "w", newline="", encoding="utf-8") as f:
|
||
|
||
writer = csv.writer(f)
|
||
|
||
writer.writerow([
|
||
"Структура",
|
||
"Режим",
|
||
"Повтор",
|
||
"Операция",
|
||
"Время (сек)"
|
||
])
|
||
|
||
writer.writerows(all_data)
|
||
|
||
print(f"CSV сохранён: {csv_path}")
|
||
|
||
# ============================================================
|
||
# ГРАФИК
|
||
# ============================================================
|
||
|
||
df = pd.read_csv(csv_path)
|
||
|
||
df_avg = (
|
||
df.groupby(
|
||
["Структура", "Режим", "Операция"]
|
||
)["Время (сек)"]
|
||
.mean()
|
||
.reset_index()
|
||
)
|
||
|
||
fig, ax = plt.subplots(figsize=(12, 6))
|
||
|
||
ops = ["insert", "search", "delete"]
|
||
|
||
x = range(len(ops))
|
||
|
||
width = 0.12
|
||
|
||
configs = [
|
||
("LinkedList", "shuffled"),
|
||
("LinkedList", "sorted"),
|
||
("HashTable", "shuffled"),
|
||
("HashTable", "sorted"),
|
||
("BST", "shuffled"),
|
||
("BST", "sorted")
|
||
]
|
||
|
||
for i, (struct, mode) in enumerate(configs):
|
||
|
||
subset = df_avg[
|
||
(df_avg["Структура"] == struct)
|
||
&
|
||
(df_avg["Режим"] == mode)
|
||
]
|
||
|
||
times = [
|
||
subset[
|
||
subset["Операция"] == op
|
||
]["Время (сек)"].values[0]
|
||
for op in ops
|
||
]
|
||
|
||
ax.bar(
|
||
[p + i * width for p in x],
|
||
times,
|
||
width,
|
||
label=f"{struct} ({mode})"
|
||
)
|
||
|
||
ax.set_xticks([p + 2.5 * width for p in x])
|
||
|
||
ax.set_xticklabels(ops)
|
||
|
||
ax.set_ylabel("Среднее время (сек)")
|
||
|
||
ax.set_title("Сравнение структур данных")
|
||
|
||
ax.legend(
|
||
bbox_to_anchor=(1.05, 1),
|
||
loc="upper left"
|
||
)
|
||
|
||
plt.tight_layout()
|
||
|
||
plt.savefig(graph_path)
|
||
|
||
print(f"График сохранён: {graph_path}")
|
||
|
||
plt.show() |