Java 不从基条件返回的递归函数

我试图从基本条件返回一个方向，无论是向上、向下、向左还是向右，在递归条件下，我寻找一个可能的移动位置。但程序只返回“q”，该值在函数启动时初始化。我知道这与堆栈的展开有关，但我不知道如何解决这个问题。 这是迷宫：

char [][]Maze = {{'S','#','#','#','#','#'}, 
                 {'.','.','.','.','.','#'},
                 {'#','.','#','#','#','#'},
                 {'#','.','#','#','#','#'},
                 {'.','.','.','#','.','G'},
                 {'#','#','.','.','.','#'}};

代码如下：

public static char BackTrace(char[][]Maze, int x, int y)
{
    char direction = 'q';
    if (Maze[x+1][y] == '.')
    {
        direction = 'd';
    }
    else if (Maze[x-1][y] == '.')
    {
        direction = 'u';
    }
    else if (Maze[x][y+1] == '.')
    {
        direction = 'r';
    }
    else if (Maze[x][y-1] == '.')
    {
        direction = 'l';
    }
    else
    {
        Maze[x][y] = '+';
        if(Maze[x+1][y] == 'X')         /// Start moving Down
        {
            direction = BackTrace(Maze, x+1, y);
        }
        else if(Maze[x-1][y] == 'X')    /// Start Moving Up
        {
            direction = BackTrace(Maze, x-1, y);
        }
        else if(Maze[x][y+1] == 'X')    /// Start Moving Right
        {
            direction = BackTrace(Maze, x, y+1);
        }
        else if(Maze[x][y-1] == 'X')    /// Start Moving Left
        {
            direction = BackTrace(Maze, x, y-1);
        }

    }
    return direction;
}

public static char BackTrace(char[][]Maze, int x, int y)
{
    char direction = 'q';
    if (Maze[x+1][y] == '.')
    {
        direction = 'd';
    }
    else if (Maze[x-1][y] == '.')
    {
        direction = 'u';
    }
    else if (Maze[x][y+1] == '.')
    {
        direction = 'r';
    }
    else if (Maze[x][y-1] == '.')
    {
        direction = 'l';
    }
    else
    {
        Maze[x][y] = '+';
        if(Maze[x+1][y] == 'X')         /// Start moving Down
        {
            direction = BackTrace(Maze, x+1, y);
            return direction;
        }
        else if(Maze[x-1][y] == 'X')    /// Start Moving Up
        {
            direction = BackTrace(Maze, x-1, y);
            return direction;
        }
        else if(Maze[x][y+1] == 'X')    /// Start Moving Right
        {
            direction = BackTrace(Maze, x, y+1);
            return direction;
        }
        else if(Maze[x][y-1] == 'X')    /// Start Moving Left
        {
            direction = BackTrace(Maze, x, y-1);
            return direction;
        }

    }
    return direction;
}

---

您忘记将递归调用的返回值分配给变量方向。

---

（即

方向=回溯（迷宫，x+1，y）；

等）

首先，你可能需要检查并确保你没有越界。而不是像这样的线条

if (Maze[x+1][y] == '.')

您将要检查您的射程

if (x+1<Maze.length && Maze[x+1][y] == '.')

它永远不会工作（除了可能的错误），应该是

if(x+1<Maze.length && Maze[x+1][y] == '#')

可能从带有

'd'

的基本情况返回，然后该

'd'

将不起作用。我假设你想从你的基本情况中得到方向，在这种情况下你应该试试

direction = BackTrace(Maze, x+1, y);

并同样修改其他3个递归调用。这会阻止你得到

'q'

，除非周围没有

'.

s或

'#'

s

我不知道这些更改是否会让您的方法实现您想要的功能，但它们会让您的方法实现比返回

'q'

更多的功能

最终结果：

 public static char BackTrace(char[][]Maze, int x, int y)
 {
    char direction = 'q';
    if (x+1<Maze.length && Maze[x+1][y] == '.')
    {
        direction = 'd';
    }
    else if (x-1>=0 && Maze[x-1][y] == '.')
    {
        direction = 'u';
    }
    else if (y+1<Maze[x].length && Maze[x][y+1] == '.')
    {
        direction = 'r';
    }
    else if (y-1>=0 && Maze[x][y-1] == '.')
    {
        direction = 'l';
    }
    else
    {
        Maze[x][y] = '+';
        if(x+1<Maze.length && Maze[x+1][y] == '#')         /// Start moving Down
        {
            direction = BackTrace(Maze, x+1, y);
        }
        else if(x-1>=0 && Maze[x-1][y] == '#')    /// Start Moving Up
        {
            direction = BackTrace(Maze, x-1, y);
        }
        else if(y+1<Maze[x].length && Maze[x][y+1] == '#')    /// Start Moving Right
        {
            direction = BackTrace(Maze, x, y+1);
        }
        else if(y-1>=0 && Maze[x][y-1] == '#')    /// Start Moving Left
        {
            direction = BackTrace(Maze, x, y-1);
        }

    }
    return direction;
}

