留言笔记不小心被自己删了（问了客服，也不能找回了），补上：

1. 可以用深度遍历，每次遍历到三度人脉，再回溯到上层节点，直到所有的三度人脉都找完。

2. 将迷宫的每个岔口记为"顶点"，岔口之间的路径记为"边"，可以用邻接表存储，也可以用邻接矩阵存储。但是个人感觉，像那种标准的方格迷宫，适合用邻接矩阵存储，因为稠密度比较高。

我基础非常差，写了老半天的非递归深度优先遍历，还请各位看看写的对不对

/**
     * 深度优先遍历
     *
     * @param start 路径查找起始点
     * @param end 路径查找终点
     */
    public void depthFirstSearch(int start, int end) {
        if (start == end) {
            return;
        }
        // 定义一个visited数组，保存是否访问过
        boolean[] visited = new boolean[v];
        // 定义一个栈，作为一个后进先出栈，保存已访问，但相连节点未访问的节点
        Stack<Integer> stack = new Stack<Integer>();
        // 先将start压入栈中
        visited[start] = true;
        stack.push(start);
        while (!stack.isEmpty()) {
            // 取出，但不出栈
            int step = stack.peek();
            // 标识位，标识step节点下的邻接节点中是否有未走过的节点
            boolean hasNoVisited = false;
            for (int i = 0; i < adj[step].size(); i++) {
                int nextStep = adj[step].get(i);
                // 存在未走过节点，则flag = true,将nextStep压入栈中，继续前行
                if (visited[nextStep] == false) {
                    hasNoVisited = true;
                    visited[nextStep] = true;
                    stack.push(nextStep);
                    if (nextStep == end) {
                        return;
                    }
                    break;
                }
            }
            // 邻接的节点都是已走过的，则出栈
            if (hasNoVisited == false) {
                stack.pop();
            }
        }
        // 遍历输出栈中存储的节点，即路径
        if (!stack.isEmpty()) {
            Iterator<Integer> it = stack.iterator();
            while (it.hasNext()) {
                System.out.print(it.next() + " ");
            }
        }
    }