DFS and BFS solution to graph tree traversal (pure code)

Dfs and bfs traversal of tree graph

BFS traversal of binary tree

/**
 * 二叉树的遍历
 */
public class Test {
    static TreeNode root;

    static {
        //构造二叉树[6,2,8,0,4,7,9,null,null,3,5]
        root = new TreeNode(1);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(8);
        TreeNode node3 = new TreeNode(0);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(7);
        TreeNode node6 = new TreeNode(9);
        TreeNode node7 = new TreeNode(3);
        TreeNode node8 = new TreeNode(5);
        root.left = node1;
        root.right = node2;
        node1.left = node3;
        node1.right = node4;
        node2.left = node5;
        node2.right = node6;
        node4.left = node7;
        node4.right = node8;
    }

    public static void main(String[] args) {
        bfs(root);
    }

    public static void bfs(TreeNode root) {
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        if (root != null) {
            nodeQueue.add(root);
        }
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.poll();
            if (node.left != null) {
                nodeQueue.add(node.left);
            }
            if (node.right != null) {
                nodeQueue.add(node.right);
            }
            System.out.print(node.value + " ");
        }

    }
}

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int value) {
        this.value = value;
    }
}

Dfs traversal of binary tree

/**
 * 二叉树的遍历
 */
public class Test {
    static TreeNode root;

    static {
        //构造二叉树[6,2,8,0,4,7,9,null,null,3,5]
        root = new TreeNode(6);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(8);
        TreeNode node3 = new TreeNode(0);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(7);
        TreeNode node6 = new TreeNode(9);
        TreeNode node7 = new TreeNode(3);
        TreeNode node8 = new TreeNode(5);
        root.left = node1;
        root.right = node2;
        node1.left = node3;
        node1.right = node4;
        node2.left = node5;
        node2.right = node6;
        node4.left = node7;
        node4.right = node8;
    }

    public static void main(String[] args) {
        dfsByRecursion(root);
    }


    //dfs通过递归遍历(优先使用)
    public static void dfsByRecursion(TreeNode root) {
        if (root != null) {
            System.out.print(root.value + " ");
            if (root.left != null) {
                dfsByRecursion(root.left);
            }
            if (root.right != null) {
                dfsByRecursion(root.right);
            }
        }
    }

    //dfs通过栈遍历
    public static void dfsByStack(TreeNode root) {
        Stack<TreeNode> nodeQueue = new Stack<>();
        if (root != null) {
            nodeQueue.push(root);
        }
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.pop();
            if (node.right != null) {
                nodeQueue.add(node.right);
            }
            if (node.left != null) {
                nodeQueue.add(node.left);
            }
            System.out.print(node.value + " ");
        }
    }
}

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int value) {
        this.value = value;
    }
}

Dfs traversal of multi-tree

/**
 * 多叉树的遍历
 */
public class Test2 {
    static TreeNode root;

    static {
        //构造多叉树[6,2,5,4,3,1,7,8,9]
        root = new TreeNode(6);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(5);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(3);
        TreeNode node5 = new TreeNode(1);
        TreeNode node6 = new TreeNode(7);
        TreeNode node7 = new TreeNode(8);
        TreeNode node8 = new TreeNode(9);
        List<TreeNode> list1 = new ArrayList<>();
        list1.add(node1);
        list1.add(node2);
        list1.add(node3);
        root.nodes = list1;
        List<TreeNode> list2 = new ArrayList<>();
        list2.add(node4);
        list2.add(node5);
        node1.nodes = list2;
        List<TreeNode> list3 = new ArrayList<>();
        list3.add(node6);
        node2.nodes = list3;
        List<TreeNode> list4 = new ArrayList<>();
        list4.add(node7);
        node3.nodes = list4;
        List<TreeNode> list5 = new ArrayList<>();
        list5.add(node8);
        node7.nodes = list5;
    }

    public static void main(String[] args) {
        dfsByStack(root);
    }


    //dfs通过递归遍历(优先使用)
    public static void dfsByRecursion(TreeNode root) {
        if (root != null) {
            System.out.print(root.value + " ");
            List<TreeNode> nodes = root.nodes;
            if (nodes != null) {
                for (TreeNode node : nodes) {
                    dfsByRecursion(node);
                }
            }

        }
    }

    //dfs通过栈遍历
    public static void dfsByStack(TreeNode root) {
        Stack<TreeNode> nodeQueue = new Stack<>();
        if (root != null) {
            nodeQueue.push(root);
        }
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.pop();
            List<TreeNode> nodes = node.nodes;
            if (nodes != null) {
                for (TreeNode node1 : nodes) {
                      nodeQueue.add(node1);
                }
            }
            System.out.print(node.value + " ");
        }
    }
}

class TreeNode {
    int value;
    List<TreeNode> nodes;

    TreeNode(int value) {
        this.value = value;
    }
}

BFS traversal of multi-tree

/**
 * 多叉树的遍历
 */
public class Test3 {
    static TreeNode root;

