Day13|二叉树的递归遍历，迭代遍历

 看黑马这个视频有指导作用

基础数据结构-102-二叉树-深度优先遍历_哔哩哔哩_bilibili

递归：一条自调用，可以看做是一条线的流程图；两条自调用，是二叉树状的流程图

使用递归的条件，第一级变量与第n级变量的的执行行为是一样的

可取n=1与n=3做流程图

递归：更新节点与更新int的递归，画递归树状图或递归线性图，二叉树本来就是树状的较易理解

前序遍历：对于一个三角 中左右输出，直接进入最后一个子叶节点的函数中体会递归流程

/**
 * 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 {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preOrder(root , res);
        return res;
    }
    public void preOrder(TreeNode root , List res){
       if(root == null){
           return;
       }
        res.add(root.val);
        preOrder(root.left , res);
        preOrder(root.right , res);
    }
}

后序遍历，对于一个三角 左右中输出

/**
 * 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 {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preOrder(root , res);
        return res;
    }
    public void preOrder(TreeNode root , List res){
       if(root == null){
           return;
       }
        preOrder(root.left , res);
        preOrder(root.right , res);
        res.add(root.val);
    }
}

中序遍历，对于一个三角 左中右输出

/**
 * 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 {
    public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
        preOrder(root , res);
        return res;
    }
    public void preOrder(TreeNode root , List res){
       if(root == null){
           return;
       }
        preOrder(root.left , res);
        res.add(root.val);
        preOrder(root.right , res);
    }
}

迭代法：

基础数据结构-102-二叉树-深度优先遍历_哔哩哔哩_bilibili黑马这个视频很好，用的就是黑马模版

前序是最简单的，在深度遍历左枝时就输出，左枝遍历到底，构成中左右逆时针三角

中序次简单，先深到左枝底部null，回溯的时候输出，构成左中右顺时针三角

回溯是直接把cur跳到父节点的right上，不是回溯到父节点上

cur到null时只会到另一个null或父节点的right节点上。

体会用词深度遍历，想象成副对角线一条一条，自上而下积分，自左而右积分

后序遍历佐能体现，深度自上而下再自左而右 

/**
 * 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 {
    public List<Integer> postorderTraversal(TreeNode root) {
        TreeNode cur = root;
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> res = new ArrayList<>();
        TreeNode pop = null;
        while(cur != null || !stack.empty()){
            if(cur != null){
                stack.push(cur);
                cur = cur.left;
            }else {
                TreeNode peek = stack.peek(); 
                if(peek.right == null){
                    pop = stack.pop();
                    res.add(pop.val);
                }else if(peek.right == pop){
                    pop = stack.pop();
                    res.add(pop.val);
                }else if(peek.right != null && peek.right != pop){
                    cur = peek.right;
                }
            }
               
        }
        return res;
    }
}