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,10 +46,8 @@

 6.  Отправь ветку **в свой форк** на Gitea:
    ```bash
-    git push origin
+    git push origin IvanovII
    ```
-    
-если просит, перед этим сделать git push --set-upstream origin

 7.  **Создай запрос на слияние (Pull Request):** На Gitea перейди в свой форк, выбери ветку `IvanovII`, нажмите **Запрос на слияние**. Убедитесь, что:
    - Базовый репозиторий: **учебный** (преподавателя)
@ -54,329 +55,4 @@
    - Сравниваемая ветка: **свой форк / IvanovII**

 8.  Отправь PR.
-
-## Задание 1 -- структуры данных
-***Напоминание: под каждое задание вы создаете отдельную ветку***
-
->Для оформления результатов заведи папку **docs** в своей папке и сохраняй туда отчет (в любом формате от .doc до .md, а то и .jpnb). Вспомогательные файлы клади в подпапку **data** внутри **docs**
-
-**Цель работы**
-
-Реализовать три различные структуры данных «с нуля», применить их для хранения записей телефонного справочника и экспериментально сравнить производительность основных операций. Вы должны собственными руками написать код, чтобы понять внутреннее устройство связного списка, хеш-таблицы и двоичного дерева поиска, а также осознать их сильные и слабые стороны на практике.
-
-**!! Задание  выполнять в структурной (процедурной) парадигме, не используя классы. Главное реализовать структуры данных «руками» и сравнить их производительность.**
-
-### Базовые операции (обязательны для всех):
-
-`insert(name, phone)` -- добавить или обновить запись.
-
-`find(name)` -- phone или None.
-
-`delete(name)` -- удалить запись, игнорировать отсутствие.
-
-`list_all()` -- список всех записей, отсортированный по имени (для BST in‑order обход; для списка и хеш‑таблицы — собрать и отсортировать явно).
-
-#### 1. Связный список (LinkedListPhoneBook)
-
-Узел представляется словарём: `{'name': 'Имя', 'phone': '123', 'next': None}.`
-
-**Функции:**
-
-`def ll_insert(head, name, phone)` — проходит до конца (или сразу добавляет в конец) и возвращает новую голову (если вставка в начало) или изменяет список по ссылке. Удобнее возвращать новую голову, если вставка может быть в начало.
-
-`def ll_find(head, name)` — ищет узел, возвращает телефон или None.
-
-`def ll_delete(head, name)` — удаляет узел, возвращает новую голову.
-
-`def ll_list_all(head)` — собирает все записи в список и сортирует (сортировка вынесена отдельно).
-
-#### 2. Хеш-таблица
-Хранится как список buckets фиксированной длины, каждый элемент — голова связного списка (или None).
-
-**Функции:**
-
-`def ht_insert(buckets, name, phone)` — вычисляет индекс, вызывает ll_insert для соответствующего бакета.
-
-Аналогично `ht_find, ht_delete, ht_list_all` (последняя собирает все записи из всех бакетов и сортирует).
-
-#### 3. Двоичное дерево поиска
-Узел — словарь: `{'name': 'Имя', 'phone': '123', 'left': None, 'right': None}.`
-
-**Функции:**
-
-`def bst_insert(root, name, phone)` — рекурсивно или итеративно вставляет, возвращает новый корень (если корень меняется).
-
-`def bst_find(root, name)` — поиск.
-
-`def bst_delete(root, name)` — удаление, возвращает новый корень.
-
-`def bst_list_all(root)` — центрированный обход (рекурсивно собирает записи в отсортированном порядке).
-
-### Экспериментальная часть (подробно об измерении времени)
-#### 1. Генерация тестовых данных
-Создайте список records из N элементов (например, N = 10000). Каждый элемент — кортеж (name, phone).
-
-Имена генерируйте как `f"User_{i:05d}"` (равномерное распределение) или случайные слова из небольшого набора (чтобы были повторения и коллизии). Для проверки влияния порядка подготовьте два варианта одного и того же набора:
-
-`records_shuffled` — случайный порядок.
-
-`records_sorted` — отсортированный по имени (по алфавиту).
-
-#### 2. Инструменты замера времени
-Используйте модуль **time**:
-
-```python
-import time
-
-start = time.perf_counter()
-# ... операции ...
-end = time.perf_counter()
-elapsed = end - start  # время в секундах
-```
-
-Для многократных замеров удобен `timeit`, но в этой задаче достаточно просто обернуть код в цикл и усреднить.
-
-#### 3. Проведение замеров
-Для каждой структуры данных и для каждого режима входных данных (случайный / отсортированный) выполните:
-
- А. Вставка всех записей
-
-Создайте пустую структуру.
-
-Засеките время, выполните insert для каждой записи из входного списка.
-
-Зафиксируйте общее время вставки.
-
- Б. Поиск 100 случайных записей
-
-Возьмите 100 случайных имён из того же набора (гарантированно существующих) и 10 имён, которых нет (например, "None_{i}").
-
-Засеките время на выполнение всех 110 вызовов find.
-
- В. Удаление 50 случайных записей
-
-Выберите 50 случайных имён из набора.
-
-Засеките время на выполнение delete для каждого.
-
-
-**!! Важно: после вставки структура остаётся заполненной, поиск и удаление выполняются на ней же. Если нужно повторить замер для другого порядка данных — создавайте новую структуру и заполняйте заново.**
-
-#### 4. Сохранение результатов
-
-**!! Каждый эксперимент повторить минимум 5 раз и записывать и среднее время, и все замеры.**
-
-Соберите все замеры в словарь или список, затем сохраните в CSV-файл:
-
-```python
-import csv
-
-results = [
-    ["Структура", "Режим", "Операция", "Время (сек)"],
-    ["LinkedList", "случайный", "вставка", 0.123],
-    ...
-]
-
-with open("results.csv", "w", newline="") as f:
-    writer = csv.writer(f)
-    writer.writerows(results)
-```
-
-
-#### 5. Анализ результатов
-Постройте график (столбчатая диаграмма или линейный график) — можно в Excel, Google Sheets или с помощью matplotlib в Python.
-
-Сравните:
-
- Как порядок входных данных влияет на скорость вставки в BST (деградация до O(n) на отсортированных данных).
-
- Почему хеш-таблица почти не чувствительна к порядку.
-
- Почему связный список всегда медленен при поиске.
-
- Как удаление работает в каждой структуре.
-
-* Вывод должен содержать ответ на вопрос: какую структуру и для каких задач (частые вставки, частый поиск, необходимость получать данные в порядке) стоит выбирать в реальной жизни.*
-
-## Задание: Поиск выхода из лабиринта (объектно-ориентированная реализация с паттернами)
-
-### Цель работы
-Разработать гибкую, расширяемую программу для загрузки лабиринта из файла, поиска пути от старта до выхода с возможностью выбора алгоритма, визуализации процесса и экспериментального сравнения алгоритмов. В ходе работы необходимо применить минимум 3 паттерна проектирования из списка GoF, обосновать их выбор и продемонстрировать преимущества такой архитектуры.
-
-### Общая схема приложения (пример)
-
-```mermaid
-classDiagram
-    class Maze {
-        -Cell[] cells
-        -int width, height
-        -Cell start
-        -Cell exit
-        +getCell(x,y): Cell
-        +getNeighbors(cell): List~Cell~
-    }
-    
-    class Cell {
-        -int x, y
-        -bool isWall
-        -bool isStart
-        -bool isExit
-        +isPassable(): bool
-    }
-    
-    class MazeBuilder {
-        <<interface>>
-        +buildFromFile(filename): Maze
-    }
-    
-    class TextFileMazeBuilder {
-        +buildFromFile(filename): Maze
-    }
-    
-    class PathFindingStrategy {
-        <<interface>>
-        +findPath(maze, start, exit): List~Cell~
-    }
-    
-    class BFSStrategy
-    class DFSStrategy
-    class AStarStrategy
-    class DijkstraStrategy
-    
-    class SearchStats {
-        +timeMs: float
-        +visitedCells: int
-        +pathLength: int
-    }
-    
-    class MazeSolver {
-        -Maze maze
-        -PathFindingStrategy strategy
-        +setStrategy(strategy)
-        +solve(): SearchStats
-    }
-    
-    class Command {
-        <<interface>>
-        +execute()
-        +undo()
-    }
-    
-    class MoveCommand {
-        -Player player
-        -Direction dir
-        -Cell previousCell
-        +execute()
-        +undo()
-    }
-    
-    class Player {
-        -Cell currentCell
-        +moveTo(cell)
-    }
-    
-    class Observer {
-        <<interface>>
-        +update(event)
-    }
-    
-    class ConsoleView {
-        +update(event)
-        +render(maze, player, path)
-    }
-    
-    MazeBuilder <|.. TextFileMazeBuilder
-    MazeBuilder --> Maze : creates
-    PathFindingStrategy <|.. BFSStrategy
-    PathFindingStrategy <|.. DFSStrategy
-    PathFindingStrategy <|.. AStarStrategy
-    PathFindingStrategy <|.. DijkstraStrategy
-    MazeSolver --> PathFindingStrategy : uses
-    MazeSolver --> Maze : uses
-    Command <|.. MoveCommand
-    MoveCommand --> Player
-    Player --> Cell
-    Observer <|.. ConsoleView
-    MazeSolver --> Observer : notifies
-```
-
-### Выполнение
-
-#### Этап 1. Модель лабиринта (без паттернов, просто классы)
-**Задача:** Создать классы `Cell` и `Maze`, которые представляют карту лабиринта.
- `Cell` хранит координаты (x, y), флаги `isWall`, `isStart`, `isExit`, метод `isPassable()` (возвращает `True` для прохода, если не стена).
- `Maze` хранит двумерный массив клеток, ширину, высоту, ссылки на стартовую и выходную клетку. Методы: `getCell(x, y)`, `getNeighbors(cell)` – возвращает список соседних проходимых клеток (вверх, вниз, влево, вправо, если в пределах границ и не стена).
-
-**Результат:** Лабиринт можно создать вручную в коде, но загрузку пока не делаем.
-
-#### Этап 2. Загрузка лабиринта из файла – применение паттерна **Builder**
-**Задача:** Реализовать загрузку лабиринта из текстового файла, где `#` – стена, ` ` (пробел) – проход, `S` – старт, `E` – выход.
- Создать интерфейс `MazeBuilder` с методом `buildFromFile(filename)`.
- Реализовать класс `TextFileMazeBuilder`, который читает файл, парсит символы, создаёт объекты `Cell`, задаёт координаты и флаги, после чего возвращает готовый `Maze`.
-
-Процесс построения лабиринта сложный (парсинг, валидация, установка старта/выхода). Builder скрывает детали создания от клиента. В будущем можно легко добавить другой формат (например, JSON или бинарный) через новую реализацию `MazeBuilder`.
-
-#### Этап 3. Стратегии поиска пути – паттерн **Strategy**
-**Задача:** Реализовать семейство алгоритмов поиска пути от старта до выхода.
- Создать интерфейс `PathFindingStrategy` с методом `findPath(maze, start, exit)`, возвращающим список клеток пути (от старта до выхода включительно) или пустой список, если пути нет.
- Реализовать минимум 3 стратегии:
-  - **BFS** (поиск в ширину) – гарантирует кратчайший путь по количеству шагов.
-  - **DFS** (поиск в глубину) – быстрый, но не обязательно кратчайший.
-  - **A*** (с эвристикой, например, манхэттенское расстояние) – компромисс между скоростью и оптимальностью.
-  - (Опционально) **Дейкстра** – полезна для взвешенных лабиринтов, но в базовом варианте все шаги имеют вес 1, тогда она совпадает с BFS.
-
-Каждая стратегия возвращает путь. Для BFS/DFS используйте очередь/стек, для A* – приоритетную очередь (heapq). Важно: алгоритмы не должны модифицировать сам лабиринт, только читать состояние клеток.
-
-Strategy позволяет легко переключать алгоритмы во время выполнения, не меняя код остальной программы. Новый алгоритм можно добавить, реализовав интерфейс.
-
-#### Этап 4. Класс-оркестратор – **MazeSolver** (использует Strategy)
-**Задача:** Создать класс, который принимает лабиринт и стратегию, выполняет поиск и собирает статистику.
- `MazeSolver` содержит поля `maze` и `strategy`.
- Метод `setStrategy(strategy)` для динамической смены алгоритма.
- Метод `solve()` вызывает `strategy.findPath(...)` и возвращает объект `SearchStats` (время выполнения в миллисекундах, количество посещённых клеток, длина найденного пути).
- Для замера времени используйте `time.perf_counter()` до и после вызова стратегии.
-
-#### Этап 5. Визуализация и пошаговое управление – паттерны **Observer** и **Command** (по желанию)
-**5.1. Наблюдатель (Observer)** – обновление консольного интерфейса.
- Создать интерфейс `Observer` с методом `update(event)`, где `event` может быть строкой или объектом с типом события (`"path_found"`, `"move"`, `"maze_loaded"`).
- Реализовать класс `ConsoleView`, который отображает лабиринт, текущее положение игрока (если реализован пошаговый режим) и найденный путь. Метод `render(maze, player_position, path)` рисует карту в консоли.
- `MazeSolver` (или отдельный контроллер) может иметь список наблюдателей и уведомлять их при изменении состояния.
-
-**5.2. Команда (Command)** – для пошагового перемещения игрока по найденному пути (или ручного управления).
- Создать интерфейс `Command` с методами `execute()` и `undo()`.
- Реализовать `MoveCommand`, который принимает игрока (`Player`), направление и изменяет его позицию, сохраняя предыдущую для отмены.
- Создать класс `Player`, хранящий текущую клетку.
- Консольное меню позволяет вводить команды (W/A/S/D), выполнять `MoveCommand`, при необходимости отменять последний ход (Ctrl+Z). Это опционально, но очень наглядно демонстрирует паттерн.
-
-*Observer можно реализовать только для вывода сообщений о начале/конце поиска, а Command – для демонстрации undo при ручном исследовании лабиринта.*
-
-#### Этап 6. Экспериментальная часть (аналогично заданию со структурами данных)
-**Задача:** Сравнить эффективность реализованных стратегий на лабиринтах разной сложности.
-1. **Подготовка тестовых лабиринтов:**
-   - Маленький (10×10) с простым путём.
-   - Средний (50×50) с тупиками.
-   - Большой (100×100) с запутанной структурой.
-   - «Пустой» лабиринт (без стен) – для демонстрации максимальной производительности.
-   - «Без выхода» – чтобы проверить обработку отсутствия пути.
-2. **Замеры:**
-   - Для каждого лабиринта и каждой стратегии запустить `solve()` 5–10 раз, усреднить время, количество посещённых клеток, длину пути.
-   - Записать результаты в CSV: `лабиринт,стратегия,время_мс,посещено_клеток,длина_пути`.
-3. **Анализ:**
-   - Построить графики для каждого лабиринта.
-   - Проанализировать и написать выводы по итогам (эффективность того или иного алгоритма в разных случаях).
-
-4. **Дополнительное задание:** Реализовать взвешенные клетки (например, болото – вес 3, песок – вес 2, асфальт – вес 1) и сравнить Дейкстру с A* на взвешенном графе.
-
-#### Этап 7. Отчёт
-**Структура отчёта:**
-1. Описание задачи и выбранных паттернов (с диаграммой классов из Mermaid).
-2. Листинги ключевых классов (можно выборочно) или ссылка на репозиторий.
-3. Результаты экспериментов (таблицы, графики).
-4. Анализ эффективности алгоритмов и применимости паттернов.
-5. Выводы: как ООП и паттерны помогли сделать код гибким и расширяемым. Что было бы сложно изменить без них.
-
-### Советы
- Для A* самая простая эвристика: `abs(x1 - x2) + abs(y1 - y2)`.
- При поиске пути надо хранить предшественников (`parent` для каждой посещённой клетки), чтобы восстановить путь.
- Для BFS/DFS используй `deque` (очередь) и `list` (стек).
- Визуализацию в консоли можно сделать с помощью `os.system('cls' if os.name == 'nt' else 'clear')` для перерисовки.
+>>>>>>> 7000ccc96cfc1bd124dd4e1eeb3ccca21f5e38b4
--- 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
				`@ -1 +0,0 @@`
				`<EFBFBD>¥¦¨¬ ¢כ¢®₪ ×®¬ ₪ ם×א (ECHO) ¢×«מח¥.`