395 lines
14 KiB
Python
395 lines
14 KiB
Python
|
import time
|
|||
|
|
import random
|
|||
|
|
import csv
|
|||
|
|
import sys
|
|||
|
|
sys.setrecursionlimit(100000)
|
|||
|
|
|
|||
|
|
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:
|
|||
|
|
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):
|
|||
|
|
records = []
|
|||
|
|
curr = head
|
|||
|
|
while curr:
|
|||
|
|
records.append((curr['name'], curr['phone']))
|
|||
|
|
curr = curr['next']
|
|||
|
|
records.sort(key=lambda x: x[0])
|
|||
|
|
return records
|
|||
|
|
|
|||
|
|
def hash_function(name, table_size):
|
|||
|
|
return sum(ord(c) for c in name) % table_size
|
|||
|
|
|
|||
|
|
def ht_create(size=1000):
|
|||
|
|
return [None] * size
|
|||
|
|
|
|||
|
|
def ht_insert(buckets, name, phone):
|
|||
|
|
index = hash_function(name, len(buckets))
|
|||
|
|
buckets[index] = ll_insert(buckets[index], name, phone)
|
|||
|
|
|
|||
|
|
def ht_find(buckets, name):
|
|||
|
|
index = hash_function(name, len(buckets))
|
|||
|
|
return ll_find(buckets[index], name)
|
|||
|
|
|
|||
|
|
def ht_delete(buckets, name):
|
|||
|
|
index = hash_function(name, len(buckets))
|
|||
|
|
buckets[index] = ll_delete(buckets[index], name)
|
|||
|
|
|
|||
|
|
def ht_list_all(buckets):
|
|||
|
|
records = []
|
|||
|
|
for head in buckets:
|
|||
|
|
curr = head
|
|||
|
|
while curr:
|
|||
|
|
records.append((curr['name'], curr['phone']))
|
|||
|
|
curr = curr['next']
|
|||
|
|
records.sort(key=lambda x: x[0])
|
|||
|
|
return records
|
|||
|
|
|
|||
|
|
def bst_insert_iterative(root, name, phone):
|
|||
|
|
new_node = {'name': name, 'phone': phone, 'left': None, 'right': None}
|
|||
|
|
|
|||
|
|
if root is None:
|
|||
|
|
return new_node
|
|||
|
|
|
|||
|
|
curr = root
|
|||
|
|
while True:
|
|||
|
|
if name < curr['name']:
|
|||
|
|
if curr['left'] is None:
|
|||
|
|
curr['left'] = new_node
|
|||
|
|
break
|
|||
|
|
curr = curr['left']
|
|||
|
|
elif name > curr['name']:
|
|||
|
|
if curr['right'] is None:
|
|||
|
|
curr['right'] = new_node
|
|||
|
|
break
|
|||
|
|
curr = curr['right']
|
|||
|
|
else:
|
|||
|
|
curr['phone'] = phone
|
|||
|
|
break
|
|||
|
|
|
|||
|
|
return root
|
|||
|
|
|
|||
|
|
def bst_find_iterative(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_find_min(node):
|
|||
|
|
while node and node['left']:
|
|||
|
|
node = node['left']
|
|||
|
|
return node
|
|||
|
|
|
|||
|
|
def bst_delete_iterative(root, name):
|
|||
|
|
if root is None:
|
|||
|
|
return None
|
|||
|
|
|
|||
|
|
if name < root['name']:
|
|||
|
|
root['left'] = bst_delete_iterative(root['left'], name)
|
|||
|
|
elif name > root['name']:
|
|||
|
|
root['right'] = bst_delete_iterative(root['right'], name)
|
|||
|
|
else:
|
|||
|
|
if root['left'] is None:
|
|||
|
|
return root['right']
|
|||
|
|
elif root['right'] is None:
|
|||
|
|
return root['left']
|
|||
|
|
|
|||
|
|
parent = root
|
|||
|
|
successor = root['right']
|
|||
|
|
while successor['left']:
|
|||
|
|
parent = successor
|
|||
|
|
successor = successor['left']
|
|||
|
|
|
|||
|
|
root['name'] = successor['name']
|
|||
|
|
root['phone'] = successor['phone']
|
|||
|
|
|
|||
|
|
if parent == root:
|
|||
|
|
parent['right'] = successor['right']
|
|||
|
|
else:
|
|||
|
|
parent['left'] = successor['right']
|
|||
|
|
|
|||
|
|
return root
|
|||
|
|
|
|||
|
|
def bst_list_all(root):
|
|||
|
|
result = []
|
|||
|
|
stack = []
|
|||
|
|
curr = root
|
|||
|
|
|
|||
|
|
while stack or curr:
|
|||
|
|
while curr:
|
|||
|
|
stack.append(curr)
|
|||
|
|
curr = curr['left']
|
|||
|
|
curr = stack.pop()
|
|||
|
|
result.append((curr['name'], curr['phone']))
|
|||
|
|
curr = curr['right']
|
|||
|
|
|
|||
|
|
return result
|
|||
|
|
|
|||
|
|
def generate_test_data(N=10000):
|
|||
|
|
names = [f"User_{i:05d}" for i in range(N)]
|
|||
|
|
phones = [f"+7-999-{random.randint(1000000, 9999999)}" for _ in range(N)]
|
|||
|
|
|
|||
|
|
records = list(zip(names, phones))
|
|||
|
|
|
|||
|
|
records_shuffled = records.copy()
|
|||
|
|
random.shuffle(records_shuffled)
|
|||
|
|
|
|||
|
|
records_sorted = sorted(records, key=lambda x: x[0])
|
|||
|
|
|
|||
|
|
return records_shuffled, records_sorted
|
|||
|
|
|
|||
|
|
def measure_insertion(structure_type, records, ht_size=1000):
|
|||
|
|
if structure_type == "LinkedList":
|
|||
|
|
head = None
|
|||
|
|
start = time.perf_counter()
|
|||
|
|
for name, phone in records:
|
|||
|
|
head = ll_insert(head, name, phone)
|
|||
|
|
end = time.perf_counter()
|
|||
|
|
return head, (end - start)
|
|||
|
|
|
|||
|
|
elif structure_type == "HashTable":
|
|||
|
|
buckets = ht_create(ht_size)
|
|||
|
|
start = time.perf_counter()
|
|||
|
|
for name, phone in records:
|
|||
|
|
ht_insert(buckets, name, phone)
|
|||
|
|
end = time.perf_counter()
|
|||
|
|
return buckets, (end - start)
|
|||
|
|
|
|||
|
|
elif structure_type == "BST":
|
|||
|
|
root = None
|
|||
|
|
start = time.perf_counter()
|
|||
|
|
for name, phone in records:
|
|||
|
|
root = bst_insert_iterative(root, name, phone)
|
|||
|
|
end = time.perf_counter()
|
|||
|
|
return root, (end - start)
|
|||
|
|
|
|||
|
|
def measure_search(data_structure, structure_type, existing_names, non_existing_names):
|
|||
|
|
start = time.perf_counter()
|
|||
|
|
for name in existing_names:
|
|||
|
|
if structure_type == "LinkedList":
|
|||
|
|
ll_find(data_structure, name)
|
|||
|
|
elif structure_type == "HashTable":
|
|||
|
|
ht_find(data_structure, name)
|
|||
|
|
elif structure_type == "BST":
|
|||
|
|
bst_find_iterative(data_structure, name)
|
|||
|
|
|
|||
|
|
for name in non_existing_names:
|
|||
|
|
if structure_type == "LinkedList":
|
|||
|
|
ll_find(data_structure, name)
|
|||
|
|
elif structure_type == "HashTable":
|
|||
|
|
ht_find(data_structure, name)
|
|||
|
|
elif structure_type == "BST":
|
|||
|
|
bst_find_iterative(data_structure, name)
|
|||
|
|
end = time.perf_counter()
|
|||
|
|
|
|||
|
|
return end - start
|
|||
|
|
|
|||
|
|
def measure_deletion(data_structure, structure_type, names_to_delete):
|
|||
|
|
start = time.perf_counter()
|
|||
|
|
for name in names_to_delete:
|
|||
|
|
if structure_type == "LinkedList":
|
|||
|
|
data_structure = ll_delete(data_structure, name)
|
|||
|
|
elif structure_type == "HashTable":
|
|||
|
|
ht_delete(data_structure, name)
|
|||
|
|
elif structure_type == "BST":
|
|||
|
|
data_structure = bst_delete_iterative(data_structure, name)
|
|||
|
|
end = time.perf_counter()
|
|||
|
|
|
|||
|
|
return data_structure, (end - start)
|
|||
|
|
|
|||
|
|
def run_experiment(N=5000, repeats=5):
|
|||
|
|
print(f"Генерация тестовых данных (N={N})...")
|
|||
|
|
records_shuffled, records_sorted = generate_test_data(N)
|
|||
|
|
|
|||
|
|
existing_names = [name for name, _ in random.sample(records_shuffled, min(100, N))]
|
|||
|
|
non_existing_names = [f"None_{i}" for i in range(10)]
|
|||
|
|
delete_names = [name for name, _ in random.sample(records_shuffled, min(50, N))]
|
|||
|
|
|
|||
|
|
results = []
|
|||
|
|
|
|||
|
|
structures = ["LinkedList", "HashTable", "BST"]
|
|||
|
|
modes = ["случайный", "отсортированный"]
|
|||
|
|
|
|||
|
|
for struct in structures:
|
|||
|
|
for mode in modes:
|
|||
|
|
records = records_shuffled if mode == "случайный" else records_sorted
|
|||
|
|
|
|||
|
|
print(f"\nТестирование: {struct}, режим: {mode}")
|
|||
|
|
|
|||
|
|
insertion_times = []
|
|||
|
|
search_times = []
|
|||
|
|
deletion_times = []
|
|||
|
|
|
|||
|
|
for rep in range(repeats):
|
|||
|
|
print(f" Повторение {rep+1}/{repeats}...")
|
|||
|
|
|
|||
|
|
data_structure, insert_time = measure_insertion(struct, records)
|
|||
|
|
insertion_times.append(insert_time)
|
|||
|
|
|
|||
|
|
search_time = measure_search(data_structure, struct, existing_names, non_existing_names)
|
|||
|
|
search_times.append(search_time)
|
|||
|
|
|
|||
|
|
data_structure, delete_time = measure_deletion(data_structure, struct, delete_names)
|
|||
|
|
deletion_times.append(delete_time)
|
|||
|
|
|
|||
|
|
avg_insert = sum(insertion_times) / repeats
|
|||
|
|
avg_search = sum(search_times) / repeats
|
|||
|
|
avg_delete = sum(deletion_times) / repeats
|
|||
|
|
|
|||
|
|
results.append({
|
|||
|
|
"structure": struct,
|
|||
|
|
"mode": mode,
|
|||
|
|
"insertion_avg": avg_insert,
|
|||
|
|
"insertion_all": insertion_times,
|
|||
|
|
"search_avg": avg_search,
|
|||
|
|
"search_all": search_times,
|
|||
|
|
"deletion_avg": avg_delete,
|
|||
|
|
"deletion_all": deletion_times
|
|||
|
|
})
|
|||
|
|
|
|||
|
|
print(f" Вставка: {avg_insert:.6f} сек (замеры: {[f'{t:.6f}' for t in insertion_times]})")
|
|||
|
|
print(f" Поиск: {avg_search:.6f} сек (замеры: {[f'{t:.6f}' for t in search_times]})")
|
|||
|
|
print(f" Удаление: {avg_delete:.6f} сек (замеры: {[f'{t:.6f}' for t in deletion_times]})")
|
|||
|
|
|
|||
|
|
return results
|
|||
|
|
|
|||
|
|
def save_results_to_csv(results, filename="results.csv"):
|
|||
|
|
with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
|
|||
|
|
writer = csv.writer(csvfile)
|
|||
|
|
writer.writerow(["Структура", "Режим", "Операция", "Повторение", "Время (сек)"])
|
|||
|
|
|
|||
|
|
for res in results:
|
|||
|
|
struct = res["structure"]
|
|||
|
|
mode = res["mode"]
|
|||
|
|
|
|||
|
|
for i, t in enumerate(res["insertion_all"]):
|
|||
|
|
writer.writerow([struct, mode, "вставка", i+1, t])
|
|||
|
|
writer.writerow([struct, mode, "вставка", "СРЕДНЕЕ", res["insertion_avg"]])
|
|||
|
|
|
|||
|
|
for i, t in enumerate(res["search_all"]):
|
|||
|
|
writer.writerow([struct, mode, "поиск", i+1, t])
|
|||
|
|
writer.writerow([struct, mode, "поиск", "СРЕДНЕЕ", res["search_avg"]])
|
|||
|
|
|
|||
|
|
for i, t in enumerate(res["deletion_all"]):
|
|||
|
|
writer.writerow([struct, mode, "удаление", i+1, t])
|
|||
|
|
writer.writerow([struct, mode, "удаление", "СРЕДНЕЕ", res["deletion_avg"]])
|
|||
|
|
|
|||
|
|
print(f"\nРезультаты сохранены в {filename}")
|
|||
|
|
|
|||
|
|
def print_summary_table(results):
|
|||
|
|
print("\n" + "="*80)
|
|||
|
|
print("СВОДНАЯ ТАБЛИЦА РЕЗУЛЬТАТОВ (среднее время в секундах)")
|
|||
|
|
print("="*80)
|
|||
|
|
print(f"{'Структура':<15} {'Режим':<12} {'Вставка':<12} {'Поиск (110)':<12} {'Удаление (50)':<12}")
|
|||
|
|
print("-"*80)
|
|||
|
|
|
|||
|
|
for res in results:
|
|||
|
|
print(f"{res['structure']:<15} {res['mode']:<12} {res['insertion_avg']:<12.6f} "
|
|||
|
|
f"{res['search_avg']:<12.6f} {res['deletion_avg']:<12.6f}")
|
|||
|
|
|
|||
|
|
print("\n" + "="*80)
|
|||
|
|
print("АНАЛИЗ ДЕГРАДАЦИИ BST")
|
|||
|
|
print("="*80)
|
|||
|
|
|
|||
|
|
bst_random = next(r for r in results if r['structure'] == "BST" and r['mode'] == "случайный")
|
|||
|
|
bst_sorted = next(r for r in results if r['structure'] == "BST" and r['mode'] == "отсортированный")
|
|||
|
|
|
|||
|
|
degradation = bst_sorted['insertion_avg'] / bst_random['insertion_avg']
|
|||
|
|
print(f"BST: отсортированные данные в {degradation:.1f} раз медленнее случайных")
|
|||
|
|
print("Причина: вырождение дерева в линейный связный список (O(n) вместо O(log n))")
|
|||
|
|
|
|||
|
|
if __name__ == "__main__":
|
|||
|
|
print("="*80)
|
|||
|
|
print("ЭКСПЕРИМЕНТАЛЬНОЕ СРАВНЕНИЕ СТРУКТУР ДАННЫХ ДЛЯ ТЕЛЕФОННОГО СПРАВОЧНИКА")
|
|||
|
|
print("="*80)
|
|||
|
|
|
|||
|
|
results = run_experiment(N=5000, repeats=5)
|
|||
|
|
|
|||
|
|
save_results_to_csv(results)
|
|||
|
|
|
|||
|
|
print_summary_table(results)
|
|||
|
|
|
|||
|
|
print("\n" + "="*80)
|
|||
|
|
print("ВЫВОДЫ И РЕКОМЕНДАЦИИ")
|
|||
|
|
print("="*80)
|
|||
|
|
print("""
|
|||
|
|
1. Хеш-таблица:
|
|||
|
|
Лучшая производительность для операций поиска и вставки (O(1) в среднем)
|
|||
|
|
Не чувствительна к порядку входных данных
|
|||
|
|
Требует память под массив бакетов
|
|||
|
|
Не поддерживает естественный порядок (нужна сортировка)
|
|||
|
|
Идеально для справочников с частым поиском
|
|||
|
|
|
|||
|
|
2. Двоичное дерево поиска:
|
|||
|
|
Естественная сортировка (in-order обход)
|
|||
|
|
Хорошая производительность на случайных данных (O(log n))
|
|||
|
|
Сильная деградация на отсортированных данных (O(n))
|
|||
|
|
Рекурсивные операции требуют больше памяти
|
|||
|
|
Хорошо для задач, где нужен отсортированный вывод
|
|||
|
|
|
|||
|
|
3. Связный список:
|
|||
|
|
Простота реализации
|
|||
|
|
Медленный поиск и удаление (O(n))
|
|||
|
|
Неэффективен для больших объёмов данных
|
|||
|
|
Применим только для очень маленьких справочников
|
|||
|
|
|
|||
|
|
РЕКОМЕНДАЦИИ ДЛЯ РЕАЛЬНЫХ ЗАДАЧ:
|
|||
|
|
Частый поиск, редкие вставки -> ХЕШ-ТАБЛИЦА
|
|||
|
|
Нужен отсортированный вывод -> ДЕРЕВО (с балансировкой)
|
|||
|
|
Очень маленький справочник (<100 записей) -> СПИСОК
|
|||
|
|
В реальных БД -> хеш-таблица + B-деревья
|
|||
|
|
""")
|
|||
|
|
|
|||
|
|
print("\n" + "="*80)
|
|||
|
|
print("ДОПОЛНИТЕЛЬНЫЙ АНАЛИЗ")
|
|||
|
|
print("="*80)
|
|||
|
|
|
|||
|
|
for struct in ["LinkedList", "HashTable", "BST"]:
|
|||
|
|
res_random = next(r for r in results if r['structure'] == struct and r['mode'] == "случайный")
|
|||
|
|
print(f"{struct:12} поиск 110 записей: {res_random['search_avg']:.6f} сек")
|
|||
|
|
|
|||
|
|
ll_random = next(r for r in results if r['structure'] == "LinkedList" and r['mode'] == "случайный")
|
|||
|
|
ll_sorted = next(r for r in results if r['structure'] == "LinkedList" and r['mode'] == "отсортированный")
|
|||
|
|
print(f"\nСвязный список: деградация {ll_sorted['insertion_avg'] / ll_random['insertion_avg']:.2f}х")
|