    static {
        //构造多叉树[6,2,5,4,3,1,7,8,9]
        root = new TreeNode(6);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(5);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(3);
        TreeNode node5 = new TreeNode(1);
        TreeNode node6 = new TreeNode(7);
        TreeNode node7 = new TreeNode(8);
        TreeNode node8 = new TreeNode(9);
        List<TreeNode> list1 = new ArrayList<>();
        list1.add(node1);
        list1.add(node2);
        list1.add(node3);
        root.nodes = list1;
        List<TreeNode> list2 = new ArrayList<>();
        list2.add(node4);
        list2.add(node5);
        node1.nodes = list2;
        List<TreeNode> list3 = new ArrayList<>();
        list3.add(node6);
        node2.nodes = list3;
        List<TreeNode> list4 = new ArrayList<>();
        list4.add(node7);
        node3.nodes = list4;
        List<TreeNode> list5 = new ArrayList<>();
        list5.add(node8);
        node7.nodes = list5;
    }

    public static void main(String[] args) {
        bfs(root);
    }

    public static void bfs(TreeNode node) {
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        if (node != null) {
            nodeQueue.add(node);
        }

        while (!nodeQueue.isEmpty()) {
            TreeNode treeNode = nodeQueue.poll();
            List<TreeNode> nodes = treeNode.nodes;
            if (nodes != null) {
                for (TreeNode node1 : nodes) {
                    nodeQueue.add(node1);
                }
            }
            System.out.print(treeNode.value + " ");
        }

    }

}

class TreeNode {
    int value;
    List<TreeNode> nodes;

    TreeNode(int value) {
        this.value = value;
    }
}

traversal of graph by bfs

/**
 * 图的遍历
 */
public class Test3 {
    static TreeNode root;

    static {
        //构造图[6,1,4,2,8,5,3,7]
        root = new TreeNode(6);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(3);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(5);
        TreeNode node5 = new TreeNode(7);
        TreeNode node6 = new TreeNode(1);
        TreeNode node7 = new TreeNode(8);
        List<TreeNode> list1 = new ArrayList<>();
        list1.add(node1);
        list1.add(node3);
        list1.add(node6);
        root.nodes = list1;
        List<TreeNode> list2 = new ArrayList<>();
        list2.add(node2);
        node1.nodes = list2;
        List<TreeNode> list3 = new ArrayList<>();
        list3.add(node4);
        node3.nodes = list3;
        List<TreeNode> list5 = new ArrayList<>();
        list5.add(node7);
        node6.nodes = list5;
        List<TreeNode> list6 = new ArrayList<>();
        list6.add(node5);
        node4.nodes = list6;
        node7.nodes = list6;
    }

    public static void main(String[] args) {
        bfs(root);
    }

    public static void bfs(TreeNode node) {
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        if (node != null) {
            nodeQueue.add(node);
        }
        Set<TreeNode> visitedNodes = new HashSet<>();
        while (!nodeQueue.isEmpty()) {
            TreeNode treeNode = nodeQueue.poll();
            visitedNodes.add(treeNode);
            List<TreeNode> nodes = treeNode.nodes;
            if (nodes != null) {
                for (TreeNode node1 : nodes) {
                    if (!visitedNodes.contains(node1)) {
                        nodeQueue.add(node1);
                    }
                }
            }
        }
        visitedNodes.forEach(it -> System.out.print(it.value + " "));
    }

}

class TreeNode {
    int value;
    List<TreeNode> nodes;

    TreeNode(int value) {
        this.value = value;
    }
}

dfs traversal of graph

/**
 * 图的遍历
 */
public class Test3 {
    static TreeNode root;

    static {
        //构造图[6,1,4,2,8,5,3,7]
        root = new TreeNode(6);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(3);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(5);
        TreeNode node5 = new TreeNode(7);
        TreeNode node6 = new TreeNode(1);
        TreeNode node7 = new TreeNode(8);
        List<TreeNode> list1 = new ArrayList<>();
        list1.add(node1);
        list1.add(node3);
        list1.add(node6);
        root.nodes = list1;
        List<TreeNode> list2 = new ArrayList<>();
        list2.add(node2);
        node1.nodes = list2;
        List<TreeNode> list3 = new ArrayList<>();
        list3.add(node4);
        node3.nodes = list3;
        List<TreeNode> list5 = new ArrayList<>();
        list5.add(node7);
        node6.nodes = list5;
        List<TreeNode> list6 = new ArrayList<>();
        list6.add(node5);
        node4.nodes = list6;
        node7.nodes = list6;
    }

    public static void main(String[] args) {
        dfsByStack(root);
    }

    //dfs通过递归遍历(优先使用)
    public static void dfsByRecursion(TreeNode root) {
        if (root != null) {
            System.out.print(root.value + " ");
            List<TreeNode> nodes = root.nodes;
            Set<TreeNode> vistedNodes = new HashSet<>();
            vistedNodes.add(root);
            if (nodes != null) {
                for (TreeNode node : nodes) {
                    if (!vistedNodes.contains(node)) {
                        vistedNodes.add(node);
                        dfsByRecursion(node);
                    }
                }
            }
        }
    }

    //dfs通过栈遍历
    public static void dfsByStack(TreeNode root) {
        Stack<TreeNode> nodeQueue = new Stack<>();
        if (root != null) {
            nodeQueue.push(root);
        }
        Set<TreeNode> vistedNodes = new HashSet<>();
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.pop();
            vistedNodes.add(node);
            List<TreeNode> nodes = node.nodes;
            if (nodes != null) {
                for (TreeNode node1 : nodes) {
                    if (!vistedNodes.contains(node1)) {
                        nodeQueue.add(node1);
                    }
                }
            }
            System.out.print(node.value + " ");
        }
    }
}

class TreeNode {
    int value;
    List<TreeNode> nodes;

    TreeNode(int value) {
        this.value = value;
    }
}