二叉树前中后遍历 递归 迭代

1.二叉树前序遍历 递归

class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root!=null){
            list.add(root.val);
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
            return list;
    }
}

迭代 先把根节点放入栈中  再放入 右节点 然后左节点。因为左节点先出栈。根左右。 

 public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(Integer.valueOf(node.val));
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
        return res;
    }

2.后序  递归

ArrayList<Integer> res = new ArrayList<Integer>();
    public List<Integer> postorderTraversal(TreeNode root) {
    if(root!=null){
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        res.add(root.val);
    }
    return res;
    }

迭代：树的后序遍历“左右根”，先序遍历是“根左右”，我们可以把树的先序代码改成根右左（在代码中体现就是更改左右子节点入栈顺序），最后将根右左的遍历顺序反转。

举个例子
1
/ \
2 3
/ \ /
4 5 6
根左右：124536
根右左：136254
左右根：452631

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<Integer>();
    if(root==null){
        return res;
    }
    Stack<TreeNode> stack =new Stack<TreeNode>();
    Stack<TreeNode> temp=new Stack<TreeNode>();
    stack.push(root);
    while(!stack.isEmpty()){
        TreeNode node = stack.pop();
        temp.push(node);
        if(node.left!=null){
            stack.push(node.left);  //node.left  root.left会一直死循环 
        }
        if(node.right!=null){
            stack.push(node.right);
        }
    }
    while(!temp.isEmpty()){
        res.add(temp.pop().val);
    }
    return res;
    }

3.中序 递归

 List<Integer> list = new ArrayList<Integer>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root!=null){
            inorderTraversal(root.left);
            list.add(root.val);
            inorderTraversal(root.right);
        }
    return list;
    }

迭代

 //1.一直往左节点走
 //2.最左的节点入栈
 //3.栈顶元素出栈 判断有没有左节点 没有出栈  判断右节点 右节点入栈 
class Solution {
    
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        if(root==null)
            return list;
        TreeNode node = root;
        while(node!=null||!stack.isEmpty()){
            while(node!=null){
                stack.push(node);
                node=node.left;
            }
            node = stack.pop();
            list.add(node.val);
            node= node.right;
        }
        return list;
    }
}

if(node.right!=null){

                node= node.right;

            }就错了