树的算法--三种基本遍历

树的基础–遍历

本笔记的题目来源于花花酱整理的力扣题

中序遍历

中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。
如何理解这个遍历？
先看一个简单的二叉树遍历顺序

上面这张图的中序遍历的结果是[B,A,C],就是先遍历左边，然后是头，然后是右边，这是一颗小二叉树，那带入到大的中间页是这个道理。
下面看一个复杂的

我们可以把上面那棵树带入到下面这颗树当中，就是以下的图片

三个三个节点的看就和上面简单的二叉树吻合，如果少一颗树就需要重新排列，但是总体顺序是不变的。
同时如何判断是要找到的最后一个节点呢？
如果是最后一个节点，那他的左右节点就是空的，这是一个判断条件，这样我们就可以理解这段递归的代码
本代码基本模型参考94. 二叉树的中序遍历

class Solution {

    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        if(root == null){
            return list;
        }
        inorder(list, root);
        return list;
    }

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

使用迭代来代替递归（使用栈模拟递归）

使用迭代得到的代码是

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList();

        if(root == null){
            return list;
        }

        Stack<TreeNode> stack = new Stack();
        while(!stack.isEmpty() || root != null){
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            list.add(root.val);
            root = root.right;
        }

        return list;
    }
}

前序遍历

前序遍历和中序遍历相比，就是遍历一个就将一个送进去，本质来说就是中序遍历不需要倒装，先左边后右边这样的顺序遍历下去，图解如下图。笔记题目来源于力扣144. 二叉树的前序遍历

使用递归来实现的代码是

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList();

        if(root == null){
            return list;
        }

        dfs(root,list);
        return list;
    }

    public void dfs(TreeNode root, List<Integer> list){
        if(root == null){
            return ;
        }

        list.add(root.val);
        dfs(root.left, list);
        dfs(root.right, list);
    }
}

使用迭代实现，思想还是和中序遍历一样使用栈来模拟递归

这里的栈是如何模拟递归的呢？首先我们遍历一个元素就要将元素的值加入到list中，但是我们一直是往左遍历，后面需要返回将右边的元素值放入，所以先让栈存遍历的元素，然后遍历结束以后查看是否有右边的元素遗漏。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList();

        if(root == null){
            return list;
        }

        Stack<TreeNode> stack = new Stack();
        while(!stack.isEmpty() || root != null){
            while(root != null){
                stack.push(root);
                list.add(root.val);
                root = root.left;
            }

            root = stack.pop();
            root = root.right;
        }

        return list;
    }
}

###后序遍历
后序遍历首先遍历左子树，然后遍历右子树，最后访问根结点，在遍历左、右子树时，仍然先遍历左子树，然后遍历右子树，最后遍历根结点。
下列代码对应的是力扣：145. 二叉树的后序遍历
先示范一颗简单的二叉树：
就是先左边，后右边，最后是中间

再看一颗复杂的遍历顺序：

使用递归的代码是：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList();

        if(root == null){
            return list;
        }

        dfs(root,list);
        return list;
    }

    public void dfs(TreeNode root, List<Integer> list){
        if(root == null){
            return ;
        }

        dfs(root.left, list);
        dfs(root.right, list);
        list.add(root.val);
    }
}

使用迭代（用栈来模拟递归）

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList();

        if(root == null){
            return list;
        }

        Stack<TreeNode> stack = new Stack();
        TreeNode prev = null;
        while(!stack.isEmpty() || root != null){
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if(root.right == null || root.right == prev){
                list.add(root.val);
                prev = root;
                root = null;
            }else{
                stack.push(root);
                root = root.right;
            }
        }
        return list;
    }
}

这里就结束了二叉树的三种基本遍历，这里我们需要思考一个问题，为什么要使用迭代去代替递归呢？递归的代码基本上很好背，但是使用迭代可以帮助你更好的理解递归到底是怎么样一个逻辑