2026-rff_mp/nikolaevda/task1/Zadanie1.py

import random
import time
import csv
import os
import traceback
import sys

sys.setrecursionlimit(30000)

def ll_insert(head, name, phone):
    
    """
    проходит до конца (или сразу добавляет в конец) 
    возвращает новую голову (если вставка в начало) или изменяет список по ссылке.
    """
    new_node = {'name': name, 'phone': phone, 'next': None}
    
    # в случае пустого списка, новый узел становится головой
    if head is None:
        return new_node
    
    # в противном случае проходим в конец списка
    current = head
    while current['next'] is not None:
        if current['name'] == name:
            current['phone'] = phone
            return head
        current = current['next']
    
    # проверяем последний узел
    if current['name'] == name:
        current['phone'] = phone
    else:
        current['next'] = new_node
    
    return head
        


def ll_find(head, name):
    
    """
    ищет узел по имени.
    возвращает телефон или None
    """
    current = head
    
    while current is not None:
        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:
        new_head = head['next']
        head['next'] = None
        return new_head
    
    # ищем узел для удаления
    current = head
    while current['next'] is not None:
        if current['next']['name'] == name:
          target = current['next']
          current['next'] = target['next']
          target['next'] = None  # разрываем связь у удаляемого узла (иными словами, обнуление ссылки)
          return head
        current = current['next']
    
    return head

def ll_collect(head, result_list):
    """собирает все данные из связного списка в result_list"""
    current = head
    while current is not None:
        result_list.append((current['name'], current['phone']))
        current = current['next']


def ll_list_all(head):
    
    """
    собирает все записи в список и сортирует
    """
    result = []
    current = head
    
    while current is not None:
        result.append((current['name'], current['phone']))
        current = current['next']
    
    # ручная сортировка пузырьком
    n = len(result)
    for i in range(n):
        for j in range(0, n - i - 1):
            if result[j][0] > result[j + 1][0]:
                result[j], result[j + 1] = result[j + 1], result[j]
    
    return result


def hash_table(size):
    """создание хеш-таблицы"""
    return [None] * size


def hash_func(name, buckets_count):
    """
    использует умножение на простое число для лучшего распределения
    """
    h = 0
    multiplier = 1
    for char in name:
        h = (h + ord(char) * multiplier) % buckets_count
        multiplier = (multiplier * 31) % buckets_count
    return h


def ht_insert(buckets, name, phone):
    """добавить или обновить запись"""
    if buckets is None:
        return
    
    index = hash_func(name, len(buckets))
    buckets[index] = ll_insert(buckets[index], name, phone)


def ht_find(buckets, name):
    """найти телефон по имени"""
    idx = hash_func(name, len(buckets))
    return ll_find(buckets[idx], name)


def ht_delete(buckets, name):
    """
    удалить запись
    """
    idx = hash_func(name, len(buckets))
    buckets[idx] = ll_delete(buckets[idx], name)


def bubble_sort(records):
    """пузырьковая сортировка"""
    n = len(records)
    for i in range(n - 1):
        swapped = False
        for j in range(n - 1 - i):
            if records[j][0] > records[j + 1][0]:
                records[j], records[j + 1] = records[j + 1], records[j]
                swapped = True
        if not swapped:
            break
    return records


def ht_list_all(buckets):
    """
    собрание всех записей и сортировка
    """
    # Собираем все записи
    full_data = []
    for head in buckets:
        ll_collect(head, full_data)
    
    # Сортируем пузырьком
    bubble_sort(full_data)
    return full_data

#Hash_table1 = hash_table(3)

#ht_insert(Hash_table1, 'Alena', '010')
#ht_insert(Hash_table1, 'Helena', '111')
#ht_insert(Hash_table1, 'Gena', '222')


#print(ht_list_all(Hash_table1))

def bst_insert(root, name, phone):
    """
    рекурсивная вставка или обновление записи
    возвращает новый корень (если корень меняется)
    """
    # если дерево пусто, создаём новый узел
    if root is None:
        return {'name': name, 'phone': phone, 'left': None, 'right': None}
    
    # вставка в левое поддерево
    if name < root['name']:
        root['left'] = bst_insert(root['left'], name, phone)
    
    # вставка в правое поддерево
    elif name > root['name']:
        root['right'] = bst_insert(root['right'], name, phone)
    
    # имя уже существует — обновляем телефон
    else:
        root['phone'] = phone
    
    return root


