Ezhovnd/phonebook.py

@@ -1,367 +0,0 @@
-# ============================================================
-# Задание 1 — структуры данных: телефонный справочник
-# Процедурная парадигма (без классов)
-# ============================================================
-
-import random
-import time
-import csv
-
-# ============================================================
-# 1. СВЯЗНЫЙ СПИСОК
-# ============================================================
-
-def ll_new_node(name, phone):
-    return {'name': name, 'phone': phone, 'next': None}
-
-def ll_insert(head, name, phone):
-    """Добавить или обновить запись. Возвращает новую голову."""
-    node = head
-    while node is not None:
-        if node['name'] == name:
-            node['phone'] = phone  # обновить существующий
-            return head
-        node = node['next']
-    # Не нашли — вставляем в начало
-    new_node = ll_new_node(name, phone)
-    new_node['next'] = head
-    return new_node
-
-def ll_find(head, name):
-    """Найти телефон по имени. Возвращает телефон или None."""
-    node = head
-    while node is not None:
-        if node['name'] == name:
-            return node['phone']
-        node = node['next']
-    return None
-
-def ll_delete(head, name):
-    """Удалить запись. Возвращает новую голову."""
-    if head is None:
-        return None
-    if head['name'] == name:
-        return head['next']
-    prev = head
-    node = head['next']
-    while node is not None:
-        if node['name'] == name:
-            prev['next'] = node['next']
-            return head
-        prev = node
-        node = node['next']
-    return head  # не нашли — без изменений
-
-def ll_list_all(head):
-    """Собрать все записи и вернуть отсортированный список (name, phone)."""
-    result = []
-    node = head
-    while node is not None:
-        result.append((node['name'], node['phone']))
-        node = node['next']
-    result.sort(key=lambda x: x[0])
-    return result
-
-
-# ============================================================
-# 2. ХЕШ-ТАБЛИЦА (на основе связных списков)
-# ============================================================
-
-def ht_new(size=1024):
-    """Создать пустую хеш-таблицу (список бакетов)."""
-    return [None] * size
-
-def ht_hash(buckets, name):
-    """Полиномиальный хеш строки по модулю размера таблицы."""
-    h = 0
-    for ch in name:
-        h = (h * 31 + ord(ch)) % len(buckets)
-    return h
-
-def ht_insert(buckets, name, phone):
-    idx = ht_hash(buckets, name)
-    buckets[idx] = ll_insert(buckets[idx], name, phone)
-
-def ht_find(buckets, name):
-    idx = ht_hash(buckets, name)
-    return ll_find(buckets[idx], name)
-
-def ht_delete(buckets, name):
-    idx = ht_hash(buckets, name)
-    buckets[idx] = ll_delete(buckets[idx], name)
-
-def ht_list_all(buckets):
-    result = []
-    for bucket in buckets:
-        node = bucket
-        while node is not None:
-            result.append((node['name'], node['phone']))
-            node = node['next']
-    result.sort(key=lambda x: x[0])
-    return result
-
-
-# ============================================================
-# 3. ДВОИЧНОЕ ДЕРЕВО ПОИСКА (BST)
-# ============================================================
-
-def bst_new_node(name, phone):
-    return {'name': name, 'phone': phone, 'left': None, 'right': None}
-
-def bst_insert(root, name, phone):
-    """Вставить или обновить запись (итеративно). Возвращает новый корень."""
-    new_node = bst_new_node(name, phone)
-    if root is None:
-        return new_node
-    node = root
-    while True:
-        if name < node['name']:
-            if node['left'] is None:
-                node['left'] = new_node
-                break
-            node = node['left']
-        elif name > node['name']:
-            if node['right'] is None:
-                node['right'] = new_node
-                break
-            node = node['right']
-        else:
-            node['phone'] = phone  # обновить
-            break
-    return root
-
-def bst_find(root, name):
-    """Найти телефон. Возвращает телефон или None."""
-    while root is not None:
-        if name < root['name']:
-            root = root['left']
-        elif name > root['name']:
-            root = root['right']
-        else:
-            return root['phone']
-    return None
-
-def _bst_min_node(node):
-    """Найти узел с минимальным ключом в поддереве."""
-    while node['left'] is not None:
-        node = node['left']
-    return node
-
-def bst_delete(root, name):
-    """Удалить узел (итеративно). Возвращает новый корень."""
-    parent = None
-    node = root
-    is_left = False
-    # Найти узел и его родителя
-    while node is not None and node['name'] != name:
-        parent = node
-        if name < node['name']:
-            node = node['left']
-            is_left = True
-        else:
-            node = node['right']
-            is_left = False
-    if node is None:
-        return root  # не нашли
-
-    # Удалить найденный узел
-    if node['left'] is None:
-        replacement = node['right']
-    elif node['right'] is None:
-        replacement = node['left']
-    else:
-        # Два потомка: найти in-order successor
-        succ_parent = node
-        succ = node['right']
-        while succ['left'] is not None:
-            succ_parent = succ
-            succ = succ['left']
-        node['name'] = succ['name']
-        node['phone'] = succ['phone']
-        # Удалить successor
-        if succ_parent is node:
-            succ_parent['right'] = succ['right']
-        else:
-            succ_parent['left'] = succ['right']
-        return root
-
-    if parent is None:
-        return replacement
-    if is_left:
-        parent['left'] = replacement
-    else:
-        parent['right'] = replacement
-    return root
-
-def bst_list_all(root):
-    """Центрированный обход (итеративно) — возвращает записи в порядке ключей."""
-    result = []
-    stack = []
-    node = root
-    while stack or node is not None:
-        while node is not None:
-            stack.append(node)
-            node = node['left']
-        node = stack.pop()
-        result.append((node['name'], node['phone']))
-        node = node['right']
-    return result
-
-
-# ============================================================
-# ГЕНЕРАЦИЯ ТЕСТОВЫХ ДАННЫХ
-# ============================================================
-
-def generate_records(n=10000, seed=42):
-    rng = random.Random(seed)
-    records = []
-    for i in range(n):
-        name = f"User_{i:05d}"
-        phone = f"+7{rng.randint(9000000000, 9999999999)}"
-        records.append((name, phone))
-    return records
-
-
-# ============================================================
-# БЕНЧМАРК
-# ============================================================
-
-REPEATS = 5
-
-def bench_insert(structure_type, records):
-    times = []
-    for _ in range(REPEATS):
-        if structure_type == 'LinkedList':
-            head = None
-            start = time.perf_counter()
-            for name, phone in records:
-                head = ll_insert(head, name, phone)
-            times.append(time.perf_counter() - start)
-
-        elif structure_type == 'HashTable':
-            buckets = ht_new()
-            start = time.perf_counter()
-            for name, phone in records:
-                ht_insert(buckets, name, phone)
-            times.append(time.perf_counter() - start)
-
-        elif structure_type == 'BST':
-            root = None
-            start = time.perf_counter()
-            for name, phone in records:
-                root = bst_insert(root, name, phone)
-            times.append(time.perf_counter() - start)
-
-    return times
-
-def bench_find(structure, structure_type, search_names):
-    times = []
-    for _ in range(REPEATS):
-        start = time.perf_counter()
-        if structure_type == 'LinkedList':
-            for name in search_names:
-                ll_find(structure, name)
-        elif structure_type == 'HashTable':
-            for name in search_names:
-                ht_find(structure, name)
-        elif structure_type == 'BST':
-            for name in search_names:
-                bst_find(structure, name)
-        times.append(time.perf_counter() - start)
-    return times
-
-def bench_delete(structure, structure_type, delete_names):
-    times = []
-    for _ in range(REPEATS):
-        if structure_type == 'LinkedList':
-            s = structure  # head
-            start = time.perf_counter()
-            for name in delete_names:
-                s = ll_delete(s, name)
-            times.append(time.perf_counter() - start)
-
-        elif structure_type == 'HashTable':
-            start = time.perf_counter()
-            for name in delete_names:
-                ht_delete(structure, name)
-            times.append(time.perf_counter() - start)
-
-        elif structure_type == 'BST':
-            s = structure  # root
-            start = time.perf_counter()
-            for name in delete_names:
-                s = bst_delete(s, name)
-            times.append(time.perf_counter() - start)
-
-    return times
-
-
-def build_structure(structure_type, records):
-    if structure_type == 'LinkedList':
-        head = None
-        for name, phone in records:
-            head = ll_insert(head, name, phone)
-        return head
-    elif structure_type == 'HashTable':
-        buckets = ht_new()
-        for name, phone in records:
-            ht_insert(buckets, name, phone)
-        return buckets
-    elif structure_type == 'BST':
-        root = None
-        for name, phone in records:
-            root = bst_insert(root, name, phone)
-        return root
-
-
-def run_all_benchmarks(n=10000):
-    rng = random.Random(99)
-    records_shuffled = generate_records(n)
-    random.Random(7).shuffle(records_shuffled)
-    records_sorted = sorted(generate_records(n), key=lambda x: x[0])
-
-    all_names = [r[0] for r in generate_records(n)]
-    search_names = rng.choices(all_names, k=100) + [f"None_{i}" for i in range(10)]
-    delete_names = rng.choices(all_names, k=50)
-
-    structures = ['LinkedList', 'HashTable', 'BST']
-    modes = [('shuffled', records_shuffled), ('sorted', records_sorted)]
-
-    rows = [["Structure", "Mode", "Operation", "Run", "Time_sec"]]
-
-    for struct in structures:
-        for mode_name, records in modes:
-            print(f"  [{struct}] [{mode_name}] insert...", flush=True)
-            ins_times = bench_insert(struct, records)
-            for i, t in enumerate(ins_times):
-                rows.append([struct, mode_name, 'insert', i + 1, round(t, 6)])
-
-            # Построить структуру один раз для find/delete
-            print(f"  [{struct}] [{mode_name}] building structure for find/delete...", flush=True)
-            s = build_structure(struct, records)
-
-            print(f"  [{struct}] [{mode_name}] find...", flush=True)
-            find_times = bench_find(s, struct, search_names)
-            for i, t in enumerate(find_times):
-                rows.append([struct, mode_name, 'find', i + 1, round(t, 6)])
-
-            print(f"  [{struct}] [{mode_name}] delete...", flush=True)
-            del_times = bench_delete(s, struct, delete_names)
-            for i, t in enumerate(del_times):
-                rows.append([struct, mode_name, 'delete', i + 1, round(t, 6)])
-
-    return rows
-
-
-if __name__ == '__main__':
-    import sys
-    N = int(sys.argv[1]) if len(sys.argv) > 1 else 10000
-    print(f"Running benchmarks with N={N}, {REPEATS} repeats each...")
-    rows = run_all_benchmarks(N)
-
-    out_path = '/home/claude/docs/data/results.csv'
-    import os; os.makedirs('/home/claude/docs/data', exist_ok=True)
-    with open(out_path, 'w', newline='', encoding='utf-8') as f:
-        csv.writer(f).writerows(rows)
-    print(f"Results saved to {out_path}")
-    print(f"Total rows: {len(rows) - 1}")

