Добавлен отчет

YanyaevAA/docs/Report_1.md

@@ -0,0 +1,317 @@
+# Структуры данных
+Цель работы: Реализовать три различные структуры данных «с нуля», применить их для хранения записей телефонного справочника и экспериментально сравнить производительность основных операций. Вы должны собственными руками написать код, чтобы понять внутреннее устройство связного списка, хеш-таблицы и двоичного дерева поиска, а также осознать их сильные и слабые стороны на практике.
+
+## Подготовка среды
+```Python
+import time
+from pathlib import Path
+import random
+import csv
+import sys
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+sys.setrecursionlimit(12000) #увеличивает глубину рекурсии
+```
+
+# Базовые операции
+```Python
+#Связный список
+def ll_insert(head, name, phone):
+    current = head
+    while current:
+        if current['name'] == name:
+            current['phone'] = phone
+            return head
+        current = current['next']
+    new_node = {'name': name, 'phone': phone, 'next': None}
+    new_node['next'] = head
+    return new_node
+
+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['name'] == name:
+        return head['next']
+    current = head
+    while current['next']:
+        if current['next']['name'] == name:
+            current['next'] = current['next']['next']
+            break
+        current = current['next']
+    return head
+
+def ll_list_all(head):
+    data= []
+    current = head
+    while current:
+        data.append((current['name'], current['phone']))
+        current = current['next']
+    return sorted(data)
+
+#хеш-таблица
+def ht_insert(buckets, name, phone):
+    id=hash(name)%len(buckets)
+    buckets[id] = ll_insert(buckets[id], name, phone)
+
+def ht_find(buckets, name):
+    id= hash(name)%len(buckets)
+    return ll_find(buckets[id], name)
+
+def ht_delete(buckets, name):
+    id= hash(name)%len(buckets)
+    buckets[id] = ll_delete(buckets[id], name)
+
+def ht_list_all(buckets):
+    data = []
+    for head in buckets:
+        current = head
+        while current:
+            data.append((current['name'], current['phone']))
+            current = current['next']
+    return sorted(data)
+
+
+
+#Двоичное дерево поиска
+def bst_insert(root, name, phone):
+    if root is None:
+        return {'name': name, 'phone': phone, 'left': None, 'right': None}
+    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
+
+def bst_find(root, name):
+    if root is None:
+        return None
+    if root['name'] == name:
+        return root['phone']
+    elif name<root['name']:
+        return bst_find(root['left'], name)
+    else:
+        return bst_find(root['right'], name)
+
+def minimum(node):
+    current = node
+    while current['left'] is not None:
+        current = current['left']
+    return current
+
+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']
+        elif root['right'] is None:
+            return root['left']
+        min=minimum(root['right'])
+        root['name']=min['name']
+        root['phone']=min['phone']
+        root['right']=bst_delete(root['right'], min['name'])
+    return root
+
+def bst_list_all(root):
+    result=[]
+    if root:
+        result.extend(bst_list_all(root['left']))
+        result.append((root['name'], root['phone']))
+        result.extend(bst_list_all(root['right']))
+    return result
+```
+
+# Экспериментальная часть
+
+## Генерация 
+Создаем список records из N=10000 элементов. Каждый элемент — кортеж (name, phone).
+Имена генерируются как f"User_{i:05d}" (равномерное распределение). Для проверки влияния порядка подготовим два варианта одного и того же набора:
+
+records_shuffled — случайный порядок.
+
+records_sorted — отсортированный по имени (по алфавиту).
+```Python
+def generate(n=10000):
+    records = [(f"User_{i:05d}", f"+7 ({random.randint(100, 999)}) {random.randint(100, 999)}-{random.randint(00, 99):02}-{random.randint(00, 99):02}") for i in range(n)]
+    records_sorted =records.copy()
+    records_shuffled=records.copy()
+    random.shuffle(records_shuffled)
+    return records_sorted, records_shuffled
+```
+## Проведение замеров
+
+**А. Вставка всех записей**  
+Создаем пустую структуру.  
+Засекаем время, выполняем insert для каждой записи из входного списка.  
+Фиксируем общее время вставки.  
+```Python
+def task_A(structure_name, data):
+    start =time.perf_counter()
+    if structure_name=="LinkedList":
+        head=None
+        for name, phone in data:
+            head = ll_insert(head, name, phone)
+        container=head
+    elif structure_name=="HashTable":
+        buckets=[None]*1000
+        for name, phone in data:
+            ht_insert(buckets, name, phone)
+        container=buckets
+    elif structure_name=="BinarySearchTree":
+        root=None
+        for name, phone in data:
+            root = bst_insert(root, name, phone)
+        container=root
+    end = time.perf_counter()
+    elapsed = end - start
+    return elapsed, container
+```
+
+**Б. Поиск 100 случайных записей**  
+Берем 100 случайных имён из того же набора (гарантированно существующих) и 10 имён, которых нет ("None_{i}").  
+Засекаем время на выполнение всех 110 вызовов find.  
+```Python
+def task_B(structure_name,container, data):
+    start=time.perf_counter()
+    if structure_name=="LinkedList":
+        for name in data:
+            ll_find(container, name)
+    elif structure_name=="HashTable":
+        for name in data:
+            ht_find(container, name)
+    elif structure_name=="BinarySearchTree":
+        for name in data:
+            bst_find(container, name)
+    end=time.perf_counter()
+    elapsed = end - start
+    return elapsed
+```
+
+**В. Удаление 50 случайных записей**  
+Берем 50 случайных имён из набора.  
+Засекаем время на выполнение delete для каждого.
+```Python
+def task_C(structure_name,container, data):
+    start=time.perf_counter()
+    if structure_name=="LinkedList":
+        for name in data:
+            container=ll_delete(container, name)
+    elif structure_name=="HashTable":
+        for name in data:
+            ht_delete(container, name)
+    elif structure_name=="BinarySearchTree":
+        for name in data:
+            container = bst_delete(container, name)
+    end=time.perf_counter()
+    elapsed = end - start
+    return elapsed
+```
+
+### Реализация замеров
+```Python
+results=[["Структура", "Режим", "Операция", "Время (сек)"]]
+structures_name=["LinkedList", "HashTable", "BinarySearchTree"]
+experiment_name=["Вставка", "Поиск", "Удаление"]
+mode_of_data=["Случайный", "Отсортированный"]
+
+records_sorted, records_shuffled = generate()
+container_shuffled=[]#хранилище структур со случайными данными
+container_sorted=[]#хранилище структур с отсортированными данными
+names=[record[0] for record in records_shuffled]
+#Данные для задания Б
+random_names=random.sample(names, 100)
+missing_names=[f"None_{i}" for i in range(10)]
+names_for_test=random_names+missing_names
+#Данные для задания В
+names_to_delete=random.sample(names,50)
+
+for i in range(3):
+    container_shuffled.append(task_A(structures_name[i], records_shuffled)[1])
+    container_sorted.append(task_A(structures_name[i], records_sorted)[1])
+    for j in range(5):
+        # Реализация задания А
+        result_shuffled = task_A(structures_name[i], records_shuffled)[0]
+        results.append([structures_name[i], mode_of_data[0], experiment_name[0], result_shuffled])
+
+        result_sorted= task_A(structures_name[i], records_sorted)[0]
+        results.append([structures_name[i], mode_of_data[1], experiment_name[0], result_sorted])
+        print(f"{structures_name[i]}: Время вставки всех записей {mode_of_data[0]}: {result_shuffled}  {mode_of_data[1]}: {result_sorted}")
+        # Реализация задания Б
+        result_shuffled = task_B(structures_name[i], container_shuffled[i], names_for_test)
+        results.append([structures_name[i], mode_of_data[0], experiment_name[1], result_shuffled])
+
+        result_sorted = task_B(structures_name[i], container_sorted[i], names_for_test)
+        results.append([structures_name[i], mode_of_data[1], experiment_name[1], result_sorted])
+        print(f"{structures_name[i]}: Время нахождения 110 записей для {mode_of_data[0]}: {result_shuffled}  {mode_of_data[1]}: {result_sorted}  ")
+        #Реализация задания В
+        shuffled = container_shuffled[i]
+        sorted = container_sorted[i]
+        result_shuffled = task_C(structures_name[i], shuffled, names_to_delete)
+        results.append([structures_name[i], mode_of_data[0], experiment_name[2], result_shuffled])
+
+        result_sorted = task_C(structures_name[i], sorted, names_to_delete)
+        results.append([structures_name[i], mode_of_data[1], experiment_name[2], result_sorted])
+        print(f"{structures_name[i]}: Время удаления 50 записей для {mode_of_data[0]}: {result_shuffled}  {mode_of_data[1]}: {result_sorted}")
+```
+
+## Сохранение результатов
+```Python
+current_dir=Path.cwd()
+target=current_dir.parent/"docs"/"data"
+csv_file=target /"results.csv"
+with open(csv_file, "w", newline="",encoding="utf-8-sig") as f:
+    writer = csv.writer(f)
+    writer.writerows(results)
+```
+
+# Анализ результатов  
+
+## Построение графиков
+```Python
+df = pd.read_csv(csv_file)
+df_avg = df.groupby(["Структура", "Режим", "Операция"])["Время (сек)"].mean().reset_index()
+fig, axes = plt.subplots(1, 3, figsize=(18, 6))
+for i, experiment in enumerate(experiment_name):
+    data_experiment = df_avg[df_avg["Операция"] == experiment]
+    sns.barplot(ax=axes[i],data=data_experiment, x="Структура",y="Время (сек)",hue="Режим")
+    axes[i].set_title(experiment)
+    axes[i].set_ylabel("Среднее время (сек)")
+    axes[i].set_yscale("log")
+plt.tight_layout()
+png_file= target/"graphics.png"
+plt.savefig(png_file, dpi=300, bbox_inches='tight')
+plt.show()
+```
+![](data/graphics.png)
+
+### Как порядок входных данных влияет на скорость вставки в BST
+Если подать на вход отсортированные данные, дерево превращается в связный список: каждый новый узел становится правым потомком предыдущего. И сложность меняется с логарифмической O(log n) на линейную O(n). Вставка для неотсортированных данных заняла 0.016531 с, а для отсортированных: 7.112118 с, разница в 430 раз. Получается, что BST сильно зависит от входных данных.
+### Почему хеш-таблица почти не чувствительна к порядку
+Хеш-таблица имеет низкую чувствительность к порядку входных данных, поскольку хеш-функция вычисляет индекс в массиве на основе значения ключа, обеспечивая равномерное распределение элементов по бакетам независимо от их исходной последовательности. По графикам видно, что разница между случайными и отсортированными данными минимальна. И для всех операций сложность составляет O(1).
+### Почему связный список всегда медленен при поиске
+Связный список всегда медленен при поиске, потому что у него отсутствует прямой доступ к элементам, и нужно перебирать все элементы по порядку. И из-за этого связный список имееет сложность O(n).
+### Как удаление работает в каждой структуре
+- **Связный список:** Сначала программа ищет нужный элемент, перебирая их по порядку от головы, что занимает время O(n). Как только элемент найден, то у предыдущего обновляется ссылка на элемент, который шел после удаляемого, что занимает время O(1). По графикам видно, что время удаления близко ко времени поиска. Время удаления для отсортированных данных: 0.017500 с, а для случайных: 0.018947 с.
+- **Хеш-таблица:** Программа определяет нужный бакет и удаляет элемент из короткого связного списка внутри этого бакета за O(1). Время удаления для отсортированных данных: 0.000036 с, а для случайных: 0.000043 с.
+- **Двоичное дерево поиска:** Нет потомков: Узел просто стирается. Один потомок: Потомок занимает место удаленного родителя. Два потомка: На место удаленного узла ставится самый минимальный элемент из его правого поддерева. Для случайных данных занимает O(log n), а для отсортированных данных занимает O(n). Время удаления для отсортированных данных: 0.039463 с, а для случайных: 0.000153 с.
+
+# Вывод
+На основе полученных результатов можно сделать вывод:
+- **Связный список:** всегда имеет линейную сложность O(n), что делает его неподходящим для задач частых вставок, частого поиска и получения данных в порядке. Но подходит только в узких случаях: максимально быстрая вставка и удаление элементов в начало или конец структуры(очереди, стеки).
+- **Хеш-таблица:** является лучшим выбором для максимально задач частого поиска, добавления и удаления элементов, которые имеют сложность O(1), при этом порядок входных данных не имеет значение. Она идеально подходит для словарей и кэшей.
+- **Двоичное дерево поиска:** Необходимо использовать в тех случаях, когда необходимо получать данные в отсортированном состоянии и выполнять поиск в заданном диапазоне значений. При случайных входных данных имеет хорошую сложность O(log n), но при получении отсортированных входных данных сложность возрастает до линейной O(n).
+
+Таким образом, для реальных задач наиболее подходят хеш-таблицы или сбалансированные деревья, если требуется получить данные в отсортированном виде.

