day 14|第六章 二叉树part01● 理论基础● 递归遍历 ● 迭代遍历● 统一迭代

● 递归遍历 

先序遍历，中序遍历，后序遍历，忘了思路是啥了，然后看了资料想起来了。

三个遍历主要区别在于res.add的位置，如果迭代的代码看不懂，你就看一下左程云算法讲解017【入门】二叉树及其三种序的递归实现_哔哩哔哩_bilibili

主要就是画图帮助你理解。

先序遍历：

总的来说就是，只要进去一个新结点，就打印

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        preOrder(root,res);
        return res;
    }
    public static void preOrder(TreeNode head, List<Integer> res){
        if(head == null){
            return;
        }
        res.add(head.val);
        preOrder(head.left,res);
        preOrder(head.right,res);
    }
}

中序遍历：

先进左结点，return回来以后再打印，然后再进右节点

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        inOrder(root,res);
        return res;
    }
        public static void inOrder(TreeNode head, List<Integer> res){
        if(head == null){
            return;
        }
        inOrder(head.left,res);
        res.add(head.val);
        inOrder(head.right,res);
    }
}

后序遍历：

先进左节点，return回来，再进右节点，return回来，打印

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        postOrder(root,res);
        return res;
    }
    public static void postOrder(TreeNode head, List<Integer> res){
        if(head == null){
            return;
        }
        postOrder(head.left,res);
        postOrder(head.right,res);
        res.add(head.val);
    }
}

 ● 迭代遍历（非递归遍历）

前序遍历：

总的来说就是把弹出来的第一个结点作为头节点，然后再压入右和左结点，那这样出来就是中左右了。

注意代码中空节点不入栈

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

    }
        return res;
}
}

后序遍历：

就是前序遍历的变形，先压左再压右，变成中右左，最后要调用Collections方法里面的reverse函数，倒序，变成左右中。Collections的常用方法，就在这个链接里面。菜鸟教程。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root!=null){
            TreeNode head = root;
            stack.push(head);
            while(!stack.isEmpty()){
                head = stack.pop();
                res.add(head.val);
                if(head.left!=null){
                    stack.push(head.left);
                }
                if(head.right!=null){
                    stack.push(head.right);
                }
            }
        }
        Collections.reverse(res);
        return res;
    }
}

中序遍历：

总是忘。。。。。。

之所以和前序遍历以及后续遍历不一样，是因为你的操作顺序和遍历的逻辑不同。

定义了一个指针，让这个指针去指向我们要处理的元素。首先让指针一直往左走，直到走不动了，弹出，然后往右走，走不动了，再弹出，左右都空了，最后弹出中间的结点。

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

        }
        return ans;
    }
        
}