刷了360多道算法题，我终于顿悟了它的真谛

public int def(int x, int y ,int step){
    if(递归出口/达到目标状态){
        //进行对应操作
        return 0;
    }
    for (int i = 0; i < n; i++) {
        //遍历剩下的所有的情况
        if(visit[i]==0){
            //未访问
            x = 下一步更新;
            y = 下一步更新;
            visit[i] = 1;
            def(x,y,step);
            visit[i] = 0;  //记得回溯还原
        }
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

public class OdTest04 {
    static Node rootNode = null;
    static int removeValue = 0;
    // 剩余的目录ID
    static StringBuilder builder = new StringBuilder();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 父子关系表的长度m
        int m = Integer.valueOf(sc.nextLine());

        // m个父子关系
        List<int[]> treeList = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            int[] treeArr = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            if(treeArr[1] == 0){
                rootNode = new Node(treeArr[0]);
                // 拼接二叉树根ID
                builder.append(treeArr[0]).append(" ");
                continue;
            }
            treeList.add(treeArr);
        }

        // 待删除的ID
        removeValue = Integer.valueOf(sc.nextLine());

        /**
         * 遍历m个父子关系，拼接成二叉树，拼接剩余的目录ID
         */
        dfs(treeList,rootNode);
        builder.deleteCharAt(builder.length() - 1);
        // 输出符合条件的目录ID
        System.out.println(builder);
    }

    /**
     * 深度优先搜索dfs
     * @param treeList
     * @param node
     */
    private static void dfs(List<int[]> treeList, Node node){
        /**
         * 如果剩余的父子关系集合treeList为0，则不需要再进行dfs
         * 如果要dfs的node节点是null，则不需要再寻找其左右子节点
         */
        if(treeList.size() == 0 || node == null){
            return;
        }
        for (int i = 0; i < treeList.size(); i++) {
            // 父子关系
            int[] treeArr = treeList.get(i);
            // 如果该关系的父节点是value
            if(treeArr[1] == node.value){
                // 如果该父节点不是待移除的ID
                if(removeValue != node.value) {
                    int sonValue = treeArr[0];
                    // 如果该子节点不是待移除的ID
                    if(removeValue != sonValue){
                        // 拼接成二叉树
                        if(node.left == null){
                            node.left = new Node(sonValue);
                        }else if(node.right == null){
                            node.right = new Node(sonValue);
                        }
                        // 拼接剩余的目录ID
                        builder.append(sonValue).append(" ");
                    }
                }
                // 移除满足条件的父子关系
                treeList.remove(treeArr);
                // 父子关系集合treeList移除某节点，treeList长度-1，下一个坐标i也应该-1
                i--;
            }
        }

        // 在剩余的父子关系集合treeList中寻找父节点是node.left的节点，进行树的再次拼接
        dfs(treeList,node.left);
        // 在剩余的父子关系集合treeList中寻找父节点是node.right的节点，进行树的再次拼接
        dfs(treeList,node.right);
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.

6
 4   8
5 7 9  10
   11
1.
2.
3.
4.

6
 4   5
5 5 5  10
   11
1.
2.
3.
4.