YanyaevAA/docs/data/results.csv

@@ -0,0 +1,91 @@
+Структура,Режим,Операция,Время (сек)
+LinkedList,Случайный,Вставка,1.3509334000045783
+LinkedList,Отсортированный,Вставка,1.3042261000009603
+LinkedList,Случайный,Поиск,0.01588919999630889
+LinkedList,Отсортированный,Поиск,0.014776199997868389
+LinkedList,Случайный,Удаление,0.012387100003252272
+LinkedList,Отсортированный,Удаление,0.008979600002930965
+LinkedList,Случайный,Вставка,1.3995262999960687
+LinkedList,Отсортированный,Вставка,1.3076703999977326
+LinkedList,Случайный,Поиск,0.01563009999517817
+LinkedList,Отсортированный,Поиск,0.014876699999149423
+LinkedList,Случайный,Удаление,0.020549799999571405
+LinkedList,Отсортированный,Удаление,0.019360199999937322
+LinkedList,Случайный,Вставка,1.3874801999991178
+LinkedList,Отсортированный,Вставка,1.2993992000047
+LinkedList,Случайный,Поиск,0.015836999999010004
+LinkedList,Отсортированный,Поиск,0.014835000001767185
+LinkedList,Случайный,Удаление,0.020929600003000814
+LinkedList,Отсортированный,Удаление,0.02016870000079507
+LinkedList,Случайный,Вставка,1.3857238999989931
+LinkedList,Отсортированный,Вставка,1.3020963999952073
+LinkedList,Случайный,Поиск,0.015273999997589272
+LinkedList,Отсортированный,Поиск,0.014580000002752058
+LinkedList,Случайный,Удаление,0.0203378000005614
+LinkedList,Отсортированный,Удаление,0.019558400003006682
+LinkedList,Случайный,Вставка,1.4175892999992357
+LinkedList,Отсортированный,Вставка,1.3036662000013166
+LinkedList,Случайный,Поиск,0.015531899996858556
+LinkedList,Отсортированный,Поиск,0.014790299996093381
+LinkedList,Случайный,Удаление,0.0205294999977923
+LinkedList,Отсортированный,Удаление,0.019432499997492414
+HashTable,Случайный,Вставка,0.0048284000004059635
+HashTable,Отсортированный,Вставка,0.00405250000039814
+HashTable,Случайный,Поиск,9.529999806545675e-05
+HashTable,Отсортированный,Поиск,6.0999998822808266e-05
+HashTable,Случайный,Удаление,4.990000161342323e-05
+HashTable,Отсортированный,Удаление,3.060000017285347e-05
+HashTable,Случайный,Вставка,0.0040650000009918585
+HashTable,Отсортированный,Вставка,0.0039127000054577366
+HashTable,Случайный,Поиск,5.650000093737617e-05
+HashTable,Отсортированный,Поиск,4.53000029665418e-05
+HashTable,Случайный,Удаление,5.3499999921768904e-05
+HashTable,Отсортированный,Удаление,4.27999984822236e-05
+HashTable,Случайный,Вставка,0.004214900000079069
+HashTable,Отсортированный,Вставка,0.03241159999743104
+HashTable,Случайный,Поиск,5.999999848427251e-05
+HashTable,Отсортированный,Поиск,5.619999865302816e-05
+HashTable,Случайный,Удаление,4.2100000428035855e-05
+HashTable,Отсортированный,Удаление,3.979999746661633e-05
+HashTable,Случайный,Вставка,0.004221499999403022
+HashTable,Отсортированный,Вставка,0.004123199993046001
+HashTable,Случайный,Поиск,4.7599998652003706e-05
+HashTable,Отсортированный,Поиск,4.7299996367655694e-05
+HashTable,Случайный,Удаление,3.6600002204068005e-05
+HashTable,Отсортированный,Удаление,3.4900003811344504e-05
+HashTable,Случайный,Вставка,0.004094500000064727
+HashTable,Отсортированный,Вставка,0.0039883999997982755
+HashTable,Случайный,Поиск,4.220000118948519e-05
+HashTable,Отсортированный,Поиск,4.189999890513718e-05
+HashTable,Случайный,Удаление,3.440000000409782e-05
+HashTable,Отсортированный,Удаление,3.2000003557186574e-05
+BinarySearchTree,Случайный,Вставка,0.01629050000337884
+BinarySearchTree,Отсортированный,Вставка,7.1500338000041666
+BinarySearchTree,Случайный,Поиск,0.00027830000180983916
+BinarySearchTree,Отсортированный,Поиск,0.05988200000138022
+BinarySearchTree,Случайный,Удаление,0.0001686000032350421
+BinarySearchTree,Отсортированный,Удаление,0.03961960000015097
+BinarySearchTree,Случайный,Вставка,0.016419899999164045
+BinarySearchTree,Отсортированный,Вставка,7.092110900004627
+BinarySearchTree,Случайный,Поиск,0.0002615000048535876
+BinarySearchTree,Отсортированный,Поиск,0.060809999995399266
+BinarySearchTree,Случайный,Удаление,0.00014789999841013923
+BinarySearchTree,Отсортированный,Удаление,0.039564300001075026
+BinarySearchTree,Случайный,Вставка,0.016564800003834534
+BinarySearchTree,Отсортированный,Вставка,7.115889100001368
+BinarySearchTree,Случайный,Поиск,0.000284100002318155
+BinarySearchTree,Отсортированный,Поиск,0.06236229999922216
+BinarySearchTree,Случайный,Удаление,0.00015389999316539615
+BinarySearchTree,Отсортированный,Удаление,0.03888590000133263
+BinarySearchTree,Случайный,Вставка,0.01672099999996135
+BinarySearchTree,Отсортированный,Вставка,7.124367500000517
+BinarySearchTree,Случайный,Поиск,0.00027630000113276765
+BinarySearchTree,Отсортированный,Поиск,0.06082099999912316
+BinarySearchTree,Случайный,Удаление,0.00014789999841013923
+BinarySearchTree,Отсортированный,Удаление,0.03982890000042971
+BinarySearchTree,Случайный,Вставка,0.016656699997838587
+BinarySearchTree,Отсортированный,Вставка,7.078189200001361
+BinarySearchTree,Случайный,Поиск,0.0002753000007942319
+BinarySearchTree,Отсортированный,Поиск,0.05944880000606645
+BinarySearchTree,Случайный,Удаление,0.00014619999274145812
+BinarySearchTree,Отсортированный,Удаление,0.039416899999196175

