Рекурсия лабиринта решает ошибку StackOverflow

Если у лабиринта есть цикл, решатель может вечно обходить этот цикл, что приведет к переполнению стека, которое вы видите. Вам нужен способ определить, когда вы видите квадрат лабиринта, который уже видели. В этом случае следует немедленно вернуться назад.

Это можно сделать либо с помощью логического флага visited в каждой ячейке, изначально установленного в значение false, а затем установленного в значение true для каждого квадрата, который вы ищете, либо вы можете поддерживать отдельные Set из (i,j) пар, которые были найдены, которые изначально пусты.

NB: Ваше использование i и j нетрадиционно. Если бы кто-то другой написал код чтения лабиринта с обычным использованием, это могло бы вызвать проблему. В математике i обычно используется для номера строки и j для столбца. С этим соглашением ваши тесты стены не согласуются с вашими приращениями и уменьшениями. Отсутствие нижней стенки потребует, например, увеличения i.

Мне кажется, что вы ходите по кругу в своем методе решателя.
Я предлагаю вам ознакомиться с Поиск в ширину, который часто используется для не слишком больших задач поиска состояний.

Если у вас есть некоторые «знания», эвристика, о том, как искать в лабиринте, вы также можете взглянуть на Поиск A-Star

В вашем случае BFS может сделать следующее: (Кстати, будьте любезны и используйте соответствующие конструкторы, геттеры и сеттеры)

public class Cell {
    public int x;
    public int y;
    public Cell parent;

    @Override
    public boolean equals(Object obj) {
        // TODO Override equals so it only incudes x and y coorinates, and not parent
        return true;
    }

    @Override
    public int hashCode() {
        // TODO Override hash code as well
        return 0;
    }
}

public Cell seachFor(Cell start, Cell finish) {
    Queue<Cell> open = new LinkedList<>();
    Set<Cell> closed = new HashSet<>();

    open.add(start);

    while (!open.isEmpty()) {
        Cell current = open.poll();
        if (current.equals(finish)) {
            return current;
        }

        closed.add(current);

        for (Cell neighbour : getNeighbours(current)) {
            if (!closed.contains(neighbour)) {
                open.add(neighbour);
            }
        }
    }

    return null;

}

private List<Cell> getNeighbours(Cell current) {
    /* TODO Set the neighbour's "parent"
     * Return valid adjacent neighbour cells
     */
    return null;
}

public Deque<Cell> pathfinder(Cell start) {
    Deque<Cell> path = new ArrayDeque<>();
    path.push(start);

    Cell current = start;

    while (current.parent != null) {
        current = current.parent;
        path.push(current);
    }

    return path;
}

public static void main(String[] args) {
    Cell start = maze.getStart();
    Cell finish = maze.getFinish();
    Deque<Cell> path = pathFinder(searchFor(start, finish))
    while (!path.isEmpty()) {
        Cell current = path.pop();
        maze.moveTo(current);
    }
}

Обратите внимание, что это фиктивный код, и вам нужно уточнить его, прежде чем он заработает.

В вашем коде нет ничего для обнаружения мест, где вы уже были раньше. Если в вашем лабиринте есть какие-либо проходы, в которых вы можете пройти по кругу или вернуться к тому месту, где вы были раньше, не возвращаясь назад, он будет продолжать бесконечно возвращаться по тому же пути.

Сначала спускайтесь вниз, пока не дойдете до стены. Потом один вверх - потом снова вниз. И один вверх, и один вниз - пока java не обнаружит, что это довольно глупо, и не остановится с StackOverFlowError;)

у вас заканчивается память, выделенная в стеке. иначе ваша рекурсия умножается слишком быстро, когда вы превышаете ресурсы JVM в данный момент времени.

вы можете увеличить память, а затем убить все остальные итерации этого метода или изменить свой алгоритм. Изменение размера стека было бы плохим решением, но оно может работать, даже если ваш код имеет недостатки как увеличить размер стека в eclipse Я предлагаю отметить, какие области вы уже посетили

лабиринт Cell[][] maze

  public class Cell{
    boolean visited = false;
    Wall left;
    Wall right;
    Wall up;
    Wall bottom;
    boolean end;

    //Settters and Getters
    }

устанавливайте для этой посещаемой переменной значение true каждый раз, когда вы ее нажимаете, а затем изменяйте свой код на

public boolean solveMaze(Cell[][] maze, int i, int j){
        if (maze[i][j].isEnd()){
            System.out.println(maze[i][j].toString());
            return true;
        }
        if (maze[i][j].getButton() == null)&&(maze[i][j].visited==false)){
            return solveMaze(maze,i,j+1); 
        }

        if (maze[i][j].getUp() == null){
        return solveMaze(maze,i,j-1) ;
        }
        // ect 

Я не буду реализовывать это, если у вас нет проблем с тем, чтобы сделать это самостоятельно, с вопросами на собеседовании, я думаю, будет здорово, если вы решите их самостоятельно с помощью подсказок, таким образом, у вас возникнет ощущение, что вы могли бы решить что-то подобное снова, где, если вы просто прочитали и поняли ответ, который вы может быть в состоянии повторить ответ на ту же проблему, но вы не сможете найти новый ответ на аналогичную проблему, используя аналогичные стратегии.