【代码随想录二刷】day14 | 二叉树的前序、中序、后序遍历 & 递归遍历 & 迭代遍历

二刷主要记录理解不一样的题

一刷地址：day14

今日题目：简单

递归遍历：模板

主要看中结点的处理逻辑的位置：

• 前序：中 - 左 - 右
• 中序：左 - 中 - 右
• 后序：左 - 右 - 中

/**
 * Definition for a binary tree node.
 * 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 {
    List<Integer> res;
    public List<Integer> traversal(TreeNode root) {
        res = new ArrayList<>();
        preorder(root); 
        // inorder(root);
        // postorder(root);
        return res;
    }

	// 中结点处理逻辑位置在前是前序： 中 左 右
    void preorder(TreeNode root){
        if(root == null) return;
        res.add(root.val); 
        preorder(root.left);
        preorder(root.right);
    }
	
	// 中结点处理逻辑位置在中是中序： 左 中 右
    void inorder(TreeNode root){
       if(root == null) return;
       inorder(root.left);
       res.add(root.val);
       inorder(root.right);
    }
    // 中结点处理逻辑位置在后是后序：左 右 中
    void postorder(TreeNode root){
        if(root == null) return;
        postorder(root.left);
        postorder(root.right);
        res.add(root.val);
    }
}

迭代遍历：模板

递归相当于是栈遍历，迭代就反向操作

主要也是看 中结点 的处理逻辑 ：

前序：中 左 右 -> 右 左 中

class Solution {
    public List<Integer> traversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> st = new LinkedList<>();
        if(root != null) st.push(root);
        // 中 左 右 -> 右 左 中
        while(!st.isEmpty()){
            TreeNode mid = st.poll();
            if(mid != null){
                if(mid.right != null) st.push(mid.right);
                if(mid.left != null) st.push(mid.left);
                st.push(mid);
                st.push(null);
            }else{
            	// 中结点处理逻辑
                TreeNode node = st.poll();
                res.add(node.val);
            }
        }
        return res;
    }
}

中序：左 中 右 -> 右 中 左

class Solution {
    List<Integer> res;
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> st = new LinkedList<>();
        if(root != null) st.push(root);
        // 左 中 右 -> 右 中 左
        while(!st.isEmpty()){
            TreeNode mid = st.poll();
            if(mid != null){
                if(mid.right != null) st.push(mid.right);
                st.push(mid);
                st.push(null);
                if(mid.left != null) st.push(mid.left);
            }else{
                TreeNode node = st.poll();
                res.add(node.val);
            }
        }
        return res;
    }
}

后序：左 右 中 -> 中 右 左

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> st = new LinkedList<>();
        if(root != null) st.push(root);
        // 左 右 中 -> 中 右 左
        while(!st.isEmpty()){
            TreeNode mid = st.poll();
            if(mid != null){
                st.push(mid);
                st.push(null);
                if(mid.right != null) st.push(mid.right);
                if(mid.left != null) st.push(mid.left);               
            }else{
                TreeNode node = st.poll();
                res.add(node.val);
            }
        }
        return res;
    }
}