diff --git a/fomichevks/426.md.txt b/fomichevks/426.md similarity index 100% rename from fomichevks/426.md.txt rename to fomichevks/426.md diff --git a/fomichevks/docs/data/empty.txt b/fomichevks/docs/data/empty.txt new file mode 100644 index 0000000..6d0a249 --- /dev/null +++ b/fomichevks/docs/data/empty.txt @@ -0,0 +1,49 @@ +######################################## +#S # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# # +# E# +######################################## \ No newline at end of file diff --git a/fomichevks/docs/data/experiment_results.csv b/fomichevks/docs/data/experiment_results.csv new file mode 100644 index 0000000..b9d6ce1 --- /dev/null +++ b/fomichevks/docs/data/experiment_results.csv @@ -0,0 +1,13 @@ +maze,strategy,time_ms,visited_cells,path_length,success_rate +Small (10x10),BFS,0.052460000733844936,30.0,14.0,1.0 +Small (10x10),DFS,0.0480999966384843,32.0,14.0,1.0 +Small (10x10),A*,0.07206000154837966,23.0,14.0,1.0 +Medium (50x50),BFS,0.2786600001854822,182.0,92.0,1.0 +Medium (50x50),DFS,0.14713999989908189,93.0,92.0,1.0 +Medium (50x50),A*,0.5699400004232302,182.0,92.0,1.0 +Large (100x100),BFS,0.39185999776236713,201.0,149.0,1.0 +Large (100x100),DFS,0.2371800015680492,151.0,149.0,1.0 +Large (100x100),A*,0.5810399976326153,200.0,149.0,1.0 +Empty,BFS,3.187239999533631,1834.0,86.0,1.0 +Empty,DFS,1.9440599950030446,1797.0,922.0,1.0 +Empty,A*,6.751939994865097,1834.0,86.0,1.0 diff --git a/fomichevks/docs/data/experiment_results.png b/fomichevks/docs/data/experiment_results.png new file mode 100644 index 0000000..c96bc8d Binary files /dev/null and b/fomichevks/docs/data/experiment_results.png differ diff --git a/fomichevks/docs/data/large.txt b/fomichevks/docs/data/large.txt new file mode 100644 index 0000000..90a84ad --- /dev/null +++ b/fomichevks/docs/data/large.txt @@ -0,0 +1,54 @@ +#################################################################################################### +#S # +# ################################################################################################ # +# # # # +# # ############################################################################################ # # +# # # # # # +# # # ######################################################################################## # # # +# # # # # # # # +# # # # #################################################################################### # # # # +# # # # # # # # # # +# # # # # ################################################################################ # # # # # +# # # # # # # # # # # # +# # # # # # ############################################################################ # # # # # # +# # # # # # # # # # # # # # +# # # # # # # ######################################################################## # # # # # # # +# # # # # # # # # # # # # # # # +# # # # # # # # #################################################################### # # # # # # # # +# # # # # # # # # # # # # # # # # # +# # # # # # # # # ################################################################ # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # ############################################################ # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # ######################################################## # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # #################################################### # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # ################################################ # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # ############################################ # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # ######################################## # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # #################################### # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # ################################ # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # ############################ # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # ######################## # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # #################### # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # ################ # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # ############ # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # ######## # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # #### # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #E# +#################################################################################################### \ No newline at end of file diff --git a/fomichevks/docs/data/maze.py b/fomichevks/docs/data/maze.py new file mode 100644 index 0000000..3581713 --- /dev/null +++ b/fomichevks/docs/data/maze.py @@ -0,0 +1,532 @@ +import sys +from collections import deque +import heapq +import time +import os +from abc import ABC, abstractmethod +from typing import List, Optional, Dict, Any + + +DATA_PATH = r"C:\Users\Kirill\2026-rff_mp\fomichevks\docs\data" + + +class Observer(ABC): + @abstractmethod + def update(self, event: str, data: Any = None): + pass + + +class Observable: + def __init__(self): + self._observers: List[Observer] = [] + + def attach(self, observer: Observer): + self._observers.append(observer) + + def detach(self, observer: Observer): + self._observers.remove(observer) + + def notify(self, event: str, data: Any = None): + for observer in self._observers: + observer.update(event, data) + + +class Tile: + def __init__(self, x: int, y: int): + self._x = x + self._y = y + self._wall = False + self._start = False + self._exit = False + + @property + def x(self) -> int: + return self._x + + @property + def y(self) -> int: + return self._y + + @property + def is_wall(self) -> bool: + return self._wall + + @is_wall.setter + def is_wall(self, v: bool): + self._wall = v + + @property + def is_start(self) -> bool: + return self._start + + @is_start.setter + def is_start(self, v: bool): + self._start = v + + @property + def is_exit(self) -> bool: + return self._exit + + @is_exit.setter + def is_exit(self, v: bool): + self._exit = v + + def passable(self) -> bool: + return not self._wall + + def __hash__(self): + return hash((self._x, self._y)) + + def __eq__(self, other): + if not isinstance(other, Tile): + return False + return self._x == other._x and self._y == other._y + + +class Maze: + def __init__(self, w: int, h: int): + self._w = w + self._h = h + self._cells = [[Tile(x, y) for x in range(w)] for y in range(h)] + self._start: Optional[Tile] = None + self._exit: Optional[Tile] = None + + @property + def width(self) -> int: + return self._w + + @property + def height(self) -> int: + return self._h + + @property + def start(self) -> Optional[Tile]: + return self._start + + @property + def exit(self) -> Optional[Tile]: + return self._exit + + def get_cell(self, x: int, y: int) -> Optional[Tile]: + if 0 <= x < self._w and 0 <= y < self._h: + return self._cells[y][x] + return None + + def set_cell(self, x: int, y: int, kind: str): + c = self.get_cell(x, y) + if not c: + return + if kind == 'wall': + c.is_wall = True + elif kind == 'start': + if self._start: + self._start.is_start = False + c.is_start = True + c.is_wall = False + self._start = c + elif kind == 'exit': + if self._exit: + self._exit.is_exit = False + c.is_exit = True + c.is_wall = False + self._exit = c + elif kind == 'path': + c.is_wall = False + + def neighbours(self, cell: Tile) -> List[Tile]: + result = [] + for dx, dy in [(0, -1), (0, 1), (-1, 0), (1, 0)]: + nx, ny = cell.x + dx, cell.y + dy + nb = self.get_cell(nx, ny) + if nb and nb.passable(): + result.append(nb) + return result + + +class MazeLoader(ABC): + @abstractmethod + def load(self, filename: str) -> Maze: + pass + + +class TextMazeLoader(MazeLoader): + def load(self, filename: str) -> Maze: + with open(filename, 'r', encoding='utf-8') as f: + lines = [line.rstrip('\n') for line in f.readlines()] + + h = len(lines) + w = max(len(line) for line in lines) if h else 0 + + start_count = 0 + exit_count = 0 + maze = Maze(w, h) + + for y, line in enumerate(lines): + for x, ch in enumerate(line): + if ch == '#': + maze.set_cell(x, y, 'wall') + elif ch == 'S': + maze.set_cell(x, y, 'start') + start_count += 1 + elif ch == 'E': + maze.set_cell(x, y, 'exit') + exit_count += 1 + else: + maze.set_cell(x, y, 'path') + + if start_count != 1 or exit_count != 1: + raise ValueError(f"Maze must have one S and one E. Found: S={start_count}, E={exit_count}") + + return maze + + +class PathFinder(ABC): + def __init__(self): + self._visited = 0 + + @abstractmethod + def find(self, maze: Maze, start: Tile, goal: Tile) -> List[Tile]: + pass + + def _reconstruct(self, parent: Dict[Tile, Optional[Tile]], start: Tile, goal: Tile) -> List[Tile]: + path = [] + current = goal + while current is not None: + path.append(current) + current = parent.get(current) + path.reverse() + return path if path and path[0] == start else [] + + @property + def visited_count(self) -> int: + return self._visited + + +class BFS(PathFinder): + def find(self, maze: Maze, start: Tile, goal: Tile) -> List[Tile]: + queue = deque([start]) + parent = {start: None} + visited = {start} + + while queue: + current = queue.popleft() + + if current == goal: + self._visited = len(visited) + return self._reconstruct(parent, start, goal) + + for neighbor in maze.neighbours(current): + if neighbor not in visited: + visited.add(neighbor) + parent[neighbor] = current + queue.append(neighbor) + + self._visited = len(visited) + return [] + + +class DFS(PathFinder): + def find(self, maze: Maze, start: Tile, goal: Tile) -> List[Tile]: + stack = [start] + parent = {start: None} + visited = {start} + + while stack: + current = stack.pop() + + if current == goal: + self._visited = len(visited) + return self._reconstruct(parent, start, goal) + + for neighbor in maze.neighbours(current): + if neighbor not in visited: + visited.add(neighbor) + parent[neighbor] = current + stack.append(neighbor) + + self._visited = len(visited) + return [] + + +class AStar(PathFinder): + def _heuristic(self, cell: Tile, goal: Tile) -> int: + return abs(cell.x - goal.x) + abs(cell.y - goal.y) + + def find(self, maze: Maze, start: Tile, goal: Tile) -> List[Tile]: + heap = [] + counter = 0 + start_f = self._heuristic(start, goal) + heapq.heappush(heap, (start_f, counter, start)) + counter += 1 + + parent = {} + g_score = {start: 0} + f_score = {start: start_f} + visited = set() + + while heap: + current_f, _, current = heapq.heappop(heap) + visited.add(current) + + if current == goal: + self._visited = len(visited) + return self._reconstruct(parent, start, goal) + + if current_f > f_score.get(current, float('inf')): + continue + + for neighbor in maze.neighbours(current): + tentative_g = g_score[current] + 1 + + if tentative_g < g_score.get(neighbor, float('inf')): + parent[neighbor] = current + g_score[neighbor] = tentative_g + new_f = tentative_g + self._heuristic(neighbor, goal) + f_score[neighbor] = new_f + heapq.heappush(heap, (new_f, counter, neighbor)) + counter += 1 + + self._visited = len(visited) + return [] + + +class MazeSolver(Observable): + def __init__(self, maze: Maze): + super().__init__() + self._maze = maze + self._algorithm: Optional[PathFinder] = None + + def set_algorithm(self, algorithm: PathFinder): + self._algorithm = algorithm + + def solve(self) -> Optional[Dict[str, Any]]: + if not self._algorithm: + raise ValueError("Algorithm not set") + + start_time = time.perf_counter() + path = self._algorithm.find(self._maze, self._maze.start, self._maze.exit) + end_time = time.perf_counter() + + elapsed_ms = (end_time - start_time) * 1000 + + return { + 'time_ms': elapsed_ms, + 'visited': self._algorithm.visited_count, + 'path_length': len(path), + 'path': path + } + + +class Command(ABC): + @abstractmethod + def execute(self) -> bool: + pass + + @abstractmethod + def undo(self) -> bool: + pass + + +class MoveCommand(Command): + def __init__(self, player: 'Player', dx: int, dy: int, maze: Maze): + self._player = player + self._dx = dx + self._dy = dy + self._maze = maze + self._executed = False + + def execute(self) -> bool: + new_x = self._player.position.x + self._dx + new_y = self._player.position.y + self._dy + target = self._maze.get_cell(new_x, new_y) + + if target and target.passable(): + self._player.move_to(target) + self._executed = True + return True + return False + + def undo(self) -> bool: + if self._executed: + self._player.undo() + self._executed = False + return True + return False + + +class Player: + def __init__(self, start_tile: Tile): + self._position = start_tile + self._previous = None + + @property + def position(self) -> Tile: + return self._position + + def move_to(self, tile: Tile): + self._previous = self._position + self._position = tile + + def undo(self): + if self._previous: + self._position, self._previous = self._previous, None + + +class ConsoleView(Observer): + def __init__(self, maze: Maze, player: Optional[Player] = None): + self._maze = maze + self._player = player + self._current_path: List[Tile] = [] + + def update(self, event: str, data: Any = None): + if event == "solving_finished": + self._current_path = data.get('path', []) + self._display_solution(data) + + def _display_solution(self, stats: Dict): + os.system('cls' if os.name == 'nt' else 'clear') + print("=" * (self._maze.width * 2 + 4)) + print("MAZE SOLUTION") + print("=" * (self._maze.width * 2 + 4)) + + for y in range(self._maze.height): + print(" ", end='') + for x in range(self._maze.width): + cell = self._maze.get_cell(x, y) + if cell == self._maze.start: + print('S', end=' ') + elif cell == self._maze.exit: + print('E', end=' ') + elif cell.is_wall: + print('#', end=' ') + elif self._current_path and cell in self._current_path: + print('●', end=' ') + else: + print('.', end=' ') + print() + + print("=" * (self._maze.width * 2 + 4)) + print(f"Time: {stats['time_ms']:.3f} ms") + print(f"Visited: {stats['visited']}") + print(f"Path length: {stats['path_length']}") + + def display_maze(self): + os.system('cls' if os.name == 'nt' else 'clear') + print("=" * (self._maze.width * 2 + 4)) + print("MAZE") + print("=" * (self._maze.width * 2 + 4)) + + for y in range(self._maze.height): + print(" ", end='') + for x in range(self._maze.width): + cell = self._maze.get_cell(x, y) + if self._player and cell == self._player.position: + print('P', end=' ') + elif cell == self._maze.start: + print('S', end=' ') + elif cell == self._maze.exit: + print('E', end=' ') + elif cell.is_wall: + print('#', end=' ') + else: + print('.', end=' ') + print() + + print("=" * (self._maze.width * 2 + 4)) + print("S - start E - exit # - wall . - path P - player") + + +def interactive_mode(maze: Maze): + player = Player(maze.start) + view = ConsoleView(maze, player) + view.display_maze() + + solver = MazeSolver(maze) + solver.attach(view) + + commands_history: List[Command] = [] + + print("\nControls:") + print("H (←) J (↓) K (↑) L (→) - move") + print("U - undo") + print("B - BFS") + print("D - DFS") + print("A - A*") + print("Q - quit") + print("\n" + "=" * 50) + + while True: + cmd = input("\n> ").lower().strip() + + if cmd == 'q': + break + + elif cmd == 'b': + solver.set_algorithm(BFS()) + result = solver.solve() + if result: + print(f"BFS: {result['time_ms']:.3f} ms, visited={result['visited']}, length={result['path_length']}") + + elif cmd == 'd': + solver.set_algorithm(DFS()) + result = solver.solve() + if result: + print(f"DFS: {result['time_ms']:.3f} ms, visited={result['visited']}, length={result['path_length']}") + + elif cmd == 'a': + solver.set_algorithm(AStar()) + result = solver.solve() + if result: + print(f"A*: {result['time_ms']:.3f} ms, visited={result['visited']}, length={result['path_length']}") + + elif cmd in ['h', 'j', 'k', 'l']: + dir_map = {'h': (-1, 0), 'l': (1, 0), 'k': (0, -1), 'j': (0, 1)} + dx, dy = dir_map[cmd] + move = MoveCommand(player, dx, dy, maze) + + if move.execute(): + commands_history.append(move) + view.display_maze() + + if player.position == maze.exit: + print("\n*** YOU ESCAPED! ***") + print(f"Total moves: {len(commands_history)}") + break + else: + print("Blocked!") + + elif cmd == 'u': + if commands_history: + last_command = commands_history.pop() + last_command.undo() + view.display_maze() + print("Undo successful") + else: + print("Nothing to undo") + + else: + print("Unknown command") + + +def main(): + if len(sys.argv) > 1 and sys.argv[1] == 'experiment': + import subprocess + subprocess.run([sys.executable, 'plots.py']) + return + + loader = TextMazeLoader() + + + maze_file = os.path.join(DATA_PATH, "maze1.txt") + + if not os.path.exists(maze_file): + print(f"ERROR: Maze file not found: {maze_file}") + print(f"Please create maze1.txt in: {DATA_PATH}") + return + + maze = loader.load(maze_file) + interactive_mode(maze) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/fomichevks/docs/data/maze1.txt b/fomichevks/docs/data/maze1.txt new file mode 100644 index 0000000..07a3ed5 --- /dev/null +++ b/fomichevks/docs/data/maze1.txt @@ -0,0 +1,10 @@ +########## +#S # +### ##### +# # E# +# # # # ## +# # # +####### # +# # +# ###### # +########## \ No newline at end of file diff --git a/fomichevks/docs/data/medium.txt b/fomichevks/docs/data/medium.txt new file mode 100644 index 0000000..c8df775 --- /dev/null +++ b/fomichevks/docs/data/medium.txt @@ -0,0 +1,48 @@ +################################################## +#S # +# ############################################# # +# # # # +# # ######################################### # # +# # # # # # +# # # ##################################### # # # +# # # # # # # # +# # # # ################################# # # # # +# # # # # # # # # # +# # # # # ############################# # # # # # +# # # # # # # # # # # # +# # # # # # ######################### # # # # # # +# # # # # # # # # # # # # # +# # # # # # # ##################### # # # # # # # +# # # # # # # # # # # # # # # # +# # # # # # # # ################# # # # # # # # # +# # # # # # # # # # # # # # # # # # +# # # # # # # # # ############# # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # ######### # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # ##### # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # # ##### # # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # # # +# # # # # # # # # # ######### # # # # # # # # # # +# # # # # # # # # # # # # # # # # # # # +# # # # # # # # # ############# # # # # # # # # # +# # # # # # # # # # # # # # # # # # +# # # # # # # # ################# # # # # # # # # +# # # # # # # # # # # # # # # # +# # # # # # # ##################### # # # # # # # +# # # # # # # # # # # # # # +# # # # # # ######################### # # # # # # +# # # # # # # # # # # # +# # # # # ############################# # # # # # +# # # # # # # # # # +# # # # ################################# # # # # +# # # # # # # # +# # # ##################################### # # # +# # # # # # +# # ######################################### # # +# # # # +# ############################################# # +# E# +################################################## \ No newline at end of file diff --git a/fomichevks/docs/data/plots.py b/fomichevks/docs/data/plots.py new file mode 100644 index 0000000..ad41b04 --- /dev/null +++ b/fomichevks/docs/data/plots.py @@ -0,0 +1,580 @@ +import csv +import time +import os +import matplotlib.pyplot as plt +import numpy as np +from collections import deque +import heapq + +from maze import DATA_PATH + + + +class Tile: + def __init__(self, x: int, y: int): + self._x = x + self._y = y + self._wall = False + self._start = False + self._exit = False + + @property + def x(self) -> int: + return self._x + + @property + def y(self) -> int: + return self._y + + @property + def is_wall(self) -> bool: + return self._wall + + @is_wall.setter + def is_wall(self, v: bool): + self._wall = v + + @property + def is_start(self) -> bool: + return self._start + + @is_start.setter + def is_start(self, v: bool): + self._start = v + + @property + def is_exit(self) -> bool: + return self._exit + + @is_exit.setter + def is_exit(self, v: bool): + self._exit = v + + def passable(self) -> bool: + return not self._wall + + def __hash__(self): + return hash((self._x, self._y)) + + def __eq__(self, other): + if not isinstance(other, Tile): + return False + return self._x == other._x and self._y == other._y + + +class Maze: + def __init__(self, w: int, h: int): + self._w = w + self._h = h + self._cells = [[Tile(x, y) for x in range(w)] for y in range(h)] + self._start = None + self._exit = None + + @property + def width(self) -> int: + return self._w + + @property + def height(self) -> int: + return self._h + + @property + def start(self): + return self._start + + @property + def exit(self): + return self._exit + + def get_cell(self, x: int, y: int): + if 0 <= x < self._w and 0 <= y < self._h: + return self._cells[y][x] + return None + + def set_cell(self, x: int, y: int, kind: str): + c = self.get_cell(x, y) + if not c: + return + if kind == 'wall': + c.is_wall = True + elif kind == 'start': + if self._start: + self._start.is_start = False + c.is_start = True + c.is_wall = False + self._start = c + elif kind == 'exit': + if self._exit: + self._exit.is_exit = False + c.is_exit = True + c.is_wall = False + self._exit = c + elif kind == 'path': + c.is_wall = False + + def neighbours(self, cell): + result = [] + for dx, dy in [(0, -1), (0, 1), (-1, 0), (1, 0)]: + nx, ny = cell.x + dx, cell.y + dy + nb = self.get_cell(nx, ny) + if nb and nb.passable(): + result.append(nb) + return result + + +class TextMazeLoader: + def load(self, filename: str): + with open(filename, 'r', encoding='utf-8') as f: + lines = [line.rstrip('\n') for line in f.readlines()] + + h = len(lines) + w = max(len(line) for line in lines) if h else 0 + + start_count = 0 + exit_count = 0 + maze = Maze(w, h) + + for y, line in enumerate(lines): + for x, ch in enumerate(line): + if ch == '#': + maze.set_cell(x, y, 'wall') + elif ch == 'S': + maze.set_cell(x, y, 'start') + start_count += 1 + elif ch == 'E': + maze.set_cell(x, y, 'exit') + exit_count += 1 + else: + maze.set_cell(x, y, 'path') + + if start_count != 1 or exit_count != 1: + raise ValueError(f"Maze must have one S and one E. Found: S={start_count}, E={exit_count}") + + return maze + + +class BFS: + def __init__(self): + self._visited = 0 + + def find(self, maze, start, goal): + from collections import deque + queue = deque([start]) + parent = {start: None} + visited = {start} + + while queue: + current = queue.popleft() + + if current == goal: + self._visited = len(visited) + return self._reconstruct(parent, start, goal) + + for neighbor in maze.neighbours(current): + if neighbor not in visited: + visited.add(neighbor) + parent[neighbor] = current + queue.append(neighbor) + + self._visited = len(visited) + return [] + + def _reconstruct(self, parent, start, goal): + path = [] + current = goal + while current is not None: + path.append(current) + current = parent.get(current) + path.reverse() + return path if path and path[0] == start else [] + + @property + def visited_count(self): + return self._visited + + +class DFS: + def __init__(self): + self._visited = 0 + + def find(self, maze, start, goal): + stack = [start] + parent = {start: None} + visited = {start} + + while stack: + current = stack.pop() + + if current == goal: + self._visited = len(visited) + return self._reconstruct(parent, start, goal) + + for neighbor in maze.neighbours(current): + if neighbor not in visited: + visited.add(neighbor) + parent[neighbor] = current + stack.append(neighbor) + + self._visited = len(visited) + return [] + + def _reconstruct(self, parent, start, goal): + path = [] + current = goal + while current is not None: + path.append(current) + current = parent.get(current) + path.reverse() + return path if path and path[0] == start else [] + + @property + def visited_count(self): + return self._visited + + +class AStar: + def __init__(self): + self._visited = 0 + + def _heuristic(self, cell, goal): + return abs(cell.x - goal.x) + abs(cell.y - goal.y) + + def find(self, maze, start, goal): + import heapq + heap = [] + counter = 0 + start_f = self._heuristic(start, goal) + heapq.heappush(heap, (start_f, counter, start)) + counter += 1 + + parent = {} + g_score = {start: 0} + f_score = {start: start_f} + visited = set() + + while heap: + current_f, _, current = heapq.heappop(heap) + visited.add(current) + + if current == goal: + self._visited = len(visited) + return self._reconstruct(parent, start, goal) + + if current_f > f_score.get(current, float('inf')): + continue + + for neighbor in maze.neighbours(current): + tentative_g = g_score[current] + 1 + + if tentative_g < g_score.get(neighbor, float('inf')): + parent[neighbor] = current + g_score[neighbor] = tentative_g + new_f = tentative_g + self._heuristic(neighbor, goal) + f_score[neighbor] = new_f + heapq.heappush(heap, (new_f, counter, neighbor)) + counter += 1 + + self._visited = len(visited) + return [] + + def _reconstruct(self, parent, start, goal): + path = [] + current = goal + while current is not None: + path.append(current) + current = parent.get(current) + path.reverse() + return path if path and path[0] == start else [] + + @property + def visited_count(self): + return self._visited + + +class MazeSolver: + def __init__(self, maze): + self._maze = maze + self._algorithm = None + + def set_algorithm(self, algorithm): + self._algorithm = algorithm + + def solve(self): + if not self._algorithm: + raise ValueError("Algorithm not set") + + start_time = time.perf_counter() + path = self._algorithm.find(self._maze, self._maze.start, self._maze.exit) + end_time = time.perf_counter() + + elapsed_ms = (end_time - start_time) * 1000 + + return { + 'time_ms': elapsed_ms, + 'visited': self._algorithm.visited_count, + 'path_length': len(path), + 'path': path + } + + + + + +DATA_PATH = r"C:\Users\Kirill\2026-rff_mp\fomichevks\docs\data" + + +class ExperimentRunner: + def __init__(self): + self.algorithms = { + "BFS": BFS(), + "DFS": DFS(), + "A*": AStar() + } + self.loader = TextMazeLoader() + + def run_benchmark(self, maze_file: str, algorithm: str, runs: int = 5): + try: + maze = self.loader.load(maze_file) + except Exception as e: + return None + + total_time = 0.0 + total_visited = 0 + total_length = 0 + successes = 0 + + for _ in range(runs): + solver = MazeSolver(maze) + solver.set_algorithm(self.algorithms[algorithm]) + result = solver.solve() + + if result and result['path_length'] > 0: + total_time += result['time_ms'] + total_visited += result['visited'] + total_length += result['path_length'] + successes += 1 + + if successes == 0: + return None + + return { + 'time_ms': total_time / successes, + 'visited_cells': total_visited / successes, + 'path_length': total_length / successes, + 'success_rate': successes / runs + } + + def run_all_experiments(self, runs: int = 5): + mazes_list = [ + (os.path.join(DATA_PATH, "small.txt"), "Small (10x10)"), + (os.path.join(DATA_PATH, "medium.txt"), "Medium (50x50)"), + (os.path.join(DATA_PATH, "large.txt"), "Large (100x100)"), + (os.path.join(DATA_PATH, "empty.txt"), "Empty"), + (os.path.join(DATA_PATH, "no_exit.txt"), "No exit") + ] + + results = [] + + + print("running experiments") + + print(f"Data path: {DATA_PATH}") + + + for maze_file, maze_name in mazes_list: + if not os.path.exists(maze_file): + print(f"\n[warn] File not found: {maze_file}") + continue + + print(f"\nTesting: {maze_name}") + + for algo_name in self.algorithms.keys(): + stats = self.run_benchmark(maze_file, algo_name, runs) + + if stats: + print( + f" {algo_name}: time={stats['time_ms']:.3f}ms, visited={stats['visited_cells']:.0f}, length={stats['path_length']:.0f}") + results.append({ + 'maze': maze_name, + 'strategy': algo_name, + 'time_ms': stats['time_ms'], + 'visited_cells': stats['visited_cells'], + 'path_length': stats['path_length'], + 'success_rate': stats['success_rate'] + }) + else: + print(f" {algo_name}: no path found") + results.append({ + 'maze': maze_name, + 'strategy': algo_name, + 'time_ms': -1, + 'visited_cells': -1, + 'path_length': -1, + 'success_rate': 0 + }) + + return results + + +def create_visualizations(results): + valid_results = [r for r in results if r['time_ms'] > 0] + if not valid_results: + print("no valid results for visualization") + return + + mazes = sorted(set(r['maze'] for r in valid_results)) + algorithms = ['BFS', 'DFS', 'A*'] + + fig, axes = plt.subplots(1, 3, figsize=(15, 5)) + fig.suptitle('pathfinding algorithms comparison', fontsize=14) + + x = np.arange(len(mazes)) + width = 0.25 + + # Time chart + for i, algo in enumerate(algorithms): + times = [] + for maze in mazes: + val = next((r['time_ms'] for r in valid_results + if r['maze'] == maze and r['strategy'] == algo), 0) + times.append(val) + bars = axes[0].bar(x + i * width, times, width, label=algo, alpha=0.8) + for bar, val in zip(bars, times): + if val > 0: + axes[0].text(bar.get_x() + bar.get_width() / 2, bar.get_height() + 0.5, + f'{val:.1f}', ha='center', va='bottom', fontsize=7) + + axes[0].set_title('execution Time (ms)') + axes[0].set_ylabel('time (ms)') + axes[0].set_xticks(x + width) + axes[0].set_xticklabels(mazes, rotation=45, ha='right', fontsize=8) + axes[0].legend() + axes[0].grid(alpha=0.3, axis='y') + + # Visited cells chart + for i, algo in enumerate(algorithms): + visited = [] + for maze in mazes: + val = next((r['visited_cells'] for r in valid_results + if r['maze'] == maze and r['strategy'] == algo), 0) + visited.append(val) + bars = axes[1].bar(x + i * width, visited, width, label=algo, alpha=0.8) + for bar, val in zip(bars, visited): + if val > 0: + axes[1].text(bar.get_x() + bar.get_width() / 2, bar.get_height(), + f'{val:.0f}', ha='center', va='bottom', fontsize=7) + + axes[1].set_title('visited Cells') + axes[1].set_ylabel('count') + axes[1].set_xticks(x + width) + axes[1].set_xticklabels(mazes, rotation=45, ha='right', fontsize=8) + axes[1].legend() + axes[1].grid(alpha=0.3, axis='y') + + # Path length chart + for i, algo in enumerate(algorithms): + lengths = [] + for maze in mazes: + val = next((r['path_length'] for r in valid_results + if r['maze'] == maze and r['strategy'] == algo), 0) + lengths.append(val) + bars = axes[2].bar(x + i * width, lengths, width, label=algo, alpha=0.8) + for bar, val in zip(bars, lengths): + if val > 0: + axes[2].text(bar.get_x() + bar.get_width() / 2, bar.get_height(), + f'{val:.0f}', ha='center', va='bottom', fontsize=7) + + axes[2].set_title('path Length') + axes[2].set_ylabel('steps') + axes[2].set_xticks(x + width) + axes[2].set_xticklabels(mazes, rotation=45, ha='right', fontsize=8) + axes[2].legend() + axes[2].grid(alpha=0.3, axis='y') + + plt.tight_layout() + + output_path = os.path.join(DATA_PATH, 'experiment_results.png') + plt.savefig(output_path, dpi=150, bbox_inches='tight') + print(f"\nPlot saved to: {output_path}") + plt.show() + + +def save_results_to_csv(results, filename='experiment_results.csv'): + if not results: + return + + filepath = os.path.join(DATA_PATH, filename) + with open(filepath, 'w', newline='', encoding='utf-8') as f: + fieldnames = ['maze', 'strategy', 'time_ms', 'visited_cells', 'path_length', 'success_rate'] + writer = csv.DictWriter(f, fieldnames=fieldnames) + writer.writeheader() + writer.writerows(results) + + print(f"Results saved to: {filepath}") + + +def analyze_efficiency(results): + valid_results = [r for r in results if r['time_ms'] > 0] + if not valid_results: + print("no valid results for analysis") + return + + algo_stats = {} + for algo in ['BFS', 'DFS', 'A*']: + algo_data = [r for r in valid_results if r['strategy'] == algo] + if algo_data: + algo_stats[algo] = { + 'avg_time': sum(r['time_ms'] for r in algo_data) / len(algo_data), + 'avg_visited': sum(r['visited_cells'] for r in algo_data) / len(algo_data), + 'avg_length': sum(r['path_length'] for r in algo_data) / len(algo_data) + } + + + print("average values across all mazes") + print(f"{'Algorithm':<12} {'Time (ms)':<15} {'Visited':<15} {'Path length':<15}") + + for algo, stats in algo_stats.items(): + print(f"{algo:<12} {stats['avg_time']:<15.3f} {stats['avg_visited']:<15.1f} {stats['avg_length']:<15.1f}") + + fastest = min(algo_stats.items(), key=lambda x: x[1]['avg_time']) + optimal = min(algo_stats.items(), key=lambda x: x[1]['avg_length']) + efficient = min(algo_stats.items(), key=lambda x: x[1]['avg_visited']) + + print("conclusions:") + print(f" fastest algorithm: {fastest[0]} ({fastest[1]['avg_time']:.3f} ms avg)") + print(f" optimal path: {optimal[0]} ({optimal[1]['avg_length']:.1f} steps avg)") + print(f" most efficient (fewest visits): {efficient[0]} ({efficient[1]['avg_visited']:.0f} cells avg)") + print("=" * 70) + + +def main(): + + + if not os.path.exists(DATA_PATH): + print(f"\nerr: directory not found: {DATA_PATH}") + print("please create the directory and place maze files there.") + print("\nexpected structure:") + print(f" {DATA_PATH}/") + print(" ├── small.txt") + print(" ├── medium.txt") + print(" ├── large.txt") + print(" ├── empty.txt") + print(" └── no_exit.txt") + return + + runner = ExperimentRunner() + results = runner.run_all_experiments(runs=5) + + if not results: + print("\nNo results. Check if maze files exist in:", DATA_PATH) + return + + save_results_to_csv(results) + analyze_efficiency(results) + create_visualizations(results) + + + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/fomichevks/docs/data/small.txt b/fomichevks/docs/data/small.txt new file mode 100644 index 0000000..e21dcdf --- /dev/null +++ b/fomichevks/docs/data/small.txt @@ -0,0 +1,10 @@ +########## +#S # +### ##### +# # E# +# # # # ## +# # # +####### # +# # +# ###### # +########## \ No newline at end of file diff --git a/fomichevks/docs/performance_comparison.png b/fomichevks/docs/performance_comparison.png new file mode 100644 index 0000000..71e527b Binary files /dev/null and b/fomichevks/docs/performance_comparison.png differ diff --git a/fomichevks/docs/results.csv b/fomichevks/docs/results.csv new file mode 100644 index 0000000..d72b22a --- /dev/null +++ b/fomichevks/docs/results.csv @@ -0,0 +1,109 @@ +Структура,Режим,Операция,Время (сек) +LinkedList,случайный,insert,3.450394299999971 +LinkedList,случайный,find,0.02368320000005042 +LinkedList,случайный,delete,0.0178195999997115 +HashTable,случайный,insert,0.009212800000568677 +HashTable,случайный,find,6.169999960548012e-05 +HashTable,случайный,delete,3.860000015265541e-05 +BST,случайный,insert,0.015902500000265718 +BST,случайный,find,0.00014120000014372636 +BST,случайный,delete,8.770000022195745e-05 +LinkedList,случайный,insert,3.517222700000275 +LinkedList,случайный,find,0.026108199999725912 +LinkedList,случайный,delete,0.01791400000001886 +HashTable,случайный,insert,0.009205899999869871 +HashTable,случайный,find,5.869999949936755e-05 +HashTable,случайный,delete,3.609999930631602e-05 +BST,случайный,insert,0.017175400000269292 +BST,случайный,find,0.0001505999998698826 +BST,случайный,delete,9.200000022246968e-05 +LinkedList,случайный,insert,3.435324000000037 +LinkedList,случайный,find,0.026613500000166823 +LinkedList,случайный,delete,0.020348300000478048 +HashTable,случайный,insert,0.01095050000003539 +HashTable,случайный,find,6.169999960548012e-05 +HashTable,случайный,delete,3.9000000469968654e-05 +BST,случайный,insert,0.015578700000332901 +BST,случайный,find,0.0001768000001902692 +BST,случайный,delete,0.00010370000018156134 +LinkedList,случайный,insert,3.4476645999993707 +LinkedList,случайный,find,0.025092200000472076 +LinkedList,случайный,delete,0.017970900000364054 +HashTable,случайный,insert,0.008620399999927031 +HashTable,случайный,find,5.6599999879836105e-05 +HashTable,случайный,delete,3.699999979289714e-05 +BST,случайный,insert,0.016901099999813596 +BST,случайный,find,0.0001353999996354105 +BST,случайный,delete,8.39000003907131e-05 +LinkedList,случайный,insert,3.4527680000001055 +LinkedList,случайный,find,0.02482880000025034 +LinkedList,случайный,delete,0.01792089999980817 +HashTable,случайный,insert,0.00791659999958938 +HashTable,случайный,find,0.00012760000026901253 +HashTable,случайный,delete,6.010000015521655e-05 +BST,случайный,insert,0.01643800000056217 +BST,случайный,find,0.0001905999997688923 +BST,случайный,delete,9.900000077323057e-05 +LinkedList,отсортированный,insert,3.2146765999996205 +LinkedList,отсортированный,find,0.02251799999976356 +LinkedList,отсортированный,delete,0.016432399999757763 +HashTable,отсортированный,insert,0.008092500000202563 +HashTable,отсортированный,find,7.089999962772708e-05 +HashTable,отсортированный,delete,4.069999977218686e-05 +BST,отсортированный,insert,8.144065100000262 +BST,отсортированный,find,0.07145860000036919 +BST,отсортированный,delete,0.041536599999744794 +LinkedList,отсортированный,insert,3.2909168000005593 +LinkedList,отсортированный,find,0.1718697999995129 +LinkedList,отсортированный,delete,0.03186750000077154 +HashTable,отсортированный,insert,0.014283700000305544 +HashTable,отсортированный,find,9.820000013860408e-05 +HashTable,отсортированный,delete,5.8200000239594374e-05 +BST,отсортированный,insert,7.79496620000009 +BST,отсортированный,find,0.06252070000027743 +BST,отсортированный,delete,0.04316579999976966 +LinkedList,отсортированный,insert,3.3210246999997253 +LinkedList,отсортированный,find,0.020591699999386037 +LinkedList,отсортированный,delete,0.016228899999987334 +HashTable,отсортированный,insert,0.007315800000469608 +HashTable,отсортированный,find,5.450000026030466e-05 +HashTable,отсортированный,delete,3.370000013092067e-05 +BST,отсортированный,insert,8.219712999999501 +BST,отсортированный,find,0.0645872999994026 +BST,отсортированный,delete,0.04166759999952774 +LinkedList,отсортированный,insert,3.3059798000003866 +LinkedList,отсортированный,find,0.020161800000096264 +LinkedList,отсортированный,delete,0.016405999999733467 +HashTable,отсортированный,insert,0.008103499999378982 +HashTable,отсортированный,find,6.690000009257346e-05 +HashTable,отсортированный,delete,3.999999989900971e-05 +BST,отсортированный,insert,9.020431099999769 +BST,отсортированный,find,0.06939630000033503 +BST,отсортированный,delete,0.04487580000022717 +LinkedList,отсортированный,insert,3.5286267000001317 +LinkedList,отсортированный,find,0.022289700000328594 +LinkedList,отсортированный,delete,0.018663600000763836 +HashTable,отсортированный,insert,0.010729900000114867 +HashTable,отсортированный,find,7.849999929021578e-05 +HashTable,отсортированный,delete,4.8600000809528865e-05 +BST,отсортированный,insert,8.329646700000012 +BST,отсортированный,find,0.06335099999978411 +BST,отсортированный,delete,0.042559800000162795 +LinkedList,случайный,insert (СРЕДНЕЕ),3.4606747199999517 +LinkedList,случайный,find (СРЕДНЕЕ),0.025265180000133114 +LinkedList,случайный,delete (СРЕДНЕЕ),0.018394740000076126 +LinkedList,отсортированный,insert (СРЕДНЕЕ),3.3322449200000848 +LinkedList,отсортированный,find (СРЕДНЕЕ),0.051486199999817475 +LinkedList,отсортированный,delete (СРЕДНЕЕ),0.019919680000202788 +HashTable,случайный,insert (СРЕДНЕЕ),0.00918123999999807 +HashTable,случайный,find (СРЕДНЕЕ),7.325999977183528e-05 +HashTable,случайный,delete (СРЕДНЕЕ),4.215999997541076e-05 +HashTable,отсортированный,insert (СРЕДНЕЕ),0.009705080000094313 +HashTable,отсортированный,find (СРЕДНЕЕ),7.379999988188501e-05 +HashTable,отсортированный,delete (СРЕДНЕЕ),4.4240000170248096e-05 +BST,случайный,insert (СРЕДНЕЕ),0.016399140000248735 +BST,случайный,find (СРЕДНЕЕ),0.0001589199999216362 +BST,случайный,delete (СРЕДНЕЕ),9.326000035798643e-05 +BST,отсортированный,insert (СРЕДНЕЕ),8.301764419999927 +BST,отсортированный,find (СРЕДНЕЕ),0.06626278000003367 +BST,отсортированный,delete (СРЕДНЕЕ),0.04276111999988643 diff --git a/fomichevks/docs/отчет.txt b/fomichevks/docs/отчет.txt new file mode 100644 index 0000000..04bd828 --- /dev/null +++ b/fomichevks/docs/отчет.txt @@ -0,0 +1,137 @@ +1. Цель работы +Реализовать три базовые структуры данных без использования объектно-ориентированных механизмов, применить их для хранения записей телефонного справочника, экспериментально измерить производительность операций вставки, поиска и удаления, а также проанализировать влияние порядка входных данных на время выполнения. + +Связный список (LinkedListPhoneBook) +Узел: {'name': str, 'phone': str, 'next': dict | None} +Операции: +ll_insert: линейный проход до конца, обновление при совпадении имени, вставка нового узла в хвост. Возвращает голову списка. +ll_find: последовательный перебор до первого совпадения. +ll_delete: поиск предшественника удаляемого узла, переназначение ссылки next. +ll_list_all: сбор записей в список, явная сортировка по имени. + +Хеш-таблица с цепочками (HashTable) +Структура: список из BUCKET_COUNT = 1024 элементов, каждый элемент — голова связного списка. +Хеширование: idx = hash(name) % BUCKET_COUNT +Операции: делегируют соответствующим ll_* функциям для конкретного бакета. + +Узел: {'name': str, 'phone': str, 'left': dict | None, 'right': dict | None} +Операции: +bst_insert: рекурсивное сравнение имён, создание листа при достижении None. +bst_find: рекурсивный спуск влево/вправо в зависимости от результата сравнения. +bst_delete: три случая: 0 потомков, 1 потомок, 2 потомка. При двух потомках используется inorder-преемник (минимальный элемент правого поддерева). +bst_list_all: центрированный (in-order) обход, гарантирующий отсортированный вывод без дополнительной сортировки. + +Влияние порядка входных данных на скорость вставки в BST +Двоичное дерево поиска (BST) поддерживает инвариант: left.name < root.name < right.name. При вставке новых узлов алгоритм рекурсивно спускается по дереву, выбирая левую или правую ветвь в зависимости от результата сравнения. + +Случай 1: Случайный порядок данных +Ключи распределяются по дереву хаотично +Левые и правые поддеревья заполняются примерно равномерно +Высота дерева: h ≈ log₂(N) ≈ 14 для N=10 000 +Сложность вставки одного элемента: O(log N) +Общая сложность вставки всех N элементов: O(N log N) + +Случай 2: Отсортированный порядок данных +Каждый следующий ключ больше всех предыдущих +Алгоритм всегда выбирает правую ветвь +Дерево вырождается в линейную цепочку + +Почему хеш-таблица почти не чувствительна к порядку? + +Функция hash() в Python: +Детерминирована: один и тот же ключ → один и тот же хеш +Равномерно распределяет значения по пространству хешей +Не зависит от порядка вызова: hash("User_00001") всегда одинаков + +Распределение по бакетам +При N=10 000 записей и 1024 бакетах: +Ожидаемая загрузка: α = N / BUCKET_COUNT ≈ 9.77 элементов на бакет +Даже если все ключи отсортированы, их хеши «размазываются» по всему диапазону +Внутри каждого бакета хранится короткий связный список (~10 элементов) + +Почему связный список всегда медленен при поиске? + +Связный список хранит элементы последовательно, без индексации +Для поиска элемента с именем X: +Начать с головы списка +Сравнить curr['name'] == X +Если не совпало → перейти к curr['next'] +Повторять до нахождения или конца списка +Связный список не подходит для задач с частым поиском. Его удел очереди, стеки, или вспомогательная роль внутри других структур. + +Как удаление работает в каждой структуре? +Связный список +def ll_delete(head, name): + if head['name'] == name: + return head['next'] + curr = head + while curr['next']: + if curr['next']['name'] == name: + curr['next'] = curr['next']['next'] + return head + curr = curr['next'] + return head + +Поиск узла (или его предшественника) — O(N) +Переназначение ссылки next — O(1) +Сборка мусора (автоматически в Python) + +Хеш-таблица +def ht_delete(buckets, name): + idx = hash(name) % BUCKET_COUNT + buckets[idx] = ll_delete(buckets[idx], name) + +Вычисление индекса бакета — O(1) +Поиск и удаление в связном списке бакета — O(L), где L ≈ 10 +Итого: O(1) в среднем + +Двоичное дерево поиска +def bst_delete(root, name): + # 1. Поиск узла + if name < root['name']: + root['left'] = bst_delete(root['left'], name) + elif name > root['name']: + root['right'] = bst_delete(root['right'], name) + else: + # 2. Три случая удаления + if root['left'] is None: + return root['right'] # 0 или 1 потомок + elif root['right'] is None: + return root['left'] + else: + # 2 потомка: найти inorder-преемника + successor = _bst_find_min(root['right']) + root['name'] = successor['name'] + root['phone'] = successor['phone'] + root['right'] = bst_delete(root['right'], successor['name']) + return root + +Поиск удаляемого узла — O(h) +Обработка случая: +0 потомков: просто удалить узел +1 потомок: «поднять» потомка на место удаляемого +2 потомка: найти минимум в правом поддереве (inorder-преемник), скопировать его данные, рекурсивно удалить преемника +Возврат обновлённого корня поддерева + +Когда какую структуру использовать? + +| Сценарий | Рекомендация | +|---|---| +| **Частый поиск** по имени | HashTable или BST (случайные данные) | +| **Данные приходят отсортированными** | HashTable (BST деградирует!) | +| **Нужен отсортированный список** | BST (in-order обход — бесплатный) | +| **Частые вставки/удаления + поиск** | HashTable | +| **Минимальная память, простота** | LinkedList (для малых N) | +| **Диапазонные запросы** (все имена A–M) | BST | + +### Сложности операций + +| Структура | Insert | Find | Delete | List (sorted) | +|---|---|---|---|---| +| LinkedList | O(n) | O(n) | O(n) | O(n log n) | +| HashTable | O(1) avg | O(1) avg | O(1) avg | O(n log n) | +| BST (сбалансированный) | O(log n) | O(log n) | O(log n) | O(n) | +| BST (вырожденный) | O(n) | O(n) | O(n) | O(n) | + + +HashTable — лучший выбор для телефонного справочника при частых вставках и поисках. BST лучше HashTable только если нужен отсортированный вывод без дополнительной сортировки — но при условии случайного порядка вставки или использования самобалансирующегося дерева (AVL, Red-Black). diff --git a/fomichevks/docs/структуры_данных.py b/fomichevks/docs/структуры_данных.py new file mode 100644 index 0000000..1eaa7dd --- /dev/null +++ b/fomichevks/docs/структуры_данных.py @@ -0,0 +1,257 @@ +import random +import time +import csv +import sys + + +sys.setrecursionlimit(20000) + + +# 1. СВЯЗНЫЙ СПИСОК +def ll_insert(head, name, phone): + curr = head + while curr: + if curr['name'] == name: + curr['phone'] = phone + return head + curr = curr['next'] + + new_node = {'name': name, 'phone': phone, 'next': None} + if head is None: + return new_node + + curr = head + while curr['next']: + curr = curr['next'] + curr['next'] = new_node + return head + + +def ll_find(head, name): + curr = head + while curr: + if curr['name'] == name: + return curr['phone'] + curr = curr['next'] + return None + + +def ll_delete(head, name): + if head is None: + return None + if head['name'] == name: + return head['next'] + + curr = head + while curr['next']: + if curr['next']['name'] == name: + curr['next'] = curr['next']['next'] + return head + curr = curr['next'] + return head + + +def ll_list_all(head): + res = [] + curr = head + while curr: + res.append((curr['name'], curr['phone'])) + curr = curr['next'] + res.sort(key=lambda x: x[0]) + return res + + + +# 2. ХЕШ-ТАБЛИЦА +BUCKET_COUNT = 1024 + + +def ht_insert(buckets, name, phone): + idx = hash(name) % BUCKET_COUNT + buckets[idx] = ll_insert(buckets[idx], name, phone) + + +def ht_find(buckets, name): + idx = hash(name) % BUCKET_COUNT + return ll_find(buckets[idx], name) + + +def ht_delete(buckets, name): + idx = hash(name) % BUCKET_COUNT + buckets[idx] = ll_delete(buckets[idx], name) + + +def ht_list_all(buckets): + res = [] + for head in buckets: + curr = head + while curr: + res.append((curr['name'], curr['phone'])) + curr = curr['next'] + res.sort(key=lambda x: x[0]) + return res + + + +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): + 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 _bst_find_min(node): + curr = node + while curr['left'] is not None: + curr = curr['left'] + return curr + + +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'] + else: + 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): + res = [] + + def inorder(node): + if node: + inorder(node['left']) + res.append((node['name'], node['phone'])) + inorder(node['right']) + + inorder(root) + return res + + + +# ЭКСПЕРИМЕНТАЛЬНАЯ ЧАСТЬ +def run_experiments(): + N = 10000 + base_records = [(f"User_{i:05d}", f"100{i:05d}") for i in range(N)] + + records_sorted = sorted(base_records, key=lambda x: x[0]) + records_shuffled = base_records[:] + random.shuffle(records_shuffled) + + all_names = [r[0] for r in base_records] + find_existing = random.sample(all_names, 100) + find_non_existing = [f"Missing_{i}" for i in range(10)] + delete_targets = random.sample(all_names, 50) + + all_results = [] + structures = ["LinkedList", "HashTable", "BST"] + data_modes = [("случайный", records_shuffled), ("отсортированный", records_sorted)] + + for mode_name, records in data_modes: + print(f"\n Режим: {mode_name}") + for run in range(1, 6): + print(f" запуск {run}/5") + + + head = None + t = time.perf_counter() + for n, p in records: head = ll_insert(head, n, p) + t_ins = time.perf_counter() - t + + t = time.perf_counter() + for n in find_existing + find_non_existing: ll_find(head, n) + t_find = time.perf_counter() - t + + t = time.perf_counter() + for n in delete_targets: head = ll_delete(head, n) + t_del = time.perf_counter() - t + + all_results.append(["LinkedList", mode_name, "insert", t_ins]) + all_results.append(["LinkedList", mode_name, "find", t_find]) + all_results.append(["LinkedList", mode_name, "delete", t_del]) + + + buckets = [None] * BUCKET_COUNT + t = time.perf_counter() + for n, p in records: ht_insert(buckets, n, p) + t_ins = time.perf_counter() - t + + t = time.perf_counter() + for n in find_existing + find_non_existing: ht_find(buckets, n) + t_find = time.perf_counter() - t + + t = time.perf_counter() + for n in delete_targets: ht_delete(buckets, n) + t_del = time.perf_counter() - t + + all_results.append(["HashTable", mode_name, "insert", t_ins]) + all_results.append(["HashTable", mode_name, "find", t_find]) + all_results.append(["HashTable", mode_name, "delete", t_del]) + + + root = None + t = time.perf_counter() + for n, p in records: root = bst_insert(root, n, p) + t_ins = time.perf_counter() - t + + t = time.perf_counter() + for n in find_existing + find_non_existing: bst_find(root, n) + t_find = time.perf_counter() - t + + t = time.perf_counter() + for n in delete_targets: root = bst_delete(root, n) + t_del = time.perf_counter() - t + + all_results.append(["BST", mode_name, "insert", t_ins]) + all_results.append(["BST", mode_name, "find", t_find]) + all_results.append(["BST", mode_name, "delete", t_del]) + + + averages = [] + for struct in structures: + for mode in ["случайный", "отсортированный"]: + for op in ["insert", "find", "delete"]: + times = [r[3] for r in all_results if r[0] == struct and r[1] == mode and r[2] == op] + avg = sum(times) / len(times) + averages.append([struct, mode, f"{op} (СРЕДНЕЕ)", avg]) + + final_csv_data = [["Структура", "Режим", "Операция", "Время (сек)"]] + all_results + averages + + with open("results.csv", "w", newline="", encoding="utf-8-sig") as f: + writer = csv.writer(f) + writer.writerows(final_csv_data) + + return all_results, averages + + +if __name__ == "__main__": + raw_data, avg_data = run_experiments() +