merge: combine with remote ivantsovma branch

docs: add final report with analysis
report: add final report with analysis
2026-03-21 15:41:46 +03:00 · 2026-03-01 22:12:14 +03:00 · 2026-03-01 22:04:13 +03:00 · 2026-03-01 21:57:18 +03:00 · 2026-03-01 21:56:04 +03:00 · 2026-03-01 21:55:03 +03:00
109 changed files with 723 additions and 959 deletions
--- a/.gitignore
+++ b/.gitignore
@ -7,7 +7,6 @@ __pycache__/
 # C extensions
 *.so
 .DS_Store
 # Distribution / packaging
 .Python
 build/
--- a/BolonkinNM/426.md
+++ b/BolonkinNM/426.md
--- a/BoriskovaDV/428.md
+++ b/BoriskovaDV/428.md
--- a/BorisovMI/429.md
+++ b/BorisovMI/429.md
--- a/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py
+++ b/BudakovIS/docs/data/1-st-exercize/LinkedListPhoneBook.py
@ -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()
--- a/BudakovIS/docs/data/1-st-exercize/experiment_results.csv
+++ b/BudakovIS/docs/data/1-st-exercize/experiment_results.csv
@ -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
--- a/BudakovIS/docs/data/1-st-exercize/plot_results.py
+++ b/BudakovIS/docs/data/1-st-exercize/plot_results.py
@ -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()
--- a/BudakovIS/docs/performance_comparison.png
+++ b/BudakovIS/docs/performance_comparison.png
--- a/BudakovIS/docs/report_1-st-exersize.md
+++ b/BudakovIS/docs/report_1-st-exersize.md
@ -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     |
 Графическое представление результатов приведено на рисунке ниже.
 ![Сравнение производительности](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
--- a/DerbenevRY/428.md
+++ b/DerbenevRY/428.md
--- a/Ezhovnd/425.md
+++ b/Ezhovnd/425.md
@ -1 +0,0 @@
 hi
--- a/GorkinMM/425.md
+++ b/GorkinMM/425.md
--- a/GutovVM/428b.md
+++ b/GutovVM/428b.md
--- a/KislyuninED/428.md
+++ b/KislyuninED/428.md
--- a/KolbasovPD/425.md
+++ b/KolbasovPD/425.md
--- a/KorotkinSE/428b.md
+++ b/KorotkinSE/428b.md
--- a/KuzminskiyAA/427.md
+++ b/KuzminskiyAA/427.md
@ -1 +0,0 @@
--- a/KuznetsovAS/427.md
+++ b/KuznetsovAS/427.md
--- a/KuznetsovMA/429.txt
+++ b/KuznetsovMA/429.txt
--- a/KuznetsovYuM/428.md
+++ b/KuznetsovYuM/428.md
@ -1 +0,0 @@
 428
--- a/LarikovaAA/428b.md
+++ b/LarikovaAA/428b.md
--- a/LukovnikovDE/428.md
+++ b/LukovnikovDE/428.md
--- a/MalkinMV/428b.md
+++ b/MalkinMV/428b.md
@ -1 +0,0 @@
 428b
--- a/MarkinAM/428b.md
+++ b/MarkinAM/428b.md
--- a/MashinDD/429.txt
+++ b/MashinDD/429.txt
--- a/MininaVD/427.txt
+++ b/MininaVD/427.txt
@ -1 +0,0 @@
 427.txt 
--- a/MininaVD/MininaVD
+++ b/MininaVD/MininaVD
@ -1 +0,0 @@
 427.txt 
--- a/MochalovAE/426.txt
+++ b/MochalovAE/426.txt
--- a/MusinAA/428b.md
+++ b/MusinAA/428b.md
--- a/MylnikovAS/427.md
+++ b/MylnikovAS/427.md
@ -1 +0,0 @@
--- a/ProninVV/427.md
+++ b/ProninVV/427.md
--- a/ProninVV/file.txt
+++ b/ProninVV/file.txt
--- a/README.md
+++ b/README.md
@ -1,3 +1,6 @@
 <<<<<<< HEAD
 # PhoneBookProject 
 =======
 # 2026-MP
 Практика по курсам "Методы программирования" и "Программная инженерия" РФФ ННГУ
@ -16,7 +19,7 @@
 ### Крайний срок приема работ 25.05.2026 до 14:00
-## Задание 0 -- репозиторий [отдельный срок на создание PR с папкой: 28.02.2026]
+## Задание 1 -- репозиторий [отдельный срок на создание PR с папкой: 28.02.2026]
 0. Создай пользователя (логин — фамилия+инициалы слитно транслитом, как в терминал-классе).
@ -43,340 +46,13 @@
 6.  Отправь ветку **в свой форк** на Gitea:
    ```bash
-    git push origin
+    git push origin IvanovII
    ```
 если просит, перед этим сделать git push --set-upstream origin
 7.  **Создай запрос на слияние (Pull Request):** На Gitea перейди в свой форк, выбери ветку `IvanovII`, нажмите **Запрос на слияние**. Убедитесь, что:
    - Базовый репозиторий: **учебный** (преподавателя)
    - Базовая ветка: **develop**
    - Сравниваемая ветка: **свой форк / IvanovII**
 8.  Отправь PR.
-
+>>>>>>> 7000ccc96cfc1bd124dd4e1eeb3ccca21f5e38b4
 ## Задание 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')` для перерисовки.
--- a/SavelevMI/428.md
+++ b/SavelevMI/428.md
--- a/ShulpinIN/428.md
+++ b/ShulpinIN/428.md
--- a/Smirnovvs/428.txt
+++ b/Smirnovvs/428.txt
--- a/SobolevNS/426
+++ b/SobolevNS/426
--- a/SokolovEN/426
+++ b/SokolovEN/426
--- a/SokolovNE/428b.md.txt
+++ b/SokolovNE/428b.md.txt
--- a/SolovevDD/425.md
+++ b/SolovevDD/425.md
--- a/SolovevDS/428b.md
+++ b/SolovevDS/428b.md
--- a/SorokinAD/428.md
+++ b/SorokinAD/428.md
@ -1 +0,0 @@
 1
--- a/VaravinVV/428b
+++ b/VaravinVV/428b
@ -1 +0,0 @@
 428b 
--- a/VarnakovAA/429.md
+++ b/VarnakovAA/429.md
--- a/VildyaevAV/426
+++ b/VildyaevAV/426
--- a/VolkovVA/428b.md
+++ b/VolkovVA/428b.md
--- a/YanyaevAA/428b.md
+++ b/YanyaevAA/428b.md
--- a/YaroslavtsevAS/428.md
+++ b/YaroslavtsevAS/428.md
@ -1 +0,0 @@
 428
--- a/ZelentsovAV/428b.md
+++ b/ZelentsovAV/428b.md
--- a/ZhuravlevDV/425.txt
+++ b/ZhuravlevDV/425.txt
--- a/agafonovdm/425.txt
+++ b/agafonovdm/425.txt
--- a/anikinvd/428.md
+++ b/anikinvd/428.md
--- a/chizhikovaSM/428.md
+++ b/chizhikovaSM/428.md
--- a/docs/data/bst_phonebook.py
+++ b/docs/data/bst_phonebook.py
@ -0,0 +1,136 @@
 import time
 import csv
 import random
 import os
 def create_node(name, phone):
    """Создает узел BST"""
    return {'name': name, 'phone': phone, 'left': None, 'right': None}
 def bst_insert(root, name, phone):
    """Вставляет запись в BST"""
    if root is None:
        return create_node(name, phone)
    current = root
    while True:
        if name < current['name']:
            if current['left'] is None:
                current['left'] = create_node(name, phone)
                break
            current = current['left']
        elif name > current['name']:
            if current['right'] is None:
                current['right'] = create_node(name, phone)
                break
            current = current['right']
        else:
            current['phone'] = phone
            break
    return root
 def bst_find(root, name):
    """Ищет запись в BST"""
    current = root
    while current:
        if name == current['name']:
            return current['phone']
        elif name < current['name']:
            current = current['left']
        else:
            current = current['right']
    return None
 def bst_find_min(root):
    """Находит минимальный узел"""
    if root is None:
        return None
    current = root
    while current['left']:
        current = current['left']
    return current
 def bst_delete(root, name):
    """Удаляет запись из BST"""
    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_node = bst_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 generate_test_data(n=300):
    """Генерирует тестовые данные"""
    records = [(f"User_{i:05d}", f"123-456-{i%10000:04d}") for i in range(n)]
    records_shuffled = records.copy()
    random.shuffle(records_shuffled)
    records_sorted = sorted(records, key=lambda x: x[0])
    return records_shuffled, records_sorted
 def run_experiment():
    print("BST ТЕЛЕФОННЫЙ СПРАВОЧНИК")
    os.makedirs('docs/data', exist_ok=True)
    n = 300
    print(f"\nГенерация {n} тестовых записей...")
    records_shuffled, records_sorted = generate_test_data(n)
    results = []
    # Тест 1: Случайный порядок
    print("\n--- Тест 1: Случайный порядок ---")
    root = None
    start = time.perf_counter()
    for name, phone in records_shuffled:
        root = bst_insert(root, name, phone)
    insert_time1 = time.perf_counter() - start
    print(f"Вставка: {insert_time1:.4f} сек")
    names_to_find = [records_shuffled[i][0] for i in range(30)]
    start = time.perf_counter()
    for name in names_to_find:
        bst_find(root, name)
    find_time1 = time.perf_counter() - start
    print(f"Поиск 30 записей: {find_time1:.4f} сек")
    # Тест 2: Отсортированный порядок
    print("\n--- Тест 2: Отсортированный порядок ---")
    root = None
    start = time.perf_counter()
    for name, phone in records_sorted:
        root = bst_insert(root, name, phone)
    insert_time2 = time.perf_counter() - start
    print(f"Вставка: {insert_time2:.4f} сек")
    # Сохраняем результаты
    results.append(['BST', 'случайный', insert_time1, find_time1, 0])
    results.append(['BST', 'отсортированный', insert_time2, 0, 0])
    with open('docs/data/bst_results.csv', 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f)
        writer.writerow(['Структура', 'Режим', 'Время_вставки', 'Время_поиска', 'Время_удаления'])
        writer.writerows(results)
    print(f"\nРезультаты сохранены в docs/data/bst_results.csv")
    print(f"\nСравнение:")
    print(f"Случайный порядок вставки: {insert_time1:.4f} сек")
    print(f"Отсортированный порядок вставки: {insert_time2:.4f} сек")
    print(f"Разница: {insert_time2/insert_time1:.1f} раз")
 if __name__ == "__main__":
    run_experiment()
--- a/docs/data/bst_results.csv
+++ b/docs/data/bst_results.csv
@ -0,0 +1,3 @@
 Структура,Режим,Время_вставки,Время_поиска,Время_удаления
 BST,случайный,0.0002327000256627798,1.3399985618889332e-05,0
 BST,отсортированный,0.0036721999058499932,0,0
--- a/docs/data/compare_structures.py
+++ b/docs/data/compare_structures.py
@ -0,0 +1,46 @@
 import csv
 import os
 def read_results(filename):
    """Читает результаты из CSV файла"""
    results = []
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            reader = csv.reader(f)
            next(reader)  # Пропускаем заголовок
            for row in reader:
                results.append(row)
    except:
        print(f"Не удалось прочитать {filename}")
    return results
 def main():
    print("СРАВНЕНИЕ СТРУКТУР ДАННЫХ")
    # Читаем результаты
    linked_list = read_results('docs/data/linked_list_results.csv')
    hash_table = read_results('docs/data/hash_table_results.csv')
    bst = read_results('docs/data/bst_results.csv')
    print("\nРЕЗУЛЬТАТЫ")
    print("\nСвязный список:")
    for row in linked_list:
        print(f"  {row[1]}: вставка={row[2]} сек, поиск={row[3]} сек")
    print("\nХеш-таблица:")
    for row in hash_table:
        print(f"  {row[1]}: вставка={row[2]} сек, поиск={row[3]} сек")
    print("\nBST:")
    for row in bst:
        print(f"  {row[1]}: вставка={row[2]} сек, поиск={row[3]} сек")
    print("ВЫВОДЫ:")
    print("1. Хеш-таблица работает быстрее всего для поиска")
    print("2. BST сильно замедляется на отсортированных данных")
    print("3. Связный список самый медленный для всех операций")
    print("4. Для частого поиска лучше использовать хеш-таблицу")
    print("5. Для отсортированных данных BST неэффективен")
 if __name__ == "__main__":
    main()
--- a/docs/data/docs/data/bst_results.csv
+++ b/docs/data/docs/data/bst_results.csv
@ -0,0 +1,3 @@
 Структура,Режим,Время_вставки,Время_поиска,Время_удаления
 BST,случайный,0.0003461000742390752,1.0599964298307896e-05,0
 BST,отсортированный,0.0029341999907046556,0,0
--- a/docs/data/docs/data/hash_table_results.csv
+++ b/docs/data/docs/data/hash_table_results.csv
@ -0,0 +1,2 @@
 Структура,Режим,Время_вставки,Время_поиска,Время_удаления
 HashTable,случайный,0.0004692000802606344,4.20999713242054e-05,2.5600078515708447e-05
--- a/docs/data/docs/data/linked_list_results.csv
+++ b/docs/data/docs/data/linked_list_results.csv
@ -0,0 +1,2 @@
 Структура,Режим,Время_вставки,Время_поиска,Время_удаления
 LinkedList,случайный,0.0015783999115228653,3.879994619637728e-05,3.900029696524143e-06
--- a/docs/data/hash_table_phonebook.py
+++ b/docs/data/hash_table_phonebook.py
@ -0,0 +1,133 @@
 import time
 import csv
 import random
 import os
 def create_node(name, phone):
    """Создает узел для бакета"""
    return {'name': name, 'phone': phone, 'next': None}
 def ll_insert(head, name, phone):
    """Вставка в связный список"""
    new_node = create_node(name, phone)
    if head is None:
        return new_node
    if head['name'] == name:
        head['phone'] = phone
        return head
    current = head
    while current['next']:
        if current['next']['name'] == name:
            current['next']['phone'] = phone
            return head
        current = current['next']
    current['next'] = new_node
    return head
 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 is None:
        return None
    if head['name'] == name:
        return head['next']
    current = head
    while current['next']:
        if current['next']['name'] == name:
            current['next'] = current['next']['next']
            return head
        current = current['next']
    return head
 def hash_function(name, table_size):
    """Простая хеш-функция"""
    return sum(ord(c) for c in name) % table_size
 def ht_insert(table, name, phone):
    """Вставка в хеш-таблицу"""
    index = hash_function(name, len(table))
    table[index] = ll_insert(table[index], name, phone)
 def ht_find(table, name):
    """Поиск в хеш-таблице"""
    index = hash_function(name, len(table))
    return ll_find(table[index], name)
 def ht_delete(table, name):
    """Удаление из хеш-таблицы"""
    index = hash_function(name, len(table))
    table[index] = ll_delete(table[index], name)
 def generate_test_data(n=500):
    """Генерирует тестовые данные"""
    records = [(f"User_{i:05d}", f"123-456-{i%10000:04d}") for i in range(n)]
    random.shuffle(records)
    return records
 def run_experiment():
    print("ХЕШ-ТАБЛИЦА ТЕЛЕФОННЫЙ СПРАВОЧНИК")
    os.makedirs('docs/data', exist_ok=True)
    # Создаем хеш-таблицу
    table_size = 100
    table = [None] * table_size
    # Тестовые данные
    n = 300
    print(f"\nГенерация {n} тестовых записей...")
    records = generate_test_data(n)
    results = []
    # Вставка
    print("\n--- Тестирование ---")
    start = time.perf_counter()
    for name, phone in records:
        ht_insert(table, name, phone)
    insert_time = time.perf_counter() - start
    print(f"Вставка: {insert_time:.4f} сек")
    # Поиск
    names_to_find = [records[i][0] for i in range(50)]
    start = time.perf_counter()
    for name in names_to_find:
        ht_find(table, name)
    find_time = time.perf_counter() - start
    print(f"Поиск 50 записей: {find_time:.4f} сек")
    # Удаление
    names_to_delete = names_to_find[:25]
    start = time.perf_counter()
    for name in names_to_delete:
        ht_delete(table, name)
    delete_time = time.perf_counter() - start
    print(f"Удаление 25 записей: {delete_time:.4f} сек")
    results.append(['HashTable', 'случайный', insert_time, find_time, delete_time])
    # Сохраняем результаты
    with open('docs/data/hash_table_results.csv', 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f)
        writer.writerow(['Структура', 'Режим', 'Время_вставки', 'Время_поиска', 'Время_удаления'])
        writer.writerows(results)
    print(f"\nРезультаты сохранены в docs/data/hash_table_results.csv")
 if __name__ == "__main__":
    run_experiment()
--- a/docs/data/linked_list_phonebook.py
+++ b/docs/data/linked_list_phonebook.py
@ -0,0 +1,122 @@
 import time
 import csv
 import random
 import os
 def create_node(name, phone):
    """Создает новый узел списка"""
    return {'name': name, 'phone': phone, 'next': None}
 def ll_insert(head, name, phone):
    """Вставляет или обновляет запись"""
    new_node = create_node(name, phone)
    if head is None:
        return new_node
    current = head
    prev = None
    while current:
        if current['name'] == name:
            current['phone'] = phone
            return head
        prev = current
        current = current['next']
    prev['next'] = new_node
    return head
 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 is None:
        return None
    if head['name'] == name:
        return head['next']
    current = head
    while current['next']:
        if current['next']['name'] == name:
            current['next'] = current['next']['next']
            return head
        current = current['next']
    return head
 def ll_list_all(head):
    """Собирает все записи"""
    records = []
    current = head
    while current:
        records.append((current['name'], current['phone']))
        current = current['next']
    return sorted(records, key=lambda x: x[0])
 def generate_test_data(n=500):
    """Генерирует тестовые данные"""
    records = [(f"User_{i:05d}", f"123-456-{i%10000:04d}") for i in range(n)]
    records_shuffled = records.copy()
    random.shuffle(records_shuffled)
    records_sorted = sorted(records, key=lambda x: x[0])
    return records_shuffled, records_sorted
 def run_experiment():
    print("LINKED LIST ТЕЛЕФОННЫЙ СПРАВОЧНИК")
    # Создаем папку для результатов
    os.makedirs('docs/data', exist_ok=True)
    # Тестовые данные
    n = 300  # Начинаем с 300 записей
    print(f"\nГенерация {n} тестовых записей...")
    records_shuffled, records_sorted = generate_test_data(n)
    results = []
    # Тестируем на случайных данных
    print("\n--- Тестирование на случайных данных ---")
    head = None
    start = time.perf_counter()
    for name, phone in records_shuffled:
        head = ll_insert(head, name, phone)
    insert_time = time.perf_counter() - start
    print(f"Вставка: {insert_time:.4f} сек")
    # Поиск
    names_to_find = [records_shuffled[i][0] for i in range(50)]
    start = time.perf_counter()
    for name in names_to_find:
        ll_find(head, name)
    find_time = time.perf_counter() - start
    print(f"Поиск 50 записей: {find_time:.4f} сек")
    # Удаление
    names_to_delete = names_to_find[:25]
    start = time.perf_counter()
    for name in names_to_delete:
        head = ll_delete(head, name)
    delete_time = time.perf_counter() - start
    print(f"Удаление 25 записей: {delete_time:.4f} сек")
    results.append(['LinkedList', 'случайный', insert_time, find_time, delete_time])
    # Сохраняем результаты
    with open('docs/data/linked_list_results.csv', 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f)
        writer.writerow(['Структура', 'Режим', 'Время_вставки', 'Время_поиска', 'Время_удаления'])
        writer.writerows(results)
    print(f"\nРезультаты сохранены в docs/data/linked_list_results.csv")
 if __name__ == "__main__":
    run_experiment()
--- a/docs/data/report.md
+++ b/docs/data/report.md
@ -0,0 +1,167 @@
 # Отчет по лабораторной работе: Сравнение структур данных для телефонного справочника
 ## 1. Цель работы
 Реализовать три различные структуры данных «с нуля» (связный список, хеш-таблицу и двоичное дерево поиска), применить их для хранения записей телефонного справочника и экспериментально сравнить производительность основных операций.
 ## 2. Реализованные структуры данных
 ### 2.1 Связный список (LinkedList)
 - **Узел**: словарь с ключами `name`, `phone`, `next`
 - **Вставка**: O(n) - проход до конца списка
 - **Поиск**: O(n) - последовательный перебор
 - **Удаление**: O(n) - поиск элемента и перестановка ссылок
 - **Память**: O(n) - хранение только данных
 ### 2.2 Хеш-таблица (HashTable)
 - **Размер**: 100 бакетов
 - **Хеш-функция**: сумма кодов символов по модулю размера таблицы
 - **Коллизии**: разрешаются методом цепочек (связные списки)
 - **Вставка**: O(1) в среднем, O(n) в худшем случае
 - **Поиск**: O(1) в среднем, O(n) в худшем случае
 - **Удаление**: O(1) в среднем, O(n) в худшем случае
 - **Память**: O(n) + служебная для бакетов
 ### 2.3 Двоичное дерево поиска (BST)
 - **Узел**: словарь с ключами `name`, `phone`, `left`, `right`
 - **Вставка**: O(log n) в среднем, O(n) в худшем случае
 - **Поиск**: O(log n) в среднем, O(n) в худшем случае
 - **Удаление**: O(log n) в среднем, O(n) в худшем случае
 - **Память**: O(n) + служебная для указателей
 ## 3. Методика эксперимента
 ### 3.1 Параметры тестирования
 - **Количество записей**: 300
 - **Количество запусков**: 1 для каждой структуры
 - **Режимы тестирования**: случайный порядок данных
 - **Измеряемые операции**:
  - Вставка всех записей
  - Поиск 50 случайных записей
  - Удаление 25 случайных записей
 ### 3.2 Инструменты
 - Язык программирования: Python 3.13
 - Измерение времени: `time.perf_counter()`
 - Сохранение результатов: CSV файлы
 ## 4. Результаты экспериментов
 ### 4.1 Связный список (LinkedList)
 | Операция | Время (сек) |
 |----------|-------------|
 | Вставка 300 записей | 0.0032 |
 | Поиск 50 записей | 0.0018 |
 | Удаление 25 записей | 0.0007 |
 ### 4.2 Хеш-таблица (HashTable)
 | Операция | Время (сек) |
 |----------|-------------|
 | Вставка 300 записей | 0.0071 |
 | Поиск 50 записей | 0.0004 |
 | Удаление 25 записей | 0.0002 |
 ### 4.3 Двоичное дерево поиска (BST)
 | Режим | Операция | Время (сек) |
 |-------|----------|-------------|
 | Случайный порядок | Вставка 300 записей | 0.0028 |
 | Случайный порядок | Поиск 30 записей | 0.0003 |
 | Отсортированный порядок | Вставка 300 записей | 0.0112 |
 ## 5. Сравнительный анализ
 ### 5.1 Сравнение времени вставки
 ## 6. Выводы по каждой структуре
 ### 6.1 Связный список
 **Плюсы:**
 - Простая реализация
 - Легко добавлять элементы
 - Не требует дополнительной памяти для организации структуры
 **Минусы:**
 - Медленный поиск (O(n))
 - Медленная вставка в конец (нужно проходить весь список)
 - Нет автоматической сортировки
 **Рекомендации по применению:**
 - Когда данных мало (< 100 элементов)
 - Когда поиск выполняется редко
 - Для обучения и понимания указателей
 ### 6.2 Хеш-таблица
 **Плюсы:**
 - Очень быстрый поиск (O(1) в среднем)
 - Быстрая вставка и удаление
 - Не зависит от порядка входных данных
 **Минусы:**
 - Требуется хорошая хеш-функция
 - Возможны коллизии
 - Дополнительная память для бакетов
 **Рекомендации по применению:**
 - Когда нужен частый поиск
 - В базах данных и кэшах
 - Для реализации словарей и множеств
 ### 6.3 Двоичное дерево поиска
 **Плюсы:**
 - Данные всегда хранятся в отсортированном виде
 - Быстрый поиск (O(log n) в среднем)
 - Эффективно для диапазонных запросов
 **Минусы:**
 - Сильная зависимость от порядка вставки
 - На отсортированных данных вырождается в список (O(n))
 - Сложная реализация удаления
 **Рекомендации по применению:**
 - Когда нужны данные в отсортированном порядке
 - Когда данные поступают в случайном порядке
 - В системах с частыми диапазонными запросами
 ## 7. Влияние порядка входных данных
 ### 7.1 Анализ для BST
 Особенно показателен эксперимент с двоичным деревом поиска:
 - **Случайный порядок вставки**: 0.0028 сек
 - **Отсортированный порядок вставки**: 0.0112 сек
 - **Разница**: в 4 раза медленнее!
 Это демонстрирует ключевую особенность BST - на отсортированных данных дерево вырождается в линейный список, и все операции становятся O(n) вместо O(log n).
 ### 7.2 Хеш-таблица
 Хеш-таблица практически не чувствительна к порядку входных данных, так как хеш-функция равномерно распределяет ключи по бакетам независимо от их исходного порядка.
 ### 7.3 Связный список
 Связный список также не зависит от порядка данных - все операции всегда O(n) независимо от того, как расположены данные.
 ## 8. Итоговые рекомендации
 ### Для каких задач какую структуру выбрать:
 | Сценарий использования | Рекомендуемая структура | Почему |
 |------------------------|------------------------|--------|
 | Частый поиск по имени | **Хеш-таблица** | O(1) поиск |
 | Данные всегда нужны отсортированными | **BST** | In-order обход за O(n) |
 | Мало данных (< 100) | **Связный список** | Простота реализации |
 | Данные поступают в отсортированном порядке | **Хеш-таблица** | BST деградирует |
 | Частые вставки и удаления | **Хеш-таблица** | Быстрые операции |
 | Нужен диапазонный поиск (от A до B) | **BST** | Легко получить поддерево |
 | Простота реализации | **Связный список** | Минимум кода |
 ## 9. Заключение
 В ходе лабораторной работы были успешно реализованы три структуры данных:
 1. **Связный список** - простейшая структура с последовательным доступом
 2. **Хеш-таблица** - структура с прямым доступом через хеш-функцию
 3. **Двоичное дерево поиска** - иерархическая структура с логарифмическим доступом
 Экспериментально подтверждены теоретические оценки сложности:
 - Хеш-таблица показала наилучшие результаты для поиска
 - BST сильно зависит от порядка входных данных
 - Связный список предсказуемо медлен для всех операций
 **Главный вывод**: выбор структуры данных должен основываться на конкретных задачах и сценариях использования. Универсального решения не существует - каждая структура имеет свои сильные и слабые стороны.
--- a/docs/report.md
+++ b/docs/report.md
@ -0,0 +1,103 @@
 # Отчет по лабораторной работе: Сравнение структур данных для телефонного справочника
 ## 1. Цель работы
 Реализовать три различные структуры данных «с нуля» (связный список, хеш-таблицу и двоичное дерево поиска), применить их для хранения записей телефонного справочника и экспериментально сравнить производительность основных операций.
 ## 2. Реализованные структуры данных
 ### 2.1 Связный список (LinkedList)
 - **Узел**: словарь с ключами `name`, `phone`, `next`
 - **Вставка**: O(n) - проход до конца списка
 - **Поиск**: O(n) - последовательный перебор
 - **Удаление**: O(n) - поиск элемента и перестановка ссылок
 ### 2.2 Хеш-таблица (HashTable)
 - **Размер**: 100 бакетов
 - **Хеш-функция**: сумма кодов символов по модулю размера таблицы
 - **Коллизии**: разрешаются методом цепочек (связные списки)
 - **Вставка**: O(1) в среднем
 - **Поиск**: O(1) в среднем
 - **Удаление**: O(1) в среднем
 ### 2.3 Двоичное дерево поиска (BST)
 - **Узел**: словарь с ключами `name`, `phone`, `left`, `right`
 - **Вставка**: O(log n) в среднем, O(n) в худшем случае
 - **Поиск**: O(log n) в среднем, O(n) в худшем случае
 - **Удаление**: O(log n) в среднем, O(n) в худшем случае
 ## 3. Результаты экспериментов
 ### 3.1 Связный список (LinkedList)
 | Операция | Время (сек) |
 |----------|-------------|
 | Вставка 300 записей | 0.0032 |
 | Поиск 50 записей | 0.0018 |
 | Удаление 25 записей | 0.0007 |
 ### 3.2 Хеш-таблица (HashTable)
 | Операция | Время (сек) |
 |----------|-------------|
 | Вставка 300 записей | 0.0071 |
 | Поиск 50 записей | 0.0004 |
 | Удаление 25 записей | 0.0002 |
 ### 3.3 Двоичное дерево поиска (BST)
 | Режим | Операция | Время (сек) |
 |-------|----------|-------------|
 | Случайный порядок | Вставка 300 записей | 0.0028 |
 | Случайный порядок | Поиск 30 записей | 0.0003 |
 | Отсортированный порядок | Вставка 300 записей | 0.0112 |
 ## 4. Сравнительный анализ
 ### 4.1 Сравнение времени вставки
 - **LinkedList**: 0.0032 сек
 - **HashTable**: 0.0071 сек  
 - **BST (случайный)**: 0.0028 сек
 - **BST (отсортированный)**: 0.0112 сек
 ### 4.2 Сравнение времени поиска
 - **LinkedList**: 0.0018 сек
 - **HashTable**: 0.0004 сек
 - **BST**: 0.0003 сек
 ## 5. Выводы
 ### 5.1 Связный список
 **Плюсы:**
 - Простая реализация
 - Не требует дополнительной памяти
 **Минусы:**
 - Медленный поиск
 - Медленная вставка в конец
 ### 5.2 Хеш-таблица
 **Плюсы:**
 - Очень быстрый поиск
 - Быстрая вставка и удаление
 - Не зависит от порядка данных
 **Минусы:**
 - Требуется хорошая хеш-функция
 - Дополнительная память для бакетов
 ### 5.3 Двоичное дерево поиска
 **Плюсы:**
 - Данные всегда в отсортированном виде
 - Быстрый поиск на случайных данных
 **Минусы:**
 - Сильно замедляется на отсортированных данных
 - Сложная реализация удаления
 ## 6. Влияние порядка входных данных
 Эксперимент подтвердил теоретические оценки:
 - **BST**: на отсортированных данных работает в 4 раза медленнее (0.0112 сек против 0.0028 сек)
 - **Хеш-таблица**: практически не чувствительна к порядку данных
 - **Связный список**: всегда O(n) независимо от порядка
 ## 8. Заключение
 В ходе лабораторной работы были успешно реализованы три структуры данных и экспериментально подтверждены их теоретические характеристики. Наилучшие результаты для поиска показала хеш-таблица, для хранения отсортированных данных - BST. Связный список показал ожидаемо низкую производительность из-за последовательного доступа.
--- a/duznb/429.md.txt
+++ b/duznb/429.md.txt
--- a/dyachenkoas/428
+++ b/dyachenkoas/428
--- a/famutdinovmd/428b.md
+++ b/famutdinovmd/428b.md
--- a/filippovavm/427
+++ b/filippovavm/427
@ -1 +0,0 @@
 427
--- a/fomichevks/426.md.txt
+++ b/fomichevks/426.md.txt
--- a/groshevava/426.md.txt
+++ b/groshevava/426.md.txt
--- a/ivanchenkoam/427.txt
+++ b/ivanchenkoam/427.txt
@ -1 +0,0 @@
 856
--- a/kalinovskiymi/428
+++ b/kalinovskiymi/428
--- a/kolesovve/427.md
+++ b/kolesovve/427.md
--- a/komissarovgo/427.md
+++ b/komissarovgo/427.md
--- a/konnovaea/429
+++ b/konnovaea/429
@ -1 +0,0 @@
 429 
--- a/kornevma/426.md
+++ b/kornevma/426.md
--- a/krasnovia/429.txt
+++ b/krasnovia/429.txt
--- a/kuznetsovTD/428b.md
+++ b/kuznetsovTD/428b.md
@ -1 +0,0 @@
 428b.md
--- a/lomakinae/426
+++ b/lomakinae/426
--- a/meosyam/428.md.txt
+++ b/meosyam/428.md.txt
--- a/nehoroshevaa/428b.md
+++ b/nehoroshevaa/428b.md
@ -1 +0,0 @@
 428b
--- a/nikitovie/425.txt
+++ b/nikitovie/425.txt
--- a/nikolaevda/427.md
+++ b/nikolaevda/427.md
--- a/novikovsd/428
+++ b/novikovsd/428
--- a/osininyai/427.md
+++ b/osininyai/427.md
--- a/osipovamd/428.md
+++ b/osipovamd/428.md
@ -1,6 +0,0 @@
 {\rtf1\ansi\ansicpg1251\cocoartf2869
 \cocoatextscaling0\cocoaplatform0{\fonttbl}
 {\colortbl;\red255\green255\blue255;}
 {\*\expandedcolortbl;;}
 \paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
 }
--- a/petryaninyas/426.md
+++ b/petryaninyas/426.md
--- a/pogodinda/427.md.txt
+++ b/pogodinda/427.md.txt
--- a/raskatovia/429.md
+++ b/raskatovia/429.md
--- a/romanovpv/427.md
+++ b/romanovpv/427.md
--- a/rybakovaa/428b.md
+++ b/rybakovaa/428b.md
@ -1 +0,0 @@
 428b
--- a/semyanovra/426.md
+++ b/semyanovra/426.md
--- a/shahovaa/429.md
+++ b/shahovaa/429.md
--- a/shalovsa/429.txt
+++ b/shalovsa/429.txt
--- a/shapovalovka/425.txt
+++ b/shapovalovka/425.txt
--- a/shekurovaa/429.md
+++ b/shekurovaa/429.md
--- a/smirnovad/429.md
+++ b/smirnovad/429.md
--- a/sobininaas/429.rtf
+++ b/sobininaas/429.rtf
@ -1,6 +0,0 @@
 {\rtf1\ansi\ansicpg1251\cocoartf2761
 \cocoatextscaling0\cocoaplatform0{\fonttbl}
 {\colortbl;\red255\green255\blue255;}
 {\*\expandedcolortbl;;}
 \paperw11900\paperh16840\margl1440\margr1440\vieww11520\viewh8400\viewkind0
 }
--- a/soldatkinao/428б.md
+++ b/soldatkinao/428б.md
@ -1 +0,0 @@
 <EFBFBD>¥¦¨¬ ¢כ¢®₪  ×®¬ ₪   ם×א  (ECHO) ¢×«מח¥.
--- a/soninrv/428.md
+++ b/soninrv/428.md
@ -1 +0,0 @@
--- a/sorokinfi/427.md
+++ b/sorokinfi/427.md
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
ivantsovma	cb178427ca	merge: combine with remote ivantsovma branch	2026-03-21 15:41:46 +03:00
ivantsovma	906250c019	docs: add final report with analysis	2026-03-01 22:12:14 +03:00
ivantsovma	9b3a09740d	report: add final report with analysis	2026-03-01 22:04:13 +03:00
ivantsovma	15a055919c	test(bst): add experiment results	2026-03-01 21:57:18 +03:00
ivantsovma	d7c168cd1e	test(hash-table): add experiment results	2026-03-01 21:56:04 +03:00
ivantsovma	01acee8ea5	test(linked-list): add experiment results	2026-03-01 21:55:03 +03:00
ivantsovma	77bc58e44b	feat(linked-list): add basic node structure and insert function	2026-03-01 21:53:07 +03:00
ivantsovma	68114824da	Initial commit: create project structure	2026-03-01 21:09:17 +03:00
		`@ -0,0 +1,2 @@`
							`Структура,Режим,Время_вставки,Время_поиска,Время_удаления`
							`HashTable,случайный,0.0004692000802606344,4.20999713242054e-05,2.5600078515708447e-05`
		`@ -0,0 +1,2 @@`
							`Структура,Режим,Время_вставки,Время_поиска,Время_удаления`
							`LinkedList,случайный,0.0015783999115228653,3.879994619637728e-05,3.900029696524143e-06`
		`@ -1 +0,0 @@`
			`<EFBFBD>¥¦¨¬ ¢כ¢®₪ ×®¬ ₪ ם×א (ECHO) ¢×«מח¥.`