深度优先，广度优先

深度优先遍历DFS

递归

    List<TreeNode> treeNodeList = new ArrayList<>();
    public List<TreeNode> dfs(TreeNode root) {
        
        if (root == null) {
            return null;
        }
        treeNodeList.add(root);
        //System.out.print(root.value+" ");
        dfsRec(root.left);
        dfsRec(root.right);
        return treeNodeList;
    }

非递归      用栈实现
    public List<TreeNode> dfs(TreeNode root) {
        List<TreeNode> treeList = new ArrayList<>();
        if(root==null) {
            return  null;
        }

        Stack<TreeNode> myStack=new Stack<>();
        myStack.add(root);

        while(!myStack.isEmpty()) {
            TreeNode node=myStack.pop();    //弹出栈顶元素
            //System.out.print(node.value+" ");
            treeList.add(node);
            //向栈中先压入右子树，在压入左子树。这样出栈时，先出左子树再出右子树.也就是,先遍历左边，后遍历右边
            if(node.right!=null) {
                myStack.push(node.right);
            }
            if(node.left!=null) {
                myStack.push(node.left);
            }
        }
        return treeList;
    }

广度优先遍历BFS

public List<TreeNode> bfs(TreeNode root) {
        treeList = new ArrayList<>();
        if(root == null){
            return null;
        }

        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll(); 
            treeList.add(node);
            //System.out.print(node.value);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
        return treeList;
    }