【Java】————二叉树的前中后序遍历（递归和迭代）

⭐️引言⭐️
大家好，今天给大家分享二叉树的前中后序遍历，二叉树是非常非常重要的基础结构，其中它的前中后序三种遍历又显得尤为基础和重要。话不多说我们看题。

⭐️1.二叉树的前序遍历(根->左->右)

1.递归解法

//用来放答案的集合，设为全局变量
    List<Integer> ret = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root == null) {
            return ret;
        }
        ret.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
        return ret;
    }

2.迭代解法

//用来存放答案的list
    List<Integer> list = new ArrayList<>();
    //用一个栈来 存储 元素
    Stack<TreeNode> stack = new Stack<>();
    public List<Integer> preorderTraversal1(TreeNode root) {
        if(root == null) return list;
        //如果头节点不为空就放入
        stack.push(root);
        while (!stack.isEmpty()) {
            //如果栈不为空 就弹出栈顶元素
            TreeNode node = stack.pop();
            //弹出元素 入list
            list.add(node.val);
            //判断 弹出元素 左右是否为空 不是 入栈
            if(node.right != null) {
                stack.push(node.right);
            }
            if(node.left != null) {
                stack.push(node.left);
            }
        }
        //最后返回 list
        return list;
    }

注意: 为什么先把右子节点入栈再入左子节点呢？因为栈是先进后出，前序遍历是根左右，为了让左节点先出所以得先放入右子节点。

⭐️2.二叉树的中序遍历（左->根->右）

1.递归解法

    //用来存放答案的list
    List<Integer> list1 = new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root == null) return list1;
        inorderTraversal(root.left);
        list1.add(root.val);
        inorderTraversal(root.right);
        return list1;
    }

2.迭代解法

   //用来存放答案
    List<Integer> list2 = new ArrayList<>();
    //栈来存放元素
    Stack<TreeNode> stack1 = new Stack<>();
    public List<Integer> inorderTraversal1(TreeNode root) {
        if(root == null) return list2;
        stack1.push(root);
        while (root != null || !stack1.isEmpty()) {
            //用一个while循环把左节点先全部放入栈中
            while (root != null) {
                stack1.push(root);
                root = root.left;
            }
            //左节点全部入栈后 再弹出
            root = stack1.pop();
            //弹出的节点 放入 list中
            list.add(root.val);
            //再去处理右节点
            root = root.right;
        }
        return list1;
    }

注意：~我们的中序遍历是先处理左节点完后才能一个个倒退回来处理根节点。也就是说需要先将所有的左子节点放入栈后再一个个出栈，然后才能处理根节点和右节点。

⭐️3.二叉树的后续遍历（左->右->根）

1.递归解法

 //用来存放答案
    List<Integer> ret2 = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root == null) return ret2;
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        ret2.add(root.val);
        return ret2;
    }

2.迭代解法
后序的迭代就比较有趣了，我们都知道我们写了前序的遍历顺序是根左右，在里面我们有个入栈的步骤，是先入右再入左，如果我们先入左再入右是不是遍历顺序就是中右左，这时我们把得到的答案list整个反过来，是不是就变成了左右中`，也就是我们的后序遍历了。

//用来存放答案的list
    List<Integer> list=new ArrayList<>();
    //用来当栈
    Deque<TreeNode> statck=new ArrayDeque<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root==null) return list;
        statck.push(root);
        while(!statck.isEmpty()){
            TreeNode node=statck.pop();
            list.add(node.val);
            //先放左再放右
            if(node.left!=null){
                statck.push(node.left);
            }
            if(node.right!=null){
                statck.push(node.right);
            } 
        }
        //反转链表
        Collections.reverse(list);
        return list;
    }