前中后序遍历二叉树(迭代)

前序遍历

    public List<Integer> preorderTraversal(TreeNode root) {
        Stack<TreeNode> stack=new Stack<>(); 
        List<Integer> res=new ArrayList<>();
        if(root==null) return res;
        stack.push(root);

        while(!stack.isEmpty()){
           TreeNode temp=stack.pop();
            if(temp.right!=null) stack.push(temp.right); 
            if(temp.left!=null) stack.push(temp.left);
            res.add(temp.val); 
        } 
       return res;
    }

后序遍历

 public List<Integer> postorderTraversal(TreeNode root) {
         Stack<TreeNode> stack = new Stack<>();
        ArrayList<Integer> list=new ArrayList<>();
        if(root==null) return list;
        stack.push(root);
        while(!stack.isEmpty()){ 
            TreeNode node=stack.pop();
                // list.polllast(node.val);   
            list.add(0,node.val);
            if(node.left!=null){
                stack.push(node.left);
            } 
            if(node.right!=null){
                stack.push(node.right);
            }   
        }  
              return list;
    }

//中序遍历

  public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res=new ArrayList<>();
        Stack<TreeNode> stack=new Stack<>();

        if(root==null) return res; 
        while(!stack.isEmpty()||root!=null){ 
            if(root!=null) {
                stack.add(root);
                root=root.left;
            }else{
                TreeNode temp=stack.pop();
                res.add(temp.val);
                root=temp.right;
            }
        } 
        return res;
    }

//中序遍历(递归)

public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }