Пункт 3: реализованы структуры данных (LinkedList, HashTable, BST)

semyanovra/docs/experiment_setup.md

@@ -0,0 +1,14 @@
+# Эксперимент 1: Генерация данных
+
+**Студент:** semyanovra
+**Ветка:** structura-dannuh
+
+## Результаты
+- Создано 10000 записей
+- Имена: User_00000 до User_09999
+- Телефоны: случайные 10 цифр
+
+## Файлы
+- `src/generate_data.py` - скрипт генерации
+- `docs/data/records_shuffled.csv` - случайный порядок
+- `docs/data/records_sorted.csv` - сортированный порядок

semyanovra/scr/generate_data.py

@@ -0,0 +1,109 @@
+"""
+Экспериментальная часть. Пункт 1: Генерация тестовых данных.
+Цель: создать список записей (имя, телефон) для дальнейшего тестирования
+структур данных (связный список, хеш-таблица, BST).
+
+Особенности реализации:
+- N = 10000 записей.
+- Два режима: случайный порядок и отсортированный по имени.
+- Имена генерируются равномерно (User_00000 ... User_09999) + небольшой
+  набор повторяющихся имен для создания коллизий в хеш-таблице.
+- Телефоны — случайные строки из 10 цифр.
+"""
+
+import random
+
+def generate_test_data(n=10000, duplicate_names_ratio=0.1):
+    """
+    Генерирует два набора записей: в случайном порядке и отсортированном.
+
+    Параметры:
+    - n: общее количество записей (по умолчанию 10000).
+    - duplicate_names_ratio: доля имен, которые будут повторяться (коллизии).
+      Например, 0.1 означает, что 10% записей будут использовать
+      имена из небольшого пула, остальные 90% — уникальные User_XXXXX.
+
+    Возвращает:
+    - records_shuffled: список кортежей (name, phone) в случайном порядке.
+    - records_sorted: тот же список, но отсортированный по имени.
+    """
+
+    # 1. Создаем пул уникальных имен (равномерное распределение)
+    #    Формат: User_00000, User_00001, ..., User_09999
+    unique_names = [f"User_{i:05d}" for i in range(n)]
+
+    # 2. Создаем небольшой пул имен для повторений (коллизий)
+    #    Например, 20 разных имен, которые будут многократно встречаться.
+    collision_pool_size = max(1, int(n * duplicate_names_ratio))  # ~1000 имен для 10000 записей (10%)
+    collision_names = [f"Common_{j:03d}" for j in range(collision_pool_size)]
+
+    # 3. Формируем итоговый список имен с повторениями
+    #    - Первые (n - collision_pool_size) записей — уникальные.
+    #    - Оставшиеся collision_pool_size записей — случайные из пула коллизий.
+    names = []
+    # Уникальная часть
+    names.extend(unique_names[:n - collision_pool_size])
+    # Часть с повторениями (для проверки коллизий в хеш-таблице)
+    for _ in range(collision_pool_size):
+        names.append(random.choice(collision_names))
+
+    # Перемешиваем имена, чтобы повторяющиеся имена не шли подряд
+    random.shuffle(names)
+
+    # 4. Генерируем случайные телефоны (10 цифр)
+    phones = []
+    for _ in range(n):
+        phone = ''.join(random.choices('0123456789', k=10))
+        phones.append(phone)
+
+    # 5. Собираем записи в список кортежей
+    records = list(zip(names, phones))
+
+    # 6. Создаем две версии: случайную и отсортированную
+    records_shuffled = records.copy()          # уже случайный порядок после shuffle
+    records_sorted = sorted(records, key=lambda x: x[0])  # сортировка по имени
+
+    return records_shuffled, records_sorted
+
+def print_sample(records, title, count=10):
+    """Вспомогательная функция: печатает первые count записей."""
+    print(f"\n{title} (первые {count} записей):")
+    for name, phone in records[:count]:
+        print(f"  {name}: {phone}")
+
+# ========== Демонстрация работы ==========
+if __name__ == "__main__":
+    # Фиксируем seed для воспроизводимости результатов
+    random.seed(42)
+
+    # Генерируем данные: N = 10000, доля коллизий 10%
+    N = 10000
+    shuffled, sorted_data = generate_test_data(N, duplicate_names_ratio=0.1)
+
+    # Выводим статистику и примеры
+    print(f"Сгенерировано {N} записей.")
+    print(f"Доля имен с повторениями (коллизиями): ~10%")
+
+    # Показываем несколько примеров из каждого набора
+    print_sample(shuffled, "Случайный порядок")
+    print_sample(sorted_data, "Отсортированный порядок")
+
+    # Дополнительно: проверка, что в отсортированном порядке имена действительно упорядочены
+    first_five_sorted = [name for name, _ in sorted_data[:5]]
+    print(f"\nПервые 5 имен в отсортированном наборе: {first_five_sorted}")
+    # Ожидается: ['Common_000', 'Common_001', ...] или 'User_...' — лексикографически
+
+    # Проверка наличия коллизий (повторяющихся имен)
+    unique_names_in_shuffled = set(name for name, _ in shuffled)
+    print(f"\nУникальных имен в случайном наборе: {len(unique_names_in_shuffled)}")
+    print(f"(меньше {N} из-за повторений для коллизий)")
+
+    # Сохраняем в файлы (опционально, для отладки)
+    # import csv
+    # with open("docs/data/records_shuffled.csv", "w") as f:
+    #     writer = csv.writer(f)
+    #     writer.writerows(shuffled)
+    # with open("docs/data/records_sorted.csv", "w") as f:
+    #     writer = csv.writer(f)
+    #     writer.writerows(sorted_data)
+

