二叉树层序遍历讲解+题目

大家好呀，本篇博客将为大家讲解二叉树的层序遍历和四道相关经典OJ

一，二叉树的层序遍历

. - 力扣（LeetCode）
 

二叉树层序遍历是一个相对很好理解的遍历方法，其就是按照一层一层从左到右的顺序来遍历每个节点，我们可以先看看最简单的层序遍历--不按照一层层的顺序保存每个节点，而是只要遍历即可

对此我们需要一种数据结构-队列，先让同节点入队列，而后往后找，想让队列中最上面的节点出队，而后，只要这个节点有左孩子或者右孩子则让他的左孩子或者右孩子入队列，这样遍历直到队列为空为止，由这个逻辑，我们可以写一个最简单的层序遍历,我们用一个数组来储存层序遍历的值

class Solution{
   public void LeverOrder(TreeNode root) {
      List<Integer> list = new ArrayList();
      Queue<TreeNode> queue = new LinkedList();
      queue.offer(root);
      while (!queue.isEmpty()) {
         TreeNode cur = (TreeNode) queue.poll();
         list.add(cur.val);
         if (cur.left != null) {
            queue.offer(cur.left);
         }
         if (cur.right != null) {
            queue.offer(cur.right);
         }
      }
   }
}

但是本题让我们返回一个 LIst<List<Integer>>的值，显然，我们需要分层储存每一层的值，因此，我们可以采用把每一层节点的个数都记录下来，然后去一层层遍历，每一层都用一个新的数组储存即可。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret=new ArrayList();
        if(root==null){return ret;}
        Queue<TreeNode> queue=new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();//每一层的节点数
            List<Integer> tmp=new ArrayList();//用一个新的数组存储
            while(size!=0){
                TreeNode x=queue.poll();
                tmp.add(x.val);
                if(x.left!=null){
                    queue.offer(x.left);
                }
                if(x.right!=null){
                    queue.offer(x.right);
                }
                size--;
            }
            ret.add(tmp);
        }
         return ret;
    }
}

二，二叉树的右视图

. - 力扣（LeetCode）

初看此题，大家可能会以为这是一个一直找二叉树右子树的题目，但实际上我们还需要考虑二叉树左子树的影响，对于没有右孩子但是有左孩子的树来说，显然这种思路并不正确，实际上，此题其实就是二叉树层序遍历的变种，只需要写出层序遍历，但是这次，我们不需要记录每一层每个节点的值，只记录每一层最右边节点的值即可。这里采取当size==0时才记录一次节点的值，其余部分稍加修改即可。

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ret=new ArrayList();
        if(root==null){
            return ret;
        }
        Queue<TreeNode> queue=new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            while(size!=0){
                TreeNode tmp=queue.poll();
                if(tmp.left!=null){
                    queue.offer(tmp.left);
                }
                 if(tmp.right!=null){
                    queue.offer(tmp.right);
                }
                size--;
                if(size==0){
                    ret.add(tmp.val);
                }
            }
        }
        return ret;

    }
}

三，二叉树的层平均值

. - 力扣（LeetCode）

只要会层序遍历就一定会的题，只需要注意因为右小数，需要用double接受平均值

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
         List<Double> ret=new ArrayList();
        if(root==null){return ret;}
        Queue<TreeNode> queue=new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            double sum=0;
            List<Integer> tmp=new ArrayList();
            while(size!=0){
                TreeNode x=queue.poll();
                tmp.add(x.val);
                 sum+=x.val;
                if(x.left!=null){
                    queue.offer(x.left);
                }
                if(x.right!=null){
                    queue.offer(x.right);
                }
                size--;
            }
            int n=tmp.size();
            ret.add(sum/n); 
        }
         return ret;
    }
}

四，二叉树的锯齿遍历

. - 力扣（LeetCode）

此题有一个简便做法那便是在层序遍历后把奇数层逆置，虽然不算锯齿遍历，但是也能过。

也可以用链表，用头插，尾插的方式来遍历，下面给出第二种方式代码

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root==null)return result;
        queue.add(root);
        int i = 0, len=1, dir = 0;
        while(!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();
            for(i = 0;i<len ;i++){
                TreeNode current = queue.remove();
                if(dir%2==0)list.add(current.val);
                else list.add(0, current.val);
                if(current.left!=null) queue.add(current.left);
                if(current.right!=null) queue.add(current.right);
            }
            result.add(list);
            len = queue.size();
            dir++;
        }
        return result;
    }
}

本期博客就到这里，谢谢大家