如何使用Java数据结构代码实现

下面是使用Java数据结构代码实现迷宫求解的示例代码，主要采用了二维数组和栈两种数据结构：

import java.util.Stack;

public class MazeSolver {

    public static void main(String[] args) {
        // 定义迷宫
        int[][] maze = {
                {1, 1, 1, 1, 1, 1, 1, 1, 1},
                {1, 0, 1, 1, 0, 0, 0, 1, 1},
                {1, 0, 0, 1, 0, 1, 0, 0, 1},
                {1, 0, 1, 0, 0, 1, 1, 0, 1},
                {1, 0, 1, 1, 1, 0, 1, 0, 1},
                {1, 0, 0, 0, 1, 0, 1, 0, 1},
                {1, 0, 1, 0, 0, 0, 0, 0, 1},
                {1, 0, 1, 1, 1, 1, 1, 0, 1},
                {1, 1, 1, 1, 1, 1, 1, 1, 1}
        };
        int startRow = 1; // 入口行
        int startCol = 1; // 入口列
        int endRow = 7; // 出口行
        int endCol = 7; // 出口列

        // 创建一个栈，用于保存已访问过的位置
        Stack<int[]> stack = new Stack<>();
        // 将入口位置压入栈中
        stack.push(new int[]{startRow, startCol});

        // 开始DFS搜索
        while (!stack.isEmpty()) {
            // 取出栈顶位置
            int[] curr = stack.peek();
            int row = curr[0];
            int col = curr[1];

            // 判断是否到达出口
            if (row == endRow && col == endCol) {
                // 输出路径
                while (!stack.isEmpty()) {
                    int[] pos = stack.pop();
                    System.out.printf("(%d,%d) ", pos[0], pos[1]);
                }
                System.out.println();
                // 标记路径
                maze[row][col] = 9;
                break;
            }

            // 尝试向下一个位置移动
            boolean moved = false;
            if (row > 0 && maze[row-1][col] == 0) { // 上
                stack.push(new int[]{row-1, col});
                maze[row-1][col] = 2; // 标记为已访问
                moved = true;
            } else if (col < maze[0].length-1 && maze[row][col+1] == 0) { // 右
                stack.push(new int[]{row, col+1});
                maze[row][col+1] = 2; // 标记为已访问
                moved = true;
            } else if (row < maze.length-1 && maze[row+1][col] == 0) { // 下
                stack.push(new int[]{row+1, col});
                maze[row+1][col] = 2; // 标记为已访问
                moved = true;
            } else if (col > 0 && maze[row][col-1] == 0) { // 左
                stack.push(new int[]{row, col-1});
                maze[row][col-1] = 2; // 标记为已访问
                moved = true;
            }

            if (!moved) { // 如果无法移动，则回退到上一个位置
                stack.pop();
            }
        }

        // 输出迷宫
        for (int[] row : maze) {
            for (int cell : row) {
                System.out.print(cell + " ");
            }
            System.out.println();
        }
    }
}

在示例代码中，使用二维数组表示迷宫，使用栈来保存已访问过的位置。通过遍历二维数组，找到通路的过程中，采用深度优先搜索（DFS）算法，每次访问一个位置时，将该位置入栈，并尝试向该位置的四个方向移动。如果当前位置已经到达出口，则输出路径，否则回退到上一个位置。最后输出标记过路径的迷宫。