java 栈迷宫路线搜索

原创

mob649e8159b30b 2024-11-13 04:07:59 ©著作权

文章标签 搜索 List 数据结构 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mob649e8159b30b的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 栈与迷宫路线搜索

在计算机科学中，栈是一种重要的数据结构，具有后进先出（LIFO）的特性。栈对于很多问题的解决非常有用，尤其是在路径搜索、递归和表达式求值等方面。本文将探讨如何利用栈来解决迷宫路线搜索问题，并提供相应的 Java 代码示例。

什么是迷宫

迷宫是一种空间结构，通常由障碍物和可通行的路径组成。我们需要从迷宫的入口出发，找到一条抵达出口的路径。迷宫的表示可以是一个二维数组，其中某些元素表示可行走的路径（通常是0），而其他元素表示障碍（通常是1）。

问题描述

在一个给定的迷宫中，我们需要找到从起点到终点的所有可能路径。使用栈可以有效地实现这一过程。

数据结构设计

我们需要用到以下数据结构：

迷宫表示：一个二维数组，表示迷宫。
栈：用于存储当前路径的节点。
访问标记：一个二维数组，记录是否访问过某个点，以避免走回头路。

流程图

以下是流程图，展示了用栈进行迷宫搜索的基本步骤：

flowchart TD
    A[开始] --> B[初始化迷宫与数据结构]
    B --> C[将起点压入栈]
    C --> D{栈是否为空?}
    D --|是|--> E[找到了终点]
    D --|否|--> F[从栈中弹出当前节点]
    F --> G{检查当前节点的邻居}
    G --|有可行走邻居|--> H[将邻居压入栈并标记访问]
    G --|没有可行走邻居|--> I[回到下一个节点]
    F --> D

Java 代码示例

以下是实现迷宫搜索的 Java 代码示例：

import java.util.*;

public class MazeSolver {
    static final int[][] directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};  // 右, 下, 左, 上

    public List<List<int[]>> findPaths(int[][] maze, int[] start, int[] end) {
        List<List<int[]>> result = new ArrayList<>();
        Stack<int[]> stack = new Stack<>();
        boolean[][] visited = new boolean[maze.length][maze[0].length];
        
        stack.push(start);
        visited[start[0]][start[1]] = true;
        
        List<int[]> path = new ArrayList<>();
        
        while (!stack.isEmpty()) {
            int[] current = stack.pop();
            path.add(current);
            
            // Check if we reached the end
            if (Arrays.equals(current, end)) {
                result.add(new ArrayList<>(path));
            } else {
                for (int[] dir : directions) {
                    int newRow = current[0] + dir[0];
                    int newCol = current[1] + dir[1];
                    
                    if (isSafe(maze, newRow, newCol, visited)) {
                        visited[newRow][newCol] = true;
                        stack.push(new int[]{newRow, newCol});
                    }
                }
            }
            
            // Remove the current node from the path if not valid
            if (!result.isEmpty() && !Arrays.equals(current, end)) {
                visited[current[0]][current[1]] = false;
                path.remove(path.size() - 1);
            }
        }
        
        return result;
    }

    private boolean isSafe(int[][] maze, int row, int col, boolean[][] visited) {
        return row >= 0 && row < maze.length && col >= 0 && col < maze[0].length &&
               maze[row][col] == 0 && !visited[row][col];
    }
    
    public static void main(String[] args) {
        int[][] maze = {
            {0, 1, 0, 0, 0},
            {0, 1, 0, 1, 0},
            {0, 0, 0, 1, 0},
            {0, 1, 0, 0, 0},
            {0, 0, 0, 1, 0}
        };
        
        MazeSolver solver = new MazeSolver();
        List<List<int[]>> paths = solver.findPaths(maze, new int[]{0, 0}, new int[]{4, 0});
        
        for (List<int[]> path : paths) {
            System.out.println("Path: " + Arrays.deepToString(path.toArray()));
        }
    }
}