Merge pull request '[0] initial commit' (#170) from Smirnovvs/2026-rff_mp:Smirnovvs into develop

Reviewed-on: UNN/2026-rff_mp#170

MalkinMV/428b.md

@@ -0,0 +1 @@
+428b

semyanovra/docs/experiment_setup.md

@@ -1,14 +0,0 @@
-# Эксперимент 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

@@ -1,109 +0,0 @@
-"""
-Экспериментальная часть. Пункт 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/measure_time.py

@@ -1,129 +0,0 @@
-"""
-Экспериментальная часть. Пункт 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Готово. Замеры можно проводить после реализации структур.")