Ezhovnd/report.md

@@ -1,142 +0,0 @@
-# Задание 1 — Структуры данных: телефонный справочник
-
-## Цель работы
-
-Реализовать три структуры данных «с нуля» в процедурной парадигме (без классов):
-- **Связный список** (LinkedList)
-- **Хеш-таблица** (HashTable)
-- **Двоичное дерево поиска** (BST)
-
-Применить их для хранения записей телефонного справочника и экспериментально сравнить производительность.
-
----
-
-## Реализация
-
-Все структуры реализованы в файле `phonebook.py`. Узлы представлены Python-словарями.
-
-### 1. Связный список
-
-Узел: `{'name': str, 'phone': str, 'next': None | dict}`
-
-| Функция | Сложность | Описание |
-|---|---|---|
-| `ll_insert(head, name, phone)` | O(n) | Поиск по списку + вставка в начало |
-| `ll_find(head, name)` | O(n) | Линейный поиск |
-| `ll_delete(head, name)` | O(n) | Поиск предшественника + удаление |
-| `ll_list_all(head)` | O(n log n) | Сборка + сортировка |
-
-**Особенность:** вставка проверяет дубликаты, проходя весь список — O(n). При вставке в начало без проверки было бы O(1), но появились бы дубли.
-
-### 2. Хеш-таблица
-
-Хранится как список из 1024 бакетов, каждый — голова связного списка. Хеш-функция — полиномиальная (база 31).
-
-| Функция | Средняя сложность | Описание |
-|---|---|---|
-| `ht_insert` | O(1) | Хеш → вызов ll_insert в бакете |
-| `ht_find` | O(1) | Хеш → вызов ll_find |
-| `ht_delete` | O(1) | Хеш → вызов ll_delete |
-| `ht_list_all` | O(n log n) | Обход всех бакетов + сортировка |
-
-### 3. Двоичное дерево поиска (BST)
-
-Узел: `{'name': str, 'phone': str, 'left': None | dict, 'right': None | dict}`
-
-Все операции реализованы **итеративно** — чтобы избежать `RecursionError` при вырожденном дереве (10 000 уровней на отсортированных данных).
-
-| Функция | Средняя / Худший случай |
-|---|---|
-| `bst_insert` | O(log n) / O(n) |
-| `bst_find` | O(log n) / O(n) |
-| `bst_delete` | O(log n) / O(n) |
-| `bst_list_all` | O(n) всегда (in-order стек) |
-
----
-
-## Экспериментальная часть
-
-### Условия эксперимента
-
-- **N = 10 000** записей в справочнике (имена вида `User_00000 … User_09999`)
-- Два режима входных данных: **случайный** (shuffled) и **отсортированный** (sorted)
-- **5 повторов** каждого замера; в CSV сохранены все замеры + среднее
-- Поиск: 100 существующих + 10 отсутствующих имён (110 вызовов)
-- Удаление: 50 случайных существующих имён
-
-### Результаты (среднее из 5 повторов, секунды)
-
-| Структура | Режим | Вставка 10 000 | Поиск 110 | Удаление 50 |
-|---|---|---:|---:|---:|
-| LinkedList | shuffled | **2.951** | 0.03205 | 0.02936 |
-| LinkedList | sorted | 1.945 | 0.02199 | 0.02032 |
-| HashTable | shuffled | 0.02342 | 0.000182 | 0.000133 |
-| HashTable | sorted | **0.01845** | 0.000179 | 0.000130 |
-| BST | shuffled | 0.02152 | **0.000143** | **0.000077** |
-| BST | sorted | **4.640** | 0.04080 | 0.02649 |
-
-### График
-
-![Benchmark Chart](data/benchmark_chart.png)
-
-*(логарифмическая шкала Y; заштрихованные столбцы — отсортированный режим)*
-
----
-
-## Анализ результатов
-
-### Вставка
-
-**Связный список** работает медленнее всех: при каждой вставке нужно пройти весь список (~5000 шагов в среднем), чтобы проверить дубликаты. 10 000 вставок → ~50 млн шагов. Это объясняет 2–3 секунды.
-
-Интересно, что на **отсортированных** данных связный список чуть **быстрее**: вставляемые имена идут по алфавиту, поэтому при проверке дубликатов мы чаще «натыкаемся» на нужный узел ближе к началу (список хранит элементы в порядке вставки — в начале самые свежие, то есть самые «поздние» по алфавиту). Это случайный эффект раскладки в памяти.
-
-**Хеш-таблица** практически **не чувствительна к порядку** (~0.02 сек в обоих режимах). Хеш-функция равномерно распределяет ключи по бакетам — порядок обхода записей не меняет время доступа.
-
-**BST на случайных данных** (~0.02 сек) — сопоставим с хеш-таблицей. Случайные ключи строят сбалансированное дерево высотой ~log₂(10000) ≈ 13, поиск пути к каждому узлу быстрый.
-
-**BST на отсортированных данных** — катастрофа: **4.6 сек**. Каждый новый ключ больше предыдущего, поэтому дерево вырождается в правый «связный список» глубиной 10 000. Вставка i-го элемента требует i шагов → суммарно O(n²). Это и есть теоретически предсказанная деградация BST. (Дополнительно: рекурсивная реализация упала бы с `RecursionError` — потому в финальном коде используется итеративная версия.)
-
-### Поиск
-
-**Связный список** — самый медленный (0.03 сек на 110 запросов). Линейный поиск O(n): в среднем 5000 шагов на каждый запрос.
-
-**Хеш-таблица** — почти мгновенно (0.00018 сек). O(1) в среднем: вычислить хеш → проверить 1–2 узла в бакете.
-
-**BST (случайные данные)** — самый быстрый среди неотсортированных режимов (0.000143 сек): O(log n) ≈ 13 шагов.
-
-**BST (отсортированные данные)** деградирует до O(n) поиска (0.04 сек ≈ уровень связного списка).
-
-### Удаление
-
-Картина аналогична поиску: удаление требует сначала найти элемент.
-
-- **LinkedList**: ~0.02–0.03 сек на 50 удалений — O(n) каждое.
-- **HashTable**: ~0.00013 сек — O(1).
-- **BST (shuffled)**: **0.000077 сек** — самый быстрый (O(log n), плюс операция замены на successor тоже быстрая в сбалансированном дереве).
-- **BST (sorted)**: 0.026 сек — вырожденное дерево, O(n) удаление.
-
----
-
-## Выводы: какую структуру выбирать?
-
-| Задача | Рекомендация | Почему |
-|---|---|---|
-| **Частые поиски / обновления** без нужды в порядке | **Хеш-таблица** | O(1) поиск, нечувствительность к порядку данных |
-| **Данные в отсортированном порядке** (range-запросы, list_all) | **Сбалансированный BST** (AVL, красно-чёрное дерево) | In-order обход = O(n), поиск O(log n) |
-| **BST из коробки** (наша реализация) | Только для **случайных** данных! | Деградирует до O(n²) на отсортированных |
-| **Связный список** | Почти никогда для справочника | O(n) поиск и вставка — медленнее на порядки |
-| **Связный список уместен** | Очень маленький справочник (<100 записей) или LIFO/FIFO-очередь | Простота реализации, O(1) вставка в начало/конец |
-
-**Главный вывод:** для телефонного справочника с 10 000+ записей хеш-таблица — лучший выбор при произвольном доступе. BST побеждает, когда нужен отсортированный вывод и данные приходят в случайном порядке (или используется самобалансирующийся BST). Простой связный список — проигрышная стратегия при любом n > нескольких сотен.
-
----
-
-## Файлы
-
-| Файл | Описание |
-|---|---|
-| `phonebook.py` | Исходный код: структуры данных + бенчмарк |
-| `docs/data/results.csv` | Сырые замеры (90 строк, 5 повторов × 3 структуры × 2 режима × 3 операции) |
-| `docs/data/benchmark_chart.png` | График сравнения (логарифмическая шкала) |
-| `docs/report.md` | Этот отчёт |