src/bst.py

@@ -0,0 +1,88 @@
+# bst.py
+# Двоичное дерево поиска по имени
+
+def create_node(name, phone):
+    """Создаёт узел дерева."""
+    return {
+        'name': name,
+        'phone': phone,
+        'left': None,
+        'right': None
+    }
+
+def bst_insert(root, name, phone):
+    """
+    Рекурсивно вставляет или обновляет запись.
+    Возвращает корень (может измениться при первой вставке).
+    """
+    if root is None:
+        return create_node(name, phone)
+
+    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):
+    """Возвращает телефон или None."""
+    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)
+
+def _min_node(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']
+
+        # Узел с двумя детьми: находим минимальный в правом поддереве
+        temp = _min_node(root['right'])
+        root['name'] = temp['name']
+        root['phone'] = temp['phone']
+        root['right'] = bst_delete(root['right'], temp['name'])
+
+    return root
+
+def bst_list_all(root):
+    """
+    Центрированный (in-order) обход – возвращает записи,
+    уже отсортированные по имени.
+    """
+    def _inorder(node, result):
+        if node is None:
+            return
+        _inorder(node['left'], result)
+        result.append((node['name'], node['phone']))
+        _inorder(node['right'], result)
+
+    records = []
+    _inorder(root, records)
+    return records

src/hash_table.py

@@ -0,0 +1,46 @@
+# hash_table.py
+# Хеш-таблица с цепочками (использует linked_list.py)
+
+import linked_list as ll
+
+def create_hash_table(size=1000):
+    """
+    Создаёт пустую хеш-таблицу.
+    size – количество корзин (рекомендуется простое число).
+    """
+    return [None] * size
+
+def _hash(name, table_size):
+    """Простая хеш-функция на основе суммы кодов символов."""
+    return sum(ord(ch) for ch in name) % table_size
+
+def ht_insert(table, name, phone):
+    """Вставляет или обновляет запись."""
+    idx = _hash(name, len(table))
+    # Вставляем в связный список в этой корзине
+    table[idx] = ll.ll_insert(table[idx], name, phone)
+
+def ht_find(table, name):
+    """Ищет телефон по имени."""
+    idx = _hash(name, len(table))
+    return ll.ll_find(table[idx], name)
+
+def ht_delete(table, name):
+    """Удаляет запись по имени."""
+    idx = _hash(name, len(table))
+    table[idx] = ll.ll_delete(table[idx], name)
+
+def ht_list_all(table):
+    """
+    Собирает все записи из всех корзин,
+    возвращает отсортированный по имени список.
+    """
+    records = []
+    for bucket in table:
+        # Каждая корзина – голова связного списка
+        current = bucket
+        while current is not None:
+            records.append((current['name'], current['phone']))
+            current = current['next']
+    records.sort(key=lambda x: x[0])
+    return record

src/linked_list.py

@@ -0,0 +1,74 @@
+# linked_list.py
+# Связный список для телефонного справочника
+
+def create_node(name, phone):
+    """Создаёт новый узел-словарь."""
+    return {'name': name, 'phone': phone, 'next': None}
+
+def ll_insert(head, name, phone):
+    """
+    Вставляет или обновляет запись.
+    Если имя уже существует – обновляет телефон.
+    Если нет – добавляет в конец списка.
+    Возвращает голову списка (может измениться, если вставка в начало).
+    """
+    # Если список пуст – создаём первый узел
+    if head is None:
+        return create_node(name, phone)
+
+    # Проверяем, не находится ли имя в первом узле
+    if head['name'] == name:
+        head['phone'] = phone
+        return head
+
+    # Ищем узел с таким именем или конец списка
+    current = head
+    while current['next'] is not None:
+        if current['next']['name'] == name:
+            current['next']['phone'] = phone
+            return head
+        current = current['next']
+
+    # Имя не найдено – добавляем в конец
+    current['next'] = create_node(name, phone)
+    return head
+
+def ll_find(head, name):
+    """Ищет телефон по имени. Возвращает phone или 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:
+        return head['next']
+
+    # Ищем предыдущий узел
+    current = head
+    while current['next'] is not None:
+        if current['next']['name'] == name:
+            current['next'] = current['next']['next']
+            return head
+        current = current['next']
+    return head
+
+def ll_list_all(head):
+    """
+    Возвращает список всех записей в виде [(name, phone), ...],
+    отсортированный по имени. Сама структура не сортируется.
+    """
+    records = []
+    current = head
+    while current is not None:
+        records.append((current['name'], current['phone']))
+        current = current['next']
+    records.sort(key=lambda x: x[0])  # сортировка по имени
+    return record

src/measure_time.py

@@ -0,0 +1,129 @@
+"""
+Экспериментальная часть. Пункт 2: Инструменты замера времени.
+Цель: предоставить функции для многократного измерения времени выполнения
+операций со структурами данных (LinkedList, HashTable, BST).
+
+Особенности:
+- Используется time.perf_counter() для высокой точности.
+- Каждый эксперимент повторяется min_runs раз (по умолчанию 5), результаты сохраняются.
+- Вычисляется среднее арифметическое и список всех замеров.
+- Результаты можно напрямую сохранить в CSV.
+"""
+
+import time
+from typing import List, Tuple, Callable, Any
+import random
+
+# Предполагается, что generate_test_data из пункта 1 уже определена
+# from experimental_part1 import generate_test_data  # если код в другом файле
+
+# ========== 1. Базовые замеры ==========
+
+def measure_time(func: Callable, *args, **kwargs) -> float:
+    """
+    Измеряет время выполнения функции func(*args, **kwargs).
+    Возвращает время в секундах (float).
+    """
+    start = time.perf_counter()
+    result = func(*args, **kwargs)
+    end = time.perf_counter()
+    return end - start, result
+
+# ========== 2. Многократные замеры с усреднением ==========
+
+def run_experiment(func: Callable, args: Tuple, min_runs: int = 5) -> Tuple[float, List[float]]:
+    """
+    Повторяет замер функции func(*args) минимум min_runs раз.
+    Возвращает (среднее_время, список_всех_замеров).
+    """
+    times = []
+    for _ in range(min_runs):
+        elapsed, _ = measure_time(func, *args)
+        times.append(elapsed)
+    avg_time = sum(times) / len(times)
+    return avg_time, times
+
+# ========== 3. Тестовые сценарии (заглушки для демонстрации) ==========
+
+# Ниже приведены примеры-заглушки для структур данных.
+# В реальной работе их нужно заменить на реализованные функции.
+
+def stub_insert(structure, name, phone):
+    """Заглушка для вставки."""
+    pass
+
+def stub_find(structure, name):
+    """Заглушка для поиска."""
+    return None
+
+def stub_delete(structure, name):
+    """Заглушка для удаления."""
+    pass
+
+def stub_list_all(structure):
+    """Заглушка для получения всех записей."""
+    return []
+
+# Пример функции, которая вставляет все записи из списка в структуру
+def insert_all(structure, records, insert_func):
+    """
+    Выполняет вставку всех записей (name, phone) в structure,
+    используя функцию insert_func(structure, name, phone).
+    """
+    for name, phone in records:
+        insert_func(structure, name, phone)
+
+# Пример замера вставки для конкретной структуры
+def benchmark_insert(structure_creator, records, insert_func, runs=5):
+    """
+    Создаёт новую структуру через structure_creator(),
+    затем измеряет время вставки всех записей.
+    """
+    def _insert_all():
+        structure = structure_creator()
+        insert_all(structure, records, insert_func)
+        return structure
+
+    avg_time, all_times = run_experiment(_insert_all, args=(), min_runs=runs)
+    return avg_time, all_times
+
+# ========== 4. Пример использования (демонстрация) ==========
+
+if __name__ == "__main__":
+    # Фиксируем seed для воспроизводимости
+    random.seed(42)
+
+    # Генерируем тестовые данные (пункт 1)
+    N = 10000
+    records_shuffled, records_sorted = generate_test_data(N, duplicate_names_ratio=0.1)
+
+    # Выбираем 100 случайных имён для поиска (существующих) и 10 несуществующих
+    existing_names = [name for name, _ in records_shuffled[:100]]  # первые 100 имён
+    nonexisting_names = [f"None_{i}" for i in range(10)]
+
+    # Для демонстрации используем заглушки
+    def dummy_creator():
+        return "dummy_structure"
+
+    print("=== Демонстрация замера времени (заглушки) ===")
+    avg, times = benchmark_insert(dummy_creator, records_shuffled, stub_insert, runs=3)
+    print(f"Среднее время вставки (заглушка): {avg:.6f} сек")
+    print(f"Все замеры: {times}")
+
+    # Пример сбора результатов для CSV
+    results = [
+        ["Структура", "Режим", "Операция", "Время (сек)"],
+        ["LinkedList", "случайный", "вставка", 0.123],
+        # ... реальные данные появятся после реализации структур
+    ]
+
+    # Сохранение в CS
+
+
+V (раскомментировать при необходимости)
+    # import csv
+    # with open("docs/data/results.csv", "w", newline="") as f:
+    #     writer = csv.writer(f)
+    #     writer.writerows(results)
+
+    print("\nГотово. Замеры можно проводить после реализации структур.")