diff --git a/BudakovIS/428.md b/BudakovIS/428.md new file mode 100644 index 0000000..e69de29 diff --git a/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py b/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py new file mode 100644 index 0000000..3a30714 --- /dev/null +++ b/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py @@ -0,0 +1,457 @@ +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']: + 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() diff --git a/BudakovIS/docs/data/1-st-exercize/experiment_results.csv b/BudakovIS/docs/data/1-st-exercize/experiment_results.csv new file mode 100644 index 0000000..e754dc6 --- /dev/null +++ b/BudakovIS/docs/data/1-st-exercize/experiment_results.csv @@ -0,0 +1,31 @@ +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 diff --git a/BudakovIS/docs/data/1-st-exercize/plot_results.py b/BudakovIS/docs/data/1-st-exercize/plot_results.py new file mode 100644 index 0000000..8eb2e7a --- /dev/null +++ b/BudakovIS/docs/data/1-st-exercize/plot_results.py @@ -0,0 +1,44 @@ +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() diff --git a/BudakovIS/docs/performance_comparison.png b/BudakovIS/docs/performance_comparison.png new file mode 100644 index 0000000..ef3e2e0 Binary files /dev/null and b/BudakovIS/docs/performance_comparison.png differ diff --git a/BudakovIS/docs/report_1-st-exersize.md b/BudakovIS/docs/report_1-st-exersize.md new file mode 100644 index 0000000..487fc81 --- /dev/null +++ b/BudakovIS/docs/report_1-st-exersize.md @@ -0,0 +1,59 @@ +# Отчёт по лабораторной работе "Структуры данных" + +## 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 | + +Графическое представление результатов приведено на рисунке ниже. + +![Сравнение производительности](performance_comparison.png) + +## 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 diff --git a/README.md b/README.md index e41f347..110fba1 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ [Презентация по курсу (обновляемая)](https://docs.google.com/presentation/d/1wmYjy5QDoYECEHi7NAAINPulU9pLsaIi-aLaUppspps/edit?usp=sharing) -Для работы необходим python 3.10 и выше. Библиотеки: numpy, pandas, matplotlib, tensorflow, Pillow. Редактор любой. Из неплохих: IDLE (родной, идёт вместе с установщиком), Visual Studio Code, notepad++, PyCharm, vim (для любителей сначала страдать, потом наслаждаться). +Для работы необходим python 3.11 и выше. Библиотеки: numpy, pandas, matplotlib, tensorflow, Pillow. Редактор любой. Из неплохих: IDLE (родной, идёт вместе с установщиком), Visual Studio Code, notepad++, PyCharm, vim (для любителей сначала страдать, потом наслаждаться). Работа с блокнотами онлайн, с возможностью подключения удалённых мощностей гугла (GPU, TPU): https://colab.research.google.com/ @@ -14,4 +14,186 @@ **Название пулл-реквеста должно начинаться с квадратных скобок, в которых перечислены номера сдаваемых лабораторных работ. Не больше одного активного реквеста, если надо довнести -- надо обновить текущий.** -## Крайний срок приема работ 25.05.2026 до 14:00 +### Крайний срок приема работ 25.05.2026 до 14:00 + +## Задание 0 -- репозиторий [отдельный срок на создание PR с папкой: 28.02.2026] + +0. Создай пользователя (логин — фамилия+инициалы слитно транслитом, как в терминал-классе). + +1. Зайди в этот репозиторий на Gitea, нажми кнопку **Форкнуть**, чтобы создать копию в своем аккаунте. + +2. **Клонирование:** Скопируй ссылку на свой форк и выполни: + ```bash + git clone <ссылка_на_ваш_форк> + cd <название_репозитория> + ``` + +3. **Создай ветку** (название — фамилия+инициалы слитно транслитом, буква в букву как логин): + ```bash + git checkout -b IvanovII + ``` + +4. **Создай папку** с таким же названием (`IvanovII`) и внутри неё — текстовый файл, названный номером вашей группы (например, `101.md`). + +5. **Сохрани изменения:** + ```bash + git add -A + git commit -m "[0] initial commit" + ``` + +6. Отправь ветку **в свой форк** на Gitea: + ```bash + git push origin + ``` + +если просит, перед этим сделать git push --set-upstream origin + +7. **Создай запрос на слияние (Pull Request):** На Gitea перейди в свой форк, выбери ветку `IvanovII`, нажмите **Запрос на слияние**. Убедитесь, что: + - Базовый репозиторий: **учебный** (преподавателя) + - Базовая ветка: **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) на отсортированных данных). + +- Почему хеш-таблица почти не чувствительна к порядку. + +- Почему связный список всегда медленен при поиске. + +- Как удаление работает в каждой структуре. + +* Вывод должен содержать ответ на вопрос: какую структуру и для каких задач (частые вставки, частый поиск, необходимость получать данные в порядке) стоит выбирать в реальной жизни.* diff --git a/testfile.txt b/testfile.txt deleted file mode 100644 index 4d19fd2..0000000 --- a/testfile.txt +++ /dev/null @@ -1 +0,0 @@ -Проверочный файл`: 0123