深度优先遍历和广度优先遍历

1.时间复杂度

对于图，深度优先搜索的时间复杂度和广度优先搜索的时间复杂度是一样的，邻接矩阵存储为O(n^2)， 邻接表存储为O(n+e) ；

对于树，深度优先搜索的时间复杂度和广度优先搜索的时间复杂度是一样的，都是O(V),V是树的节点数。

2.基于树的 代码实现

public class DepthFirstTraversal {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(7);
//        preOrderTraverse2(root);
        levelTraverse(root);
    }
//    1.先序遍历 递归实现
    public static void preOrderTraverse1(TreeNode root){
        if(root==null)return;
        System.out.print(root.val+" ");
        preOrderTraverse1(root.left);
        preOrderTraverse1(root.right);
    }
//    2.先序遍历 非递归实现---栈
    public static void preOrderTraverse2(TreeNode root) {
        if(root==null)return;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            System.out.print(node.val+" ");
            if(node.right!=null) stack.push(node.right);
            if(node.left!=null) stack.push(node.left);
        }
    }
//    3.层次遍历
    public static void levelTraverse(TreeNode root) {
        if(root==null) return;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            System.out.print(node.val+" ");
            if(node.left!=null) queue.offer(node.left);
            if (node.right!=null) queue.offer(node.right);
        }
    }
}