二叉树的遍历

1、先序遍历

1.1递归法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        preorder(root,res);
        return res;
    }
    public void preorder(TreeNode root,ArrayList<Integer> res){
        if(root==null){
            return;
        }
        res.add(root.val);
        preorder(root.left,res);
        preorder(root.right,res);  
    }
}

1.2迭代法（使用栈）

    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        
        //一开始就压入根节点，弹出节点，压入右左子树
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            //后续压入的节点可能为空
            if(node==null){
                continue;
            }else{
                res.add(node.val); 
            }
            stack.push(node.right);
            stack.push(node.left); 
        }
        return res;
    }

2、中序遍历

2.1递归法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        preorder(root,res);
        return res;
    }
    public void preorder(TreeNode root,ArrayList<Integer> res){
        if(root==null){
            return;
        }
        preorder(root.left,res);
        res.add(root.val);
        preorder(root.right,res);  
    }
}

2.2迭代法（使用栈）

    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        //从根节点开始，一直向左压入栈，如果为空，则弹出一个节点，压入右子树
        TreeNode node = root;
        while(node!=null || !stack.isEmpty()){
            if(node!=null){
                stack.push(node);
                node = node.left;
            }
            else{
                node = stack.pop();
                res.add(node.val);
                node = node.right;
            }
        }
        return res;
    }

3、后序遍历

3.1递归法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        preorder(root,res);
        return res;
    }
    public void preorder(TreeNode root,ArrayList<Integer> res){
        if(root==null){
            return;
        }
        preorder(root.left,res);
        preorder(root.right,res);  
        res.add(root.val);
    }
}

3.2迭代法（使用栈）

    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        
        //一开始就压入根节点，弹出节点，压入右左子树
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            //后续压入的节点可能为空
            if(node==null){
                continue;
            }else{
                res.add(node.val); 
            }
            stack.push(node.left); 
            stack.push(node.right);
            
        }

        //中右左，反转一下
        Collections.reverse(res);
        return res;
    }

4、层次遍历

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList();
        队列，存储一层弹出一层
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        if(root!=null) queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> col = new ArrayList();

            while(size>0){
                TreeNode temp = queue.poll();
                size--;
                col.add(temp.val);
                if(temp.left!=null){
                    queue.add(temp.left);
                }
                if(temp.right!=null){
                    queue.add(temp.right);
                }
            }
            res.add(col);
        }
        return res;

    }