数据结构-二叉树的遍历

深度优先遍历

前序遍历

“根左右”：从树根开始，先遍历根节点，继续递归遍历左子树，再递归遍历右子树。
前序遍历结果的第一个节点一定是当前二叉树的根节点。

递归实现

    // 现在的遍历就是输出节点的值
    public void preOrder(TreeNode root) {
        // 1.base case
        if (root == null) {
            return;
        }
        // 根
        System.out.print(root.val + " ");
        // 左
        preOrder(root.left);
        preOrder(root.right);
    }

循环实现

前序遍历的循环实现：

public class Num144_PreorderTraversal {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        //用栈实现
        Deque<TreeNode>stack = new ArrayDeque<>();
        //先压入根节点
        stack.push(root);
        //当栈为空，所有节点遍历完毕
        while (!stack.isEmpty()){
            //先弹出根
            TreeNode node = stack.poll();
            //保存当前弹出的值
            result.add(node.val);
            //前序遍历用栈实现要先压入右子树，再压入左子树
            //先压入右树
            if(node.right!=null){
                stack.push(node.right);
            }
            //再压入左树
            if(node.left!=null){
                stack.push(node.left);
            }
        }
        return result;
    }
}

中序遍历

“左根右”：先递归的访问左子树，然后访问根节点，再递归的访问右子树。

递归实现

public void inOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        // 先左子树的中序
        inOrder(root.left);
        // 根
        System.out.print(root.val + " ");
        // 再右子树的中序
        inOrder(root.right);
    }

循环实现

中序遍历的循环实现：

public class Num94_InOrderTraversal {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        Deque<TreeNode> stack = new ArrayDeque<>();
        TreeNode cur = root;
        while(cur!=null || !stack.isEmpty()){
            //左
            //先不断地向左走到头
            while(cur!=null){
                //将cur压入栈中
                stack.push(cur);
                cur = cur.left;
            }
            //走完这个循环此时cur走到了null，此时栈顶就存放了第一个要输出的节点
            //当前节点就是第一个左树为空的节点
            //根
            cur = stack.pop();
            result.add(cur.val);
            //继续访问右子树
            //右
            cur = cur.right;
        }
        return result;
    }
}

注意：在中序遍历中，当每个节点第二次访问，此时可以输出该节点的值，因为以这个节点为根的左树已经访问完毕！

后序遍历

“左右根”：先递归的访问左子树，然后递归的访问右子树，最后访问根节点。
后遍历结果的最后一个节点一定是当前二叉树的根节点。

递归实现

 public void postOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        // 先左子树的后序
        postOrder(root.left);
        // 再右子树的后序
        postOrder(root.right);
        // 根
        System.out.print(root.val + " ");
    }

循环实现

public class Num145_PostOrderTraversal {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        //当前即将要访问的节点
        TreeNode cur = root;
        //上一个完全访问的节点
        TreeNode prev = null;
        Deque<TreeNode> stack = new ArrayDeque<>();
        while (cur != null || !stack.isEmpty()) {
            //先一路向左
            while (cur != null) {
                //先将当前节点压入栈中
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.pop();
            if (cur.right == null || prev == cur.right) {
                //右子树为空或者已经访问结束
                result.add(cur.val);
                //更新prev为当前节点
                prev = cur;
                //将cur置空，下一次循环从栈顶取元素
                cur = null;
            } else {
                //继续访问右子树
                //将cur再次压入
                stack.push(cur);
                cur = cur.right;
            }
        }
        return result;
    }
}

注意：在整个遍历的过程中，拿节点E来举例，当第三次访问到该节点时，将节点E弹出，但这里有一个问题，此时节点E的右子树不为null，又得将H节点压入栈中，但此时H节点已经被访问过了，故会无限的在E和H之间循环，程序会死循环。如何告诉程序H节点已经被访问过了？引入一个新的引用prev，描述一下上一个被完全访问过的节点是谁。当这个节点能被输出之后，更新prev。

前序遍历和后序遍历的关系：
后序遍历的转置，就是前序遍历的镜像结果，即“根右左”。

广度优先遍历(层序遍历)

从上到下，从左至右依次遍历树中每个节点。

循环实现

在二叉树的层序遍历中，我们需要借助队列这个数据结构来实现。

问题1：为啥要借助队列而不是栈呢？
答：栈是一种先进后出的数据结构，在层序遍历中，我们的目的是第一层的节点一定比第二层的先访问，以此类推。所以我们要让先访问的先出，故要借助队列。

//二叉树的层序遍历
public class Num102_LevelOrder {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        //借助队列来模拟层序遍历的过程
        Deque<TreeNode> qeque = new LinkedList<>();
        //根节点先入队
        qeque.offer(root);
        //遍历整个队列，当队列为空时，循环结束
        while (!qeque.isEmpty()){
            //根节点入队后，此时队列中保存的就是即将要访问的这一层的所有元素
            //定义内层循环的次数，就是此时队列中保存的元素的个数
            int size = qeque.size();
            //先保存当前这一层的节点
            List<Integer> curlist = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                //先出队
                TreeNode node = qeque.poll();
                //将这个值依次添加到curlist中
                curlist.add(node.val);
                //再入队。依次将当前节点的左右子树依次入队
                if(node.left != null){
                    qeque.offer(node.left);
                }
                if(node.right != null){
                    qeque.offer(node.right);
                }
            }
            //走完这个循环，curlist保存了当前层的所有元素，队列中恰好就是下一层的所有元素
            //将curlist保存到result中
            result.add(curlist);
            //继续循环
        }
        //循环结束，返回result
        return result;
    }
}

注意：在上述代码中，List<Integer> curlist = new ArrayList<>()这行代码如果写在循环外面会报错，原因在于， curlist 这个引用保存的是当前这一层的所有元素，就拿上面这个图来说，我们需要保存了四个curlist引用，但我们要的是这四个引用互不影响，如果写在循环外面，那这四个引用指向的是同一个数组对象，所以在每次保存下一层元素时，会更改上一层保存好的元素。因此必须在每一层都要产生一个新的ArrayList对象。

动图参考：https://zhuanlan.zhihu.com/p/384818393。

继续加油努力！！！