publicstaticcharbacktrace（char[][]迷宫，intx，inty）
{
字符方向='q'；
如果（x+1=0&&Maze[x-1][y]='。）
{
方向='u'；
}
else如果（y+1=0&&Maze[x][y-1]='。）
{
方向='l'；
}
其他的
{
迷宫[x][y]='+'；
如果（x+1=0&&Maze[x-1][y]='#'）///开始向上移动
{
方向=回溯（迷宫，x-1，y）；
}
否则如果（y+1=0&&Maze[x][y-1]='#'）///开始向左移动
{
方向=回溯轨迹（迷宫，x，y-1）；
}
}
返回方向；
}

好的。我得到了它。谢谢大家。问题是每次堆栈展开时，方向的旧值都会不断更改新值。只需在每次函数调用后添加一个return语句，以便在堆栈展开时返回新值。代码如下：

public static char BackTrace(char[][]Maze, int x, int y)
{
    char direction = 'q';
    if (Maze[x+1][y] == '.')
    {
        direction = 'd';
    }
    else if (Maze[x-1][y] == '.')
    {
        direction = 'u';
    }
    else if (Maze[x][y+1] == '.')
    {
        direction = 'r';
    }
    else if (Maze[x][y-1] == '.')
    {
        direction = 'l';
    }
    else
    {
        Maze[x][y] = '+';
        if(Maze[x+1][y] == 'X')         /// Start moving Down
        {
            direction = BackTrace(Maze, x+1, y);
        }
        else if(Maze[x-1][y] == 'X')    /// Start Moving Up
        {
            direction = BackTrace(Maze, x-1, y);
        }
        else if(Maze[x][y+1] == 'X')    /// Start Moving Right
        {
            direction = BackTrace(Maze, x, y+1);
        }
        else if(Maze[x][y-1] == 'X')    /// Start Moving Left
        {
            direction = BackTrace(Maze, x, y-1);
        }

    }
    return direction;
}

public static char BackTrace(char[][]Maze, int x, int y)
{
    char direction = 'q';
    if (Maze[x+1][y] == '.')
    {
        direction = 'd';
    }
    else if (Maze[x-1][y] == '.')
    {
        direction = 'u';
    }
    else if (Maze[x][y+1] == '.')
    {
        direction = 'r';
    }
    else if (Maze[x][y-1] == '.')
    {
        direction = 'l';
    }
    else
    {
        Maze[x][y] = '+';
        if(Maze[x+1][y] == 'X')         /// Start moving Down
        {
            direction = BackTrace(Maze, x+1, y);
            return direction;
        }
        else if(Maze[x-1][y] == 'X')    /// Start Moving Up
        {
            direction = BackTrace(Maze, x-1, y);
            return direction;
        }
        else if(Maze[x][y+1] == 'X')    /// Start Moving Right
        {
            direction = BackTrace(Maze, x, y+1);
            return direction;
        }
        else if(Maze[x][y-1] == 'X')    /// Start Moving Left
        {
            direction = BackTrace(Maze, x, y-1);
            return direction;
        }

    }
    return direction;
}

---

它仍然返回“q”。您是否更改了所有行？是否所有函数调用都返回q，或者仅返回程序中的最后一个？是的。我尝试使用调试器查找问题。它显示当基本条件为真时，方向变量设置为“d”。但是，当堆栈展开并将控制权转移到BackTrace函数，调用最后一个返回语句时，方向变量再次设置为“q”。

if（x
if（x+1I已更改代码。但它仍然返回设置为“q”的方向变量。调试器显示方向变量设置为“d”，但当堆栈展开且最后一个返回语句再次调用时，方向变量返回“q”。公共静态字符回溯（char[][]Maze，int x，int y）这个函数只是程序的一部分，当程序在寻找路径时，它会朝错误的方向移动并撞到墙上。然后它必须回溯。没有X的原因是因为它们是在代码运行时放置的，并且正在跟踪一条路径。那
'+'
就是一个
'X'
吗？不。它只是用来作为一个标记来看看是什么它的回溯与否。x+1表示行是递增的，这意味着在数组中向下移动。我看不出这段代码如何解决您的问题。假设初始调用是调用
BackTrace（Maze，0，0）
代码将输入第一个
if
并设置
方向='d'
，然后将
返回方向。