下面是一个使用 Stack 包含连接之间的子路径和自实现的 Pairs . 已访问的字段保存在矩阵中。最后再次打印矩阵，其中结果字段（找到的路径）具有值 3 其他访问的字段具有 2 .

public class Pair {
    private int row;
    private int col;
    private Pair next;

    public Pair(int row, int col){
        this.row = row;
        this.col = col;
    }

    public int getRow(){
        return row;
    }
    public int getCol(){
        return col;
    }

    public Pair getNext() {
        return next;
    }

    public void setNext(Pair next) {
        this.next = next;
    }

}

///////////////////////

import java.util.*;

public class PathFinder {

    private int[][] arr;
    private int rowCount;
    private int colCount;
    private Stack<Pair> junctions = new Stack<>();

    public PathFinder(int[][] arr){
        this.arr = arr;
        this.rowCount = arr.length;
        if(rowCount > 0) {
            this.colCount = arr[0].length;
        }
    }

    public Pair dfs(Pair sp){

        int actualRow = sp.getRow();
        int actualCol = sp.getCol();

        //we where already here
        arr[actualRow][actualCol] = 2;

        if(actualRow >= rowCount - 1 && actualCol >= colCount - 1) {
            //ready
            return sp;
        }

        boolean deeper = actualRow +1 < rowCount && arr[actualRow +1][actualCol] == 0;
        boolean left = actualCol -1 >= 0 && arr[actualRow][actualCol -1] == 0;
        boolean right = actualCol +1 < colCount && arr[actualRow][actualCol +1] == 0;
        boolean up = actualRow -1 >= 0 && arr[actualRow-1][actualCol] == 0;

        //test for junctions
        int possibilities = 0;
        if(left){
            possibilities++;
        }
        if(right) {
            possibilities++;
        }
        if(deeper){
            possibilities++;
        }
        if(up){
            possibilities++;
        }
        if(possibilities > 1) {
            this.junctions.push(sp);
        }

        Pair nextPair;
        if(deeper){
            nextPair = new Pair(actualRow + 1, actualCol);
        } else if(left) {
            nextPair = new Pair(actualRow, actualCol-1);
        } else if(right) {
            nextPair = new Pair(actualRow, actualCol+1);
        } else if(up) {
            nextPair = new Pair(actualRow-1, actualCol);
        }  else {
            if(!this.junctions.empty()) {
                Pair lastJunction = this.junctions.pop();
                lastJunction.setNext(null);
                return dfs(lastJunction);
            }
            return sp;
        }
        sp.setNext(nextPair);
        return dfs(nextPair);
    }
}

/////////////////////

public class Main {

    public static void printArray(int[][] arr, int row, int col){
        for (int i = 0; i < row; i++) {
            for (int j = 0; j <col ; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int rowCount = 6;
        int colCount = 8;
        int[][] matrix = new int[rowCount][colCount];
        matrix[0] = new int[]{0, 1, 0, 1, 0, 0, 0, 1};
        matrix[1] = new int[]{0, 1, 0, 0, 0, 1, 0, 0};
        matrix[2] = new int[]{0, 0, 0, 1, 0, 1, 0, 0};
        matrix[3] = new int[]{0, 1, 1, 1, 1, 0, 0, 1};
        matrix[4] = new int[]{0, 0, 0, 0, 0, 1, 0, 0};
        matrix[5] = new int[]{0, 1, 0, 1, 0, 0, 1, 0};

        printArray(matrix, rowCount, colCount);
        Pair pair = new Pair(0,0);
        PathFinder finder = new PathFinder(matrix);
        Pair finish = finder.dfs(pair);
        if(finish.getRow() == rowCount-1 && finish.getCol() == colCount -1) {

            while( pair != null){
                System.out.println(pair.getRow()+","+pair.getCol());
                matrix[pair.getRow()][pair.getCol()] = 3;
                pair = pair.getNext();
            }
        } else {
            System.out.println("no path found");
        }
        printArray(matrix, rowCount, colCount);
    }
}