def bst_find(root, name):
    """
    рекурсивный поиск телефона по имени
    возвращает phone или None
    """
    # не нашли
    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 bst_find_min(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 and root['right'] is None:
            return None
        
        
        elif root['left'] is None:
            return root['right']
        elif root['right'] is None:
            return root['left']
        
        
        # находим минимальный элемент в правом поддереве
        successor = bst_find_min(root['right'])
        
        # копируем данные из преемника в текущий узел
        root['name'] = successor['name']
        root['phone'] = successor['phone']
        
        # удаляем преемника
        root['right'] = bst_delete(root['right'], successor['name'])
    
    return root


def bst_list_all(root, result=None):
    """
    центрированный (in-order) обход дерева
    рекурсивно собирает записи в отсортированном порядке
    """
    if result is None:
        result = []
    
    if root is not None:
        # сначала обходим левое поддерево (все меньшие ключи)
        bst_list_all(root['left'], result)
        
        # затем текущий узел
        result.append((root['name'], root['phone']))
        
        # затем правое поддерево (все большие ключи)
        bst_list_all(root['right'], result)
    
    return result

def generate_records(count=10000):
    """
    генерация тестовых данных
    70% уникальных имён, 30% повторяющихся (для коллизий)
    """
    records = []
    base_names = ["Алексей", "Борис", "Владимир", "Дмитрий", "Елена", 
                  "Иван", "Мария", "Николай", "Ольга", "Павел"]
    
    for i in range(count):
        if random.random() < 0.7:
            name = f"User_{i:05d}"
        else:
            name = random.choice(base_names) + f"_{random.randint(1, 100)}"
        
        phone = f"+7-{random.randint(100,999)}-{random.randint(100,999)}-{random.randint(1000,9999)}"
        records.append((name, phone))
    
    shuffled = records.copy()
    random.shuffle(shuffled)
    sorted_records = sorted(records, key=lambda x: x[0])
    
    return shuffled, sorted_records


def measure_insertion(structure_name, records):
    """
    замер времени вставки
    возвращает список замеров и заполненную структуру
    """
    times = []
    filled_structure = None
    
    for run in range(5):
        if structure_name == "linked_list":
            structure = None
        elif structure_name == "hash_table":
            structure = hash_table(2003)
        elif structure_name == "bst":
            structure = None
        
        start = time.perf_counter()
        
        for name, phone in records:
            if structure_name == "linked_list":
                structure = ll_insert(structure, name, phone)
            elif structure_name == "hash_table":
                ht_insert(structure, name, phone)
            elif structure_name == "bst":
                structure = bst_insert(structure, name, phone)
        
        end = time.perf_counter()
        times.append(end - start)
        
        if run == 4:  # Сохраняем после последнего замера
            filled_structure = structure
    
    return times, filled_structure


def measure_search(structure_name, structure, search_names):
    """
    замер времени поиска
    возвращает список замеров
    """
    times = []
    
    for run in range(5):
        start = time.perf_counter()
        
        for name in search_names:
            if structure_name == "linked_list":
                ll_find(structure, name)
            elif structure_name == "hash_table":
                ht_find(structure, name)
            elif structure_name == "bst":
                bst_find(structure, name)
        
        end = time.perf_counter()
        times.append(end - start)
    
    return times


def measure_deletion(structure_name, original_structure, delete_names):
    """
    замер времени удаления
    возвращает список замеров
    """
    times = []
    
    for run in range(5):
        # создаём копию структуры
        if structure_name == "linked_list":
            all_records = ll_list_all(original_structure)
            test_structure = None
            for name, phone in all_records:
                test_structure = ll_insert(test_structure, name, phone)
        
        elif structure_name == "hash_table":
            all_records = ht_list_all(original_structure)
            test_structure = hash_table(2003)
            for name, phone in all_records:
                ht_insert(test_structure, name, phone)
        
        elif structure_name == "bst":
            all_records = bst_list_all(original_structure)
            test_structure = None
            for name, phone in all_records:
                test_structure = bst_insert(test_structure, name, phone)
        
        start = time.perf_counter()
        
        for name in delete_names:
            if structure_name == "linked_list":
                test_structure = ll_delete(test_structure, name)
            elif structure_name == "hash_table":
                ht_delete(test_structure, name)
            elif structure_name == "bst":
                test_structure = bst_delete(test_structure, name)
        
        end = time.perf_counter()
        times.append(end - start)
    
    return times

print(f"Текущая рабочая директория: {os.getcwd()}")
print(f"Путь к файлу: {os.path.abspath(__file__)}")

def run_experiment():
    """
    запуск всех экспериментов и сохранение результатов
    """
    
    current_dir = os.path.dirname(__file__)
    docs_dir = os.path.dirname(current_dir)
    csv_file = os.path.join(docs_dir, "experiment_results.csv")
   
    
    
    os.makedirs(docs_dir, exist_ok=True)
    
    print("ЭКСПЕРИМЕНТАЛЬНОЕ СРАВНЕНИЕ СТРУКТУР ДАННЫХ")
    print("Телефонный справочник - 10000 записей")
    print(f"\nРезультаты будут сохранены в: {csv_file}")
    
    # генерация данных
    print("\n1. Генерация тестовых данных...")
    shuffled_records, sorted_records = generate_records(10000)
    print(f"Сгенерировано 10000 записей")
    print(f"Уникальных имён: {len(set([r[0] for r in shuffled_records]))}")
    
    # подготовка имён для поиска и удаления
    random.seed(42)
    existing_names = [shuffled_records[i][0] for i in random.sample(range(10000), 100)]
    nonexisting_names = [f"NotExist_{i}" for i in range(10)]
    search_names = existing_names + nonexisting_names
    delete_names = [shuffled_records[i][0] for i in random.sample(range(10000), 50)]
    
    results = [["Структура", "Режим", "Операция", 
                "Замер1(с)", "Замер2(с)", "Замер3(с)", "Замер4(с)", "Замер5(с)", 
                "Среднее(с)"]]
    
    # тестирование для каждого режима
    for mode_name, records in [("случайный", shuffled_records), 
                                ("отсортированный", sorted_records)]:
        
        print(f"\n2. Тестирование режима: {mode_name}")
        
        
        for struct_name in ["linked_list", "hash_table", "bst"]:
            print(f"\n   {struct_name.upper()}:")
            
            # вставка
            print("Вставка 10000 записей...")
            insert_times, filled_struct = measure_insertion(struct_name, records)
            avg_insert = sum(insert_times) / 5
            print(f"Время: {avg_insert:.4f} сек (среднее)")
            
            # поиск
            print("Поиск 110 записей (100 существующих + 10 которых нет)...")
            search_times = measure_search(struct_name, filled_struct, search_names)
            avg_search = sum(search_times) / 5
            print(f"Время: {avg_search:.4f} сек (среднее)")
            
            # удаление
            print("Удаление 50 случайных записей...")
            delete_times = measure_deletion(struct_name, filled_struct, delete_names)
            avg_delete = sum(delete_times) / 5
            print(f"Время: {avg_delete:.4f} сек (среднее)")
            
            # сохраняем результаты
            results.append([struct_name, mode_name, "вставка"] + insert_times + [avg_insert])
            results.append([struct_name, mode_name, "поиск"] + search_times + [avg_search])
            results.append([struct_name, mode_name, "удаление"] + delete_times + [avg_delete])
    
    # сохранение CSV
    print("\n3. Сохранение результатов...")
    try:
        with open(csv_file, "w", newline="", encoding="utf-8-sig") as f:
            writer = csv.writer(f, delimiter=';')
            writer.writerows(results)
        print(f"Результаты сохранены в: {csv_file}")
    except Exception as e:
        print(f"Ошибка сохранения: {e}")
    
    # вывод табл.
    print("СВОДНАЯ ТАБЛИЦА РЕЗУЛЬТАТОВ")
    print(f"{'Структура':<15} {'Режим':<12} {'Операция':<10} {'Среднее время (сек)':<20}")
    
    for row in results[1:]:
        struct, mode, op, t1, t2, t3, t4, t5, avg = row
        print(f"{struct:<15} {mode:<12} {op:<10} {avg:<20.6f}")
    
    return results

def create_report_table(results):
    """Создание сводной таблицы"""

    print("СВОДНАЯ ТАБЛИЦА (среднее время в секундах)")

    print(f"{'Структура':<12} {'Режим':<12} {'Вставка':<12} {'Поиск':<12} {'Удаление':<12}")

    summary = {}
    for row in results[1:]:
        struct, mode, op, _, _, _, _, _, avg = row
        key = (struct, mode)
        if key not in summary:
            summary[key] = {}
        summary[key][op] = avg
    
    names = {'linked_list': 'LinkedList', 'hash_table': 'HashTable', 'bst': 'BST'}
    for (struct, mode), ops in summary.items():
        print(f"{names[struct]:<12} {mode:<12} {ops.get('вставка', 0):<12.6f} {ops.get('поиск', 0):<12.6f} {ops.get('удаление', 0):<12.6f}")


def print_analysis():
    """вывод краткого анализа"""
  
    print("АНАЛИЗ РЕЗУЛЬТАТОВ")
 
    print("""
1. Влияние порядка данных на BST:
   - На случайных данных: быстро O(log n)
   - На отсортированных: деградация до O(n) (дерево вырождается в список)

2. Хеш-таблица не чувствительна к порядку:
   - Хеш-функция случайно распределяет данные по bucket'ам
   - Порядок вставки не влияет на время операций

3. Связный список всегда медленен при поиске:
   - Поиск требует последовательного прохода O(n)
   - Нет индексов или сортировки для ускорения

4. Сравнение удаления:
   - Связный список: O(n) — нужен поиск элемента
   - Хеш-таблица: O(1) — прямой доступ по индексу
   - BST: O(log n) в среднем, O(n) на отсортированных

5. Рекомендация для реальных задач:
   - Хеш-таблица: частый поиск, словари, кэши
   - BST (сбалансированный): нужны отсортированные данные
   - Связный список: маленькие объёмы, очереди/стеки
   - Для телефонного справочника ЛУЧШЕ: ХЕШ-ТАБЛИЦА
""")
    
def create_graphs(results):
    """Построение столбчатых диаграмм"""
    import matplotlib.pyplot as plt
    import numpy as np
    
    data = {}
    for row in results[1:]:
        struct = row[0]
        mode = row[1]
        op = row[2]
        avg = row[8]
        
        if struct not in data:
            data[struct] = {}
        if mode not in data[struct]:
            data[struct][mode] = {}
        data[struct][mode][op] = avg
    
    # Настройки
    struct_names = {'linked_list': 'LinkedList', 'hash_table': 'HashTable', 'bst': 'BST'}
    colors = {'linked_list': '#3498db', 'hash_table': '#2ecc71', 'bst': '#e74c3c'}
    modes = ['случайный', 'отсортированный']
    operations = ['вставка', 'поиск', 'удаление']
    op_titles = ['Вставка (10000 записей)', 'Поиск (110 запросов)', 'Удаление (50 записей)']
    
    fig, axes = plt.subplots(1, 3, figsize=(14, 5))
    fig.suptitle('Сравнение производительности структур данных', fontsize=14, fontweight='bold')
    
    for idx, (op, title) in enumerate(zip(operations, op_titles)):
        ax = axes[idx]
        x = np.arange(len(modes))
        width = 0.25
        multiplier = 0
        
        for struct in ['linked_list', 'hash_table', 'bst']:
            values = [data[struct][mode][op] for mode in modes]
            bars = ax.bar(x + multiplier * width, values, width, 
                         label=struct_names[struct], color=colors[struct])
            
            for bar, val in zip(bars, values):
                if val < 0.001:
                    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height(),
                           f'{val:.6f}', ha='center', va='bottom', fontsize=7)
                elif val < 0.01:
                    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height(),
                           f'{val:.5f}', ha='center', va='bottom', fontsize=7)
                else:
                    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height(),
                           f'{val:.3f}', ha='center', va='bottom', fontsize=8)
            multiplier += 1
        
        ax.set_title(title)
        ax.set_ylabel('Время (сек)')
        ax.set_yscale('log')
        ax.set_ylim(1e-5, 10)
        ax.set_xticks(x + width)
        ax.set_xticklabels(['Случайный', 'Отсортированный'])
        ax.legend()
        ax.grid(True, alpha=0.3, axis='y')
    
    plt.tight_layout()
    
    current_dir = os.path.dirname(__file__)
    docs_dir = os.path.dirname(current_dir)
    path = os.path.join(docs_dir, 'graphs.png')
    plt.savefig(path, dpi=150)
    plt.close()
    print(f"\nГрафики сохранены: {path}")
    return path 

if __name__ == "__main__":
    results = run_experiment()
    create_report_table(results)
    create_graphs(results)
    print_analysis()
  
    print("ЭКСПЕРИМЕНТ ВЫПОЛНЕН ПОЛНОСТЬЮ!")