无聊的层序遍历

树的层序遍历是关于树这类算法中最基础的考查内容，只要只要掌握了层序遍历，关于这类的算法问题基本都是在层序遍历算法上做修改而已，特无聊！

二叉树的层序遍历（102）

关于层序遍历我们一般采用队列的方式去实现，大致思路是这样的：先将根节点放入队列，获取当前队列长度（size），然后一边出队列，一边将出队列的节点的左右节点放入队列，共执行size次。这是一行数据，然后以此循环直到将树遍历完。题干中要将每行数据放在一个列表中，我们只需要记录每个出队列的数据放入列表中即可。代码实现：

public List<List<Integer>> levelOrder(TreeNode root) {
        if(root==null){
            return List.of();
        }
        Queue<TreeNode> newQueue = new ArrayDeque<TreeNode>();
        List<List<Integer>> resultList = new ArrayList<>();
        newQueue.add(root);
        while(!newQueue.isEmpty()){
            int len = newQueue.size();
            List<Integer> list = new ArrayList<>(len);
             while(len>0){
                TreeNode node = newQueue.remove();
                if(node.left!=null){
                    newQueue.add(node.left);
                }
                if(node.right!=null){
                    newQueue.add(node.right);
                }
                list.add(node.val);
                len--;
            }
            resultList.add(list);
        }
        return resultList;
    }

请仔细研究并弄懂这段代码逻辑，后面我们会不止一次的复用这段代码。

自底向上的二叉树的层序遍历（107）

这……和层序遍历有什么区别吗？将结果列表反转一下就好了呀！当然反转方法有很多种。这里我用的是Java提供的反转反函数实现，当然大家也可以在插入时都从0号位置插入同样也可以实现翻转resultList.add(0,list);。

public List<List<Integer>> levelOrderBottom(TreeNode root) {
         if(root==null){
            return List.of();
        }
        Queue<TreeNode> newQueue = new ArrayDeque<TreeNode>();
        List<List<Integer>> resultList = new ArrayList<>();
        newQueue.add(root);
        while(!newQueue.isEmpty()){
            int len = newQueue.size();
            List<Integer> list = new ArrayList<>(len);
             while(len>0){
                TreeNode node = newQueue.remove();
                if(node.left!=null){
                    newQueue.add(node.left);
                }
                if(node.right!=null){
                    newQueue.add(node.right);
                }
                list.add(node.val);
                len--;
            }
            resultList.add(list);
        }
        Collections.reverse(resultList);
        return resultList;
    }

锯齿层序遍历（103）

好家伙个这考我基本功是吧！这个题大致意思就是奇数行遍历时不翻转，偶数行遍历时反转。这有什么难的：

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        if(root==null){
            return List.of();
        }
        Queue<TreeNode> newQueue = new ArrayDeque<TreeNode>();
        List<List<Integer>> resultList = new ArrayList<>();
        newQueue.add(root);
        boolean isOddRow = true;
        while(!newQueue.isEmpty()){
            int len = newQueue.size();
            List<Integer> list = new ArrayList<>(len);
             while(len>0){
                TreeNode node = newQueue.remove();
                if(node.left!=null){
                    newQueue.add(node.left);
                }
                if(node.right!=null){
                    newQueue.add(node.right);
                }
                list.add(node.val);
                len--;
            }
            if(isOddRow){
                resultList.add(list);
            }else{
                Collections.reverse(list);
                resultList.add(list);
            }
            isOddRow=!isOddRow;
        }
        
        return resultList;
    }

基本上关于二叉树的遍历都是这一类的题，只需要将层序遍历进行相应的修改即可，例如：N叉树的层序遍历（429）、在每行树中找最大值（515）、二叉树的层平均值（637）、二叉树的右视图（199）等等。

填充每个节点下一个右侧节点的指针（116）

这道题还是有一定的难度的，大致意思是每个节点都新增了一个next指针，next指向的是与他同一行的右侧节点，现在树的next都为空，让你填充每个节点next值。

由于给定了条件是完美二叉树，不需要考虑左右节点是否存在的问题，这里我采用的是递归的方法：

public Node connect(Node root) {
        if(root == null){
            return null;
        }
        if(root.left != null){
            root.left.next=root.right;
            if(root.next!=null){
                root.right.next=root.next.left;
            }
        }
        connect(root.left);
        connect(root.right);
        return root;
    }

很好理解，对于每个节点来说要将他下面的左右子节点相连接，同时还要判断该节点的右边是否还有节点，若有则将该节点的右节点与他先一个节点的左节点线连接。以此递归实现。

填充每个节点下一个右侧节点的指针II（117）

与上一题不同的是这里是所有二叉树，要考虑到节点的情况，是否有左节点，是否右有右节点等，情况多样并没有统一的处理方法，所以不能像上一题那样采用递归，这里我的想法是仍在基础层序遍历的基础上修改，在出队的过程中给next赋值：

public Node connect(Node root) {
        if(root==null){
            return null;
        }
        Queue<Node> newQueue = new ArrayDeque<Node>();
        newQueue.add(root);
        while(!newQueue.isEmpty()){
            int len = newQueue.size();
            while(len>0){
                Node node = newQueue.remove();
                if(node.left!=null){
                    newQueue.add(node.left);
                }
                if(node.right!=null){
                    newQueue.add(node.right);
                }
                if(len==1){
                    node.next=null;
                }else{
                    node.next=newQueue.peek();
                }
                len--;
            }
        }
        return root;
    }

后序发现我们的目的只是修改next,没必要用队列存节点再给next赋值，为什么不直接使用链表呢？

public Node connect(Node root) {
        Node head = new Node(0, null, null, root), nxt = new Node();
        while (head.next != null) {
            for (Node p = head.next, q = nxt; p != null; p = p.next) {
                if (p.left != null) {
                    q.next = p.left;
                    q = q.next;
                }
                if (p.right != null) {
                    q.next = p.right;
                    q = q.next;
                }
            }
            head.next = nxt.next;
            nxt.next = null;
        }
        return root;
    }

这个方法的时间复杂度要比用队列的方式要低，是一种较优解法。