forked from UNN/2026-rff_mp
Compare commits
8 Commits
structura-
...
develop
| Author | SHA1 | Date | |
|---|---|---|---|
| 82e988c965 | |||
| 58daf860ed | |||
| 566d89fda2 | |||
| c7229154ca | |||
| fe9ce65eb2 | |||
| 3a251f06c7 | |||
|
7e84caffc4 | ||
| 84e5d1e763 |
1
MalkinMV/428b.md
Normal file
1
MalkinMV/428b.md
Normal file
|
|
@ -0,0 +1 @@
|
|||
428b
|
||||
0
Smirnovvs/428.txt
Normal file
0
Smirnovvs/428.txt
Normal file
0
dyachenkoas/428
Normal file
0
dyachenkoas/428
Normal file
0
kalinovskiymi/428
Normal file
0
kalinovskiymi/428
Normal file
|
|
@ -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` - сортированный порядок
|
||||
|
|
@ -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)
|
||||
|
||||
|
|
@ -1,345 +0,0 @@
|
|||
import sys
|
||||
from collections import deque
|
||||
import heapq
|
||||
import time
|
||||
import os
|
||||
import csv
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
|
||||
|
||||
# ----------------------------- Модель клетки -----------------------------
|
||||
class GridCell:
|
||||
def __init__(self, x, y):
|
||||
self._x = x
|
||||
self._y = y
|
||||
self._blocked = False
|
||||
self._entry = False
|
||||
self._exit_flag = False
|
||||
|
||||
@property
|
||||
def x(self):
|
||||
return self._x
|
||||
|
||||
@property
|
||||
def y(self):
|
||||
return self._y
|
||||
|
||||
@property
|
||||
def is_wall(self):
|
||||
return self._blocked
|
||||
|
||||
@is_wall.setter
|
||||
def is_wall(self, value):
|
||||
self._blocked = value
|
||||
|
||||
@property
|
||||
def is_start(self):
|
||||
return self._entry
|
||||
|
||||
@is_start.setter
|
||||
def is_start(self, value):
|
||||
self._entry = value
|
||||
|
||||
@property
|
||||
def is_exit(self):
|
||||
return self._exit_flag
|
||||
|
||||
@is_exit.setter
|
||||
def is_exit(self, value):
|
||||
self._exit_flag = value
|
||||
|
||||
def passable(self):
|
||||
return not self._blocked
|
||||
|
||||
|
||||
# ----------------------------- Модель лабиринта -----------------------------
|
||||
class Labyrinth:
|
||||
def __init__(self, width, height):
|
||||
self._width = width
|
||||
self._height = height
|
||||
self._cells = [[GridCell(x, y) for x in range(width)] for y in range(height)]
|
||||
self._start_cell = None
|
||||
self._exit_cell = None
|
||||
|
||||
@property
|
||||
def width(self):
|
||||
return self._width
|
||||
|
||||
@property
|
||||
def height(self):
|
||||
return self._height
|
||||
|
||||
@property
|
||||
def start(self):
|
||||
return self._start_cell
|
||||
|
||||
@property
|
||||
def exit(self):
|
||||
return self._exit_cell
|
||||
|
||||
def cell_at(self, x, y):
|
||||
if 0 <= x < self._width and 0 <= y < self._height:
|
||||
return self._cells[y][x]
|
||||
return None
|
||||
|
||||
def configure_cell(self, x, y, cell_type):
|
||||
cell = self.cell_at(x, y)
|
||||
if cell is None:
|
||||
return
|
||||
|
||||
if cell_type == 'wall':
|
||||
cell.is_wall = True
|
||||
elif cell_type == 'start':
|
||||
if self._start_cell:
|
||||
self._start_cell.is_start = False
|
||||
cell.is_start = True
|
||||
cell.is_wall = False
|
||||
self._start_cell = cell
|
||||
elif cell_type == 'exit':
|
||||
if self._exit_cell:
|
||||
self._exit_cell.is_exit = False
|
||||
cell.is_exit = True
|
||||
cell.is_wall = False
|
||||
self._exit_cell = cell
|
||||
elif cell_type == 'path':
|
||||
cell.is_wall = False
|
||||
|
||||
def adjacent_cells(self, cell):
|
||||
neighbours = []
|
||||
directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]
|
||||
for dx, dy in directions:
|
||||
nx, ny = cell.x + dx, cell.y + dy
|
||||
neighbour = self.cell_at(nx, ny)
|
||||
if neighbour and neighbour.passable():
|
||||
neighbours.append(neighbour)
|
||||
return neighbours
|
||||
|
||||
|
||||
# ----------------------------- Загрузка лабиринта -----------------------------
|
||||
class LabyrinthBuilder:
|
||||
def build_from_file(self, filename):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class TxtLabyrinthBuilder(LabyrinthBuilder):
|
||||
def build_from_file(self, filename):
|
||||
with open(filename, 'r') as f:
|
||||
lines = [line.rstrip('\n') for line in f.readlines()]
|
||||
height = len(lines)
|
||||
width = max(len(line) for line in lines) if height > 0 else 0
|
||||
start_cnt = 0
|
||||
exit_cnt = 0
|
||||
lab = Labyrinth(width, height)
|
||||
|
||||
for y, line in enumerate(lines):
|
||||
for x, ch in enumerate(line):
|
||||
if ch == "#":
|
||||
lab.configure_cell(x, y, "wall")
|
||||
elif ch == "S":
|
||||
lab.configure_cell(x, y, "start")
|
||||
start_cnt += 1
|
||||
elif ch == "E":
|
||||
lab.configure_cell(x, y, "exit")
|
||||
exit_cnt += 1
|
||||
else:
|
||||
lab.configure_cell(x, y, 'path')
|
||||
if start_cnt != 1 or exit_cnt != 1:
|
||||
raise ValueError(f"Maze must have exactly one S and one E. Found S={start_cnt}, E={exit_cnt}")
|
||||
return lab
|
||||
|
||||
|
||||
# ----------------------------- Алгоритмы поиска -----------------------------
|
||||
class SearchAlgorithm:
|
||||
def compute_path(self, maze, start, goal):
|
||||
raise NotImplementedError
|
||||
|
||||
def _build_path(self, came_from, start, goal):
|
||||
path = []
|
||||
cur = goal
|
||||
while cur is not None:
|
||||
path.append(cur)
|
||||
cur = came_from.get(cur)
|
||||
path.reverse()
|
||||
return path
|
||||
|
||||
def visited_nodes(self):
|
||||
return getattr(self, '_visited', 0)
|
||||
|
||||
|
||||
class BFS(SearchAlgorithm):
|
||||
def compute_path(self, maze, start, goal):
|
||||
q = deque()
|
||||
q.append(start)
|
||||
came_from = {start: None}
|
||||
visited = {start}
|
||||
|
||||
while q:
|
||||
cur = q.popleft()
|
||||
if cur == goal:
|
||||
self._visited = len(visited)
|
||||
return self._build_path(came_from, start, goal)
|
||||
for nb in maze.adjacent_cells(cur):
|
||||
if nb not in visited:
|
||||
visited.add(nb)
|
||||
came_from[nb] = cur
|
||||
q.append(nb)
|
||||
self._visited = len(visited)
|
||||
return []
|
||||
|
||||
|
||||
class DFS(SearchAlgorithm):
|
||||
def compute_path(self, maze, start, goal):
|
||||
stack = [start]
|
||||
came_from = {start: None}
|
||||
visited = {start}
|
||||
|
||||
while stack:
|
||||
cur = stack.pop()
|
||||
if cur == goal:
|
||||
self._visited = len(visited)
|
||||
return self._build_path(came_from, start, goal)
|
||||
for nb in maze.adjacent_cells(cur):
|
||||
if nb not in visited:
|
||||
visited.add(nb)
|
||||
came_from[nb] = cur
|
||||
stack.append(nb)
|
||||
self._visited = len(visited)
|
||||
return []
|
||||
|
||||
|
||||
class AStar(SearchAlgorithm):
|
||||
def _heuristic(self, cell, goal):
|
||||
return abs(cell.x - goal.x) + abs(cell.y - goal.y)
|
||||
|
||||
def compute_path(self, maze, start, goal):
|
||||
heap = []
|
||||
counter = 0
|
||||
start_f = self._heuristic(start, goal)
|
||||
heapq.heappush(heap, (start_f, counter, start))
|
||||
counter += 1
|
||||
|
||||
came_from = {}
|
||||
g_score = {start: 0}
|
||||
f_score = {start: start_f}
|
||||
visited = set()
|
||||
|
||||
while heap:
|
||||
cur_f, _, cur = heapq.heappop(heap)
|
||||
visited.add(cur)
|
||||
|
||||
if cur == goal:
|
||||
self._visited = len(visited)
|
||||
return self._build_path(came_from, start, goal)
|
||||
if cur_f > f_score.get(cur, float('inf')):
|
||||
continue
|
||||
for nb in maze.adjacent_cells(cur):
|
||||
tentative_g = g_score[cur] + 1
|
||||
if tentative_g < g_score.get(nb, float('inf')):
|
||||
came_from[nb] = cur
|
||||
g_score[nb] = tentative_g
|
||||
new_f = tentative_g + self._heuristic(nb, goal)
|
||||
f_score[nb] = new_f
|
||||
heapq.heappush(heap, (new_f, counter, nb))
|
||||
counter += 1
|
||||
self._visited = len(visited)
|
||||
return []
|
||||
|
||||
|
||||
# ----------------------------- Оркестратор -----------------------------
|
||||
class Pathfinder:
|
||||
def __init__(self, maze):
|
||||
self._maze = maze
|
||||
self._algorithm = None
|
||||
self._listeners = []
|
||||
|
||||
def attach(self, listener):
|
||||
self._listeners.append(listener)
|
||||
|
||||
def notify(self, event, data):
|
||||
for lst in self._listeners:
|
||||
lst.update(event, data)
|
||||
|
||||
def set_algorithm(self, algorithm):
|
||||
self._algorithm = algorithm
|
||||
|
||||
def solve(self):
|
||||
if self._algorithm is None:
|
||||
return None
|
||||
t0 = time.perf_counter()
|
||||
path = self._algorithm.compute_path(self._maze, self._maze.start, self._maze.exit)
|
||||
t1 = time.perf_counter()
|
||||
elapsed_ms = (t1 - t0) * 1000
|
||||
|
||||
self.notify("path_found", path)
|
||||
|
||||
return PerformanceData(elapsed_ms, self._algorithm.visited_nodes(), len(path))
|
||||
|
||||
|
||||
class PerformanceData:
|
||||
def __init__(self, time_ms, visited, length):
|
||||
self.time_ms = time_ms
|
||||
self.visited_cells = visited
|
||||
self.path_length = length
|
||||
|
||||
|
||||
# ----------------------------- Наблюдатель и отображение -----------------------------
|
||||
class EventListener:
|
||||
def update(self, event_type, data):
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class ConsoleDisplay(EventListener):
|
||||
def __init__(self):
|
||||
self._last_path = None
|
||||
|
||||
def update(self, event_type, data):
|
||||
if event_type == "maze_loaded":
|
||||
self._render_maze(data)
|
||||
elif event_type == "path_found":
|
||||
self._last_path = data
|
||||
self._render_path(data)
|
||||
|
||||
def _render_maze(self, maze):
|
||||
os.system('cls' if os.name == 'nt' else 'clear')
|
||||
print("=" * (maze.width * 2 + 4))
|
||||
print(" LABYRINTH")
|
||||
print("=" * (maze.width * 2 + 4))
|
||||
|
||||
for y in range(maze.height):
|
||||
print(" ", end='')
|
||||
for x in range(maze.width):
|
||||
cell = maze.cell_at(x, y)
|
||||
if cell == maze.start:
|
||||
print('S', end=' ')
|
||||
elif cell == maze.exit:
|
||||
print('E', end=' ')
|
||||
elif cell.is_wall:
|
||||
print('#', end=' ')
|
||||
else:
|
||||
print('.', end=' ')
|
||||
print()
|
||||
print("=" * (maze.width * 2 + 4))
|
||||
print(" S - start E - exit # - wall . - path")
|
||||
|
||||
def _render_path(self, path):
|
||||
if not path:
|
||||
print("\n Path not found!")
|
||||
return
|
||||
print(f"\n Path found! Length: {len(path)}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
builder = TxtLabyrinthBuilder()
|
||||
maze = builder.build_from_file("maze/level1.txt")
|
||||
|
||||
view = ConsoleDisplay()
|
||||
view.update("maze_loaded", maze)
|
||||
|
||||
pf = Pathfinder(maze)
|
||||
pf.attach(view)
|
||||
|
||||
for algo, name in [(BFS(), "BFS"), (DFS(), "DFS"), (AStar(), "A*")]:
|
||||
pf.set_algorithm(algo)
|
||||
stats = pf.solve()
|
||||
print(f"{name}: {stats.time_ms:.3f}ms, visited={stats.visited_cells}, length={stats.path_length}")
|
||||
88
src/bst.py
88
src/bst.py
|
|
@ -1,88 +0,0 @@
|
|||
# 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
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
# 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
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
# 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
|
||||
|
|
@ -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Готово. Замеры можно проводить после реализации структур.")
|
||||
Loading…
Reference in New Issue
Block a user