YanyaevAA/task1/[1].py

@@ -0,0 +1,256 @@
+import time
+from pathlib import Path
+import random
+import csv
+import sys
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+sys.setrecursionlimit(12000)
+#Связный список
+def ll_insert(head, name, phone):
+    current = head
+    while current:
+        if current['name'] == name:
+            current['phone'] = phone
+            return head
+        current = current['next']
+    new_node = {'name': name, 'phone': phone, 'next': None}
+    new_node['next'] = head
+    return new_node
+
+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['name'] == name:
+        return head['next']
+    current = head
+    while current['next']:
+        if current['next']['name'] == name:
+            current['next'] = current['next']['next']
+            break
+        current = current['next']
+    return head
+
+def ll_list_all(head):
+    data= []
+    current = head
+    while current:
+        data.append((current['name'], current['phone']))
+        current = current['next']
+    return sorted(data)
+
+#хэш-таблица
+def ht_insert(buckets, name, phone):
+    id=hash(name)%len(buckets)
+    buckets[id] = ll_insert(buckets[id], name, phone)
+
+def ht_find(buckets, name):
+    id= hash(name)%len(buckets)
+    return ll_find(buckets[id], name)
+
+def ht_delete(buckets, name):
+    id= hash(name)%len(buckets)
+    buckets[id] = ll_delete(buckets[id], name)
+
+def ht_list_all(buckets):
+    data = []
+    for head in buckets:
+        current = head
+        while current:
+            data.append((current['name'], current['phone']))
+            current = current['next']
+    return sorted(data)
+
+
+
+#Двоичное дерево поиска
+def bst_insert(root, name, phone):
+    if root is None:
+        return {'name': name, 'phone': phone, 'left': None, 'right': None}
+    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
+
+def bst_find(root, name):
+    if root is None:
+        return None
+    if root['name'] == name:
+        return root['phone']
+    elif name<root['name']:
+        return bst_find(root['left'], name)
+    else:
+        return bst_find(root['right'], name)
+
+def minimum(node):
+    current = node
+    while current['left'] is not None:
+        current = current['left']
+    return current
+
+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']
+        elif root['right'] is None:
+            return root['left']
+        min=minimum(root['right'])
+        root['name']=min['name']
+        root['phone']=min['phone']
+        root['right']=bst_delete(root['right'], min['name'])
+    return root
+
+def bst_list_all(root):
+    result=[]
+    if root:
+        result.extend(bst_list_all(root['left']))
+        result.append((root['name'], root['phone']))
+        result.extend(bst_list_all(root['right']))
+    return result
+
+
+
+#1. Генерация тестовых данных
+def generate(n=10000):
+    records = [(f"User_{i:05d}", f"+7 ({random.randint(100, 999)}) {random.randint(100, 999)}-{random.randint(00, 99):02}-{random.randint(00, 99):02}") for i in range(n)]
+    records_sorted =records.copy()
+    records_shuffled=records.copy()
+    random.shuffle(records_shuffled)
+    return records_sorted, records_shuffled
+
+#3.Проведение замеров
+#А. Вставка всех записей
+def task_A(structure_name, data):
+    start =time.perf_counter()
+    if structure_name=="LinkedList":
+        head=None
+        for name, phone in data:
+            head = ll_insert(head, name, phone)
+        container=head
+    elif structure_name=="HashTable":
+        buckets=[None]*1000
+        for name, phone in data:
+            ht_insert(buckets, name, phone)
+        container=buckets
+    elif structure_name=="BinarySearchTree":
+        root=None
+        for name, phone in data:
+            root = bst_insert(root, name, phone)
+        container=root
+    end = time.perf_counter()
+    elapsed = end - start
+    return elapsed, container
+
+#Б. Поиск 100 случайных записей
+def task_B(structure_name,container, data):
+    start=time.perf_counter()
+    if structure_name=="LinkedList":
+        for name in data:
+            ll_find(container, name)
+    elif structure_name=="HashTable":
+        for name in data:
+            ht_find(container, name)
+    elif structure_name=="BinarySearchTree":
+        for name in data:
+            bst_find(container, name)
+    end=time.perf_counter()
+    elapsed = end - start
+    return elapsed
+
+#В. Удаление 50 случайных чисел
+def task_C(structure_name,container, data):
+    start=time.perf_counter()
+    if structure_name=="LinkedList":
+        for name in data:
+            container=ll_delete(container, name)
+    elif structure_name=="HashTable":
+        for name in data:
+            ht_delete(container, name)
+    elif structure_name=="BinarySearchTree":
+        for name in data:
+            container = bst_delete(container, name)
+    end=time.perf_counter()
+    elapsed = end - start
+    return elapsed
+results=[["Структура", "Режим", "Операция", "Время (сек)"]]
+structures_name=["LinkedList", "HashTable", "BinarySearchTree"]
+experiment_name=["Вставка", "Поиск", "Удаление"]
+mode_of_data=["Случайный", "Отсортированный"]
+
+records_sorted, records_shuffled = generate()
+container_shuffled=[]#хранилище структур со случайными данными
+container_sorted=[]#хранилище структур с отсортированными данными
+names=[record[0] for record in records_shuffled]
+#Данные для задания Б
+random_names=random.sample(names, 100)
+missing_names=[f"None_{i}" for i in range(10)]
+names_for_test=random_names+missing_names
+#Данные для задания В
+names_to_delete=random.sample(names,50)
+
+for i in range(3):
+    container_shuffled.append(task_A(structures_name[i], records_shuffled)[1])
+    container_sorted.append(task_A(structures_name[i], records_sorted)[1])
+    for j in range(5):
+        # Реализация задания А
+        result_shuffled = task_A(structures_name[i], records_shuffled)[0]
+        results.append([structures_name[i], mode_of_data[0], experiment_name[0], result_shuffled])
+
+        result_sorted= task_A(structures_name[i], records_sorted)[0]
+        results.append([structures_name[i], mode_of_data[1], experiment_name[0], result_sorted])
+        print(f"{structures_name[i]}: Время вставки всех записей {mode_of_data[0]}: {result_shuffled}  {mode_of_data[1]}: {result_sorted}")
+        # Реализация задания Б
+        result_shuffled = task_B(structures_name[i], container_shuffled[i], names_for_test)
+        results.append([structures_name[i], mode_of_data[0], experiment_name[1], result_shuffled])
+
+        result_sorted = task_B(structures_name[i], container_sorted[i], names_for_test)
+        results.append([structures_name[i], mode_of_data[1], experiment_name[1], result_sorted])
+        print(f"{structures_name[i]}: Время нахождения 110 записей для {mode_of_data[0]}: {result_shuffled}  {mode_of_data[1]}: {result_sorted}  ")
+        #Реализация задания В
+        shuffled = container_shuffled[i]
+        sorted = container_sorted[i]
+        result_shuffled = task_C(structures_name[i], shuffled, names_to_delete)
+        results.append([structures_name[i], mode_of_data[0], experiment_name[2], result_shuffled])
+
+        result_sorted = task_C(structures_name[i], sorted, names_to_delete)
+        results.append([structures_name[i], mode_of_data[1], experiment_name[2], result_sorted])
+        print(f"{structures_name[i]}: Время удаления 50 записей для {mode_of_data[0]}: {result_shuffled}  {mode_of_data[1]}: {result_sorted}")
+
+#4. Сохранение результатов\
+current_dir=Path.cwd()
+target=current_dir.parent/"docs"/"data"
+csv_file=target /"results.csv"
+with open(csv_file, "w", newline="",encoding="utf-8-sig") as f:
+    writer = csv.writer(f)
+    writer.writerows(results)
+
+#Построение графиков
+df = pd.read_csv(csv_file)
+df_avg = df.groupby(["Структура", "Режим", "Операция"])["Время (сек)"].mean().reset_index()
+fig, axes = plt.subplots(1, 3, figsize=(18, 6), sharey=True)
+for i, experiment in enumerate(experiment_name):
+    data_experiment = df_avg[df_avg["Операция"] == experiment]
+    sns.barplot(ax=axes[i],data=data_experiment, x="Структура",y="Время (сек)",hue="Режим")
+    axes[i].set_title(experiment)
+    axes[i].set_ylabel("Среднее время (сек)")
+    axes[i].set_yscale("log")
+plt.tight_layout()
+png_file= target/"graphics.png"
+plt.savefig(png_file, dpi=300, bbox_inches='tight')
+plt.show()