day14 二叉树的递归遍历和迭代遍历

文档讲解：代码随想录（代码随想录）

完成状态:  true

递归遍历

递归遍历三要素：                

1. 确定递归函数的参数和返回值

2. 确定终止条件

3. 确定单层递归的逻辑

二叉树的前序遍历(根左右)、中序遍历(左根右)、后序遍历(左右根)思路:

        leetcode上测试用例分别是空二叉树(case2)、含有一个节点的二叉树(case3)和正常的二叉树(case1)，这也是在启发我们，对于二叉树这种递归的结构，我们最终考虑的就是空二叉树怎么操作，一个节点的二叉树怎么操作，考虑清楚这两个的处理逻辑即可。因为二叉树这种结构最终会递归到一个节点的二叉树和空二叉树这两种情况。

// 前序遍历·递归·LC144_二叉树的前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);
        return result;
    }

    public void preorder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preorder(root.left, result);
        preorder(root.right, result);
    }
}
// 中序遍历·递归·LC94_二叉树的中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }

    void inorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inorder(root.left, list);
        list.add(root.val);             // 注意这一句
        inorder(root.right, list);
    }
}
// 后序遍历·递归·LC145_二叉树的后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }

    void postorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        postorder(root.left, list);
        postorder(root.right, list);
        list.add(root.val);             // 注意这一句
    }
}

迭代遍历

        迭代法使用非递归的方式来实现二叉树的前中后序遍历。我们可以使用栈的方式来实现二叉树的前中后序遍历。

前序遍历:

        每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。右孩子先入栈是因为这样出栈的时候才能保证是根左右的顺序。模拟代码逻辑更容易理解代码。

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

后序遍历：

        根左右-->根右左-->左右根 [前序遍历如何转化为后序遍历]

        这里学到了: 通过反转数组，可以得到与原来遍历顺序完全相反的遍历数组(如根左右已知，向想知道右左根，只需要直接反转前者的结果就好了)，不需要代码重新实现，只需要简单的反转数组就可以完成。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<>();
        if(root == null){
            return result;
        }

        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if(node.left != null){
                stack.push(node.left);
            }
            if(node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

中序遍历：

        中序遍历先访问的节点是根节点，但是处理的第一个节点却不是根节点，而是最左边的节点。前序遍历先访问的是根节点，处理的第一个节点也是根节点。那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

        指针：用来遍历节点

        栈：用来记录遍历过的元素，然后从栈里弹出元素进行处理(放入结果数组)

        中序遍历最开始的初始化很重要，即一路向左后在栈中存储的元素很重要，因为它们的存在，使得代码第一个弹出的节点一定是二叉树最左边的节点，从此之后代码可以按照左中右的处理逻辑依次顺序去处理。

        仔细看代码的逻辑，可以发现其实就是在确定栈中最开始的元素是谁后，先处理最小的那个二叉树的左中右逻辑，处理完之后再处理其上一个层次的较大的二叉树的左中右的逻辑，再去处理更上一个层次的二叉树的左中右的逻辑，知道处理完根节点，再处理右边二叉树，其逻辑和上述一致。代码写的处理逻辑和我们自己手动模拟中序处理的时候一样，不过是多了个指针去遍历元素将其存储在栈中而已。[上述是目前自己的理解，写的并不是非常通透，希望后续有了更深的理解后可以表达的更清晰。]

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<>();
        if(root == null){
            return result;
        }
        TreeNode cur = root; 
        while(cur != null || !stack.isEmpty()){
            if(cur != null){
                stack.push(cur);
                cur = cur.left;  // 左
            }else{
                cur = stack.pop();
                result.add(cur.val); // 中
                cur = cur.right; // 右
            }
        }
        return result;
    }
}