二叉树的前中后序遍历

1、二叉树的相关概念

二叉树的概念参考: 二叉树_百度百科

2、二叉树的前中后序遍历

对于如下二叉树：

• 前序遍历A-B-D-F-G-H-I-E-C（根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面 ）
• 中序遍历F-D-H-G-I-B-E-A-C（根在中，从左往右，一棵树的左子树永远在根前面，根永远在右子树前面）
• 后序遍历F-H-I-G-D-E-B-C-A（根在后，从左往右，一棵树的左子树永远在右子树前面，右子树永远在根前面）
  这里前中后，其实指的就是中间节点的遍历顺序，记住前中后序指的就是中间节点的位置就可以了。

3、代码实现

二叉树的定义

 // 二叉树的定义
public class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode() {}
     TreeNode(int val) { this.val = val; }
     TreeNode(int val, TreeNode left, TreeNode right) {
         this.val = val;
         this.left = left;
         this.right = right;
     }
 }

前序遍历

// 递归实现
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preorder(root,res);
        return res;
    }

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

// 遍历实现
// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> st = new Stack<>();
        if(root == null){
            return res;
        }
        st.push(root);
        while(!st.isEmpty()){
            TreeNode node =  st.pop();
            res.add(node.val);
            if(node.right != null){
                st.push(node.right);
            }
            if(node.left != null){
                st.push(node.left);
            }
        }
        return res;
    }
}

中序遍历

// 递归实现
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }

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

// 遍历实现
// 中序遍历顺序: 左-中-右 入栈顺序： 左-右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> st = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !st.isEmpty()){
            if(cur != null){
                st.push(cur);
                cur = cur.left;
            }else{
                cur = st.pop();
                res.add(cur.val);
                cur = cur.right;
            }
        }
        return res;
    }
}

后序遍历

// 递归实现
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }

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

// 遍历实现
// 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> st = new Stack<>();

        if(root == null){
            return res;
        }
        st.push(root);
        while(!st.isEmpty()){
            TreeNode node = st.pop();
            res.add(node.val);
            if(node.left != null){
                st.push(node.left);
            }
            if(node.right != null){
                st.push(node.right);
            }
        }
        // 翻转
        Collections.reverse(res);
        return res;
    }
}