Ezhovnd/results.csv

@@ -1,91 +0,0 @@
-Structure,Mode,Operation,Run,Time_sec
-LinkedList,shuffled,insert,1,2.818623
-LinkedList,shuffled,insert,2,2.776622
-LinkedList,shuffled,insert,3,2.932603
-LinkedList,shuffled,insert,4,3.150283
-LinkedList,shuffled,insert,5,3.077142
-LinkedList,shuffled,find,1,0.032263
-LinkedList,shuffled,find,2,0.0328
-LinkedList,shuffled,find,3,0.03149
-LinkedList,shuffled,find,4,0.031703
-LinkedList,shuffled,find,5,0.031978
-LinkedList,shuffled,delete,1,0.017758
-LinkedList,shuffled,delete,2,0.032563
-LinkedList,shuffled,delete,3,0.032256
-LinkedList,shuffled,delete,4,0.032048
-LinkedList,shuffled,delete,5,0.032178
-LinkedList,sorted,insert,1,1.833796
-LinkedList,sorted,insert,2,1.836535
-LinkedList,sorted,insert,3,2.088518
-LinkedList,sorted,insert,4,1.868659
-LinkedList,sorted,insert,5,2.096095
-LinkedList,sorted,find,1,0.021973
-LinkedList,sorted,find,2,0.021922
-LinkedList,sorted,find,3,0.022304
-LinkedList,sorted,find,4,0.02182
-LinkedList,sorted,find,5,0.021948
-LinkedList,sorted,delete,1,0.008794
-LinkedList,sorted,delete,2,0.021849
-LinkedList,sorted,delete,3,0.021325
-LinkedList,sorted,delete,4,0.021476
-LinkedList,sorted,delete,5,0.028157
-HashTable,shuffled,insert,1,0.022874
-HashTable,shuffled,insert,2,0.021475
-HashTable,shuffled,insert,3,0.019544
-HashTable,shuffled,insert,4,0.023367
-HashTable,shuffled,insert,5,0.029821
-HashTable,shuffled,find,1,0.000252
-HashTable,shuffled,find,2,0.000152
-HashTable,shuffled,find,3,0.000143
-HashTable,shuffled,find,4,0.000216
-HashTable,shuffled,find,5,0.000147
-HashTable,shuffled,delete,1,0.000208
-HashTable,shuffled,delete,2,0.000132
-HashTable,shuffled,delete,3,0.000112
-HashTable,shuffled,delete,4,0.000106
-HashTable,shuffled,delete,5,0.000106
-HashTable,sorted,insert,1,0.020814
-HashTable,sorted,insert,2,0.017296
-HashTable,sorted,insert,3,0.016897
-HashTable,sorted,insert,4,0.016796
-HashTable,sorted,insert,5,0.020424
-HashTable,sorted,find,1,0.000285
-HashTable,sorted,find,2,0.000152
-HashTable,sorted,find,3,0.00015
-HashTable,sorted,find,4,0.00015
-HashTable,sorted,find,5,0.000157
-HashTable,sorted,delete,1,0.000182
-HashTable,sorted,delete,2,0.000156
-HashTable,sorted,delete,3,0.000104
-HashTable,sorted,delete,4,0.000103
-HashTable,sorted,delete,5,0.000103
-BST,shuffled,insert,1,0.024171
-BST,shuffled,insert,2,0.021608
-BST,shuffled,insert,3,0.025746
-BST,shuffled,insert,4,0.017484
-BST,shuffled,insert,5,0.018589
-BST,shuffled,find,1,0.000218
-BST,shuffled,find,2,0.000122
-BST,shuffled,find,3,0.000139
-BST,shuffled,find,4,0.000117
-BST,shuffled,find,5,0.000121
-BST,shuffled,delete,1,0.000108
-BST,shuffled,delete,2,7.3e-05
-BST,shuffled,delete,3,6.8e-05
-BST,shuffled,delete,4,6.8e-05
-BST,shuffled,delete,5,6.8e-05
-BST,sorted,insert,1,4.498011
-BST,sorted,insert,2,4.60869
-BST,sorted,insert,3,4.558911
-BST,sorted,insert,4,4.703444
-BST,sorted,insert,5,4.830993
-BST,sorted,find,1,0.04103
-BST,sorted,find,2,0.039717
-BST,sorted,find,3,0.040988
-BST,sorted,find,4,0.0401
-BST,sorted,find,5,0.042171
-BST,sorted,delete,1,0.026369
-BST,sorted,delete,2,0.025809
-BST,sorted,delete,3,0.027687
-BST,sorted,delete,4,0.025919
-BST,sorted,delete,5,0.026676