为了编写一个解决C程序的蛮力迷宫，我首先编写了这个Java程序来测试一个想法。我对C还是很陌生，打算在Java中正确处理后将其转换。结果，我试图远离arraylist，fancy库等，以便更轻松地转换为C。该程序需要生成最短步骤的单个宽度路径来解决迷宫问题。我认为我的问题可能在于将通过每个递归传递的路径存储数组碎片化。感谢您的关注。-乔

maze:

1 3 3 3 3 
3 3 3 3 3 
3 0 0 0 3 
3 0 3 3 3 
0 3 3 3 2


Same maze solved by this program:
4 4 4 4 4 
4 4 4 4 4 
4 0 0 0 4 
3 0 3 3 4 
0 3 3 3 2

代码中解释了数字符号

    public class javamaze {

static storage[] best_path;
static int best_count;
static storage[] path;

//the maze - 1 = start; 2 = finish; 3 = open path
static int maze[][] = {{1, 3, 3, 3, 3}, 
    {3, 3, 3, 3, 3},
    {0, 0, 0, 0, 3},
    {0, 0, 3, 3, 3},
    {3, 3, 3, 3, 2}};

public static void main(String[] args) {

    int count1;
    int count2;

    //declares variables used in the solve method
    best_count = 0;
    storage[] path = new storage[10000];
    best_path = new storage[10000];
    int path_count = 0;


    System.out.println("Here is the maze:");
    for(count1 = 0; count1 < 5; count1++) {
        for(count2 = 0; count2 < 5; count2++) {
            System.out.print(maze[count1][count2] + " ");   
        }                       
        System.out.println("");         
    }

    //solves the maze
    solve(findStart()/5, findStart()%5, path, path_count);

    //assigns an int 4 path to the maze to visually represent the shortest path
    for(int count = 0; count <= best_path.length - 1; count++)
        if (best_path[count] != null)
            maze[best_path[count].getx()][best_path[count].gety()] = 4;

    System.out.print("Here is the solved maze\n");

    //prints the solved maze
    for(count1 = 0; count1 < 5; count1++) {
        for(count2 = 0; count2 < 5; count2++){
            System.out.print(maze[count1][count2] + " ");
        }
        System.out.print("\n");
    }
}

//finds maze start marked by int 1 - this works perfectly and isn't related to the problem
public static int findStart() {
    int count1, count2;
    for(count1 = 0; count1 < 5; count1++) {
        for(count2 = 0; count2 < 5; count2++) {
            if (maze[count1][count2] == 1)
                return (count1 * 5 + count2);
        }
    }
    return -1;
}

//saves path coordinate values into a new array
public static void save_storage(storage[] old_storage) {
    int count;
    for(count = 0; count < old_storage.length; count++) {
        best_path[count] = old_storage[count];
    }
}

//solves the maze
public static Boolean solve(int x, int y, storage[] path, int path_count) {

    //checks to see if grid squares are valid (3 = open path; 0 = wall
    if (x < 0 || x > 4) { //array grid is a 5 by 5
        //System.out.println("found row end returning false");
        return false;
    }
    if (y < 0 || y > 4) {
        //System.out.println("Found col end returning false");
        return false;
    }

    //when finding finish - records the number of moves in static int best_count
    if (maze[x][y] == 2) {
        if (best_count == 0 || best_count > path_count) {
            System.out.println("Found end with this many moves: " + path_count);
            best_count = path_count;
            save_storage(path); //copies path counting array into a new static array
        }
    }
    //returns false if it hits a wall
    if (maze[x][y] == 0)
        return false;

    //checks with previously crossed paths to prevent an unnecessary repeat in steps
    for(storage i: path) 
        if (i != null)
            if (i.getx() == x && i.gety() == y) 
                return false;

    //saves current recursive x, y (row, col) coordinates into a storage object which is then added to an array.
    //this array is supposed to fragment per each recursion which doesn't seem to - this may be the issue
    storage storespoints = new storage(x, y);
    path[path_count] = storespoints;

    //recurses up, down, right, left
    if (solve((x-1), y, path, path_count++) == true || solve((x+1), y, path, path_count++) == true ||
            solve(x, (y+1), path, path_count++) == true || solve(x, (y-1), path, path_count++) == true) {
        return true;
    }

    return false;
}
}

//stores (x, y) aka row, col coordinate points
class storage {

private int x;
private int y;

public storage(int x, int y) {
    this.x = x;
    this.y = y;
}
public int getx() {
    return x;
}
public int gety() {
    return y;
}
public String toString() {
    return ("storage coordinate: " + x + ", " + y + "-------");
}

}