Day15:二叉树层序遍历 LeedCode 102.二叉树的层序遍历 199二叉树的右视图 637.二叉树的层平均值 101.对称二叉树 226.翻转二叉树

102.二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。（即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

思路:利用队列的先进先出特点,依次将左子树和右子树入队列,每次循环结束后,队列里都存放的新一层的所有结点,依次将这些结点的左右子树入队列,可以得到下一层的所有结点

图解:

迭代法

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
         List<List<Integer>> list=new ArrayList<>();
         if(root==null){
            return list;
         }
         Queue<TreeNode> myQueue=new LinkedList<>();
         TreeNode cur=root;
         myQueue.offer(cur);
        while(!myQueue.isEmpty()){
            List<Integer>list1=new ArrayList<>();
//队列中存放着上一层的所有结点
//len记录上一层所有结点的个数
            int len=myQueue.size();
            while(len-->0){
                TreeNode temp=myQueue.poll();
                list1.add(temp.val);
                if(temp.left!=null){myQueue.offer(temp.left);}
                if(temp.right!=null){myQueue.offer(temp.right);}
            }
            list.add(list1);
        }
        return list;
    }
}

递归法

在先序遍历的基础上加入深度length

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
         List<List<Integer>> list=new ArrayList<>();
         order(root,list,0);
         return list;
    }
    public void order(TreeNode cur, List<List<Integer>> list,int length){
       if(cur==null){
        return;
       }
       if(list.size()==length)
       list.add(new ArrayList<Integer>());
//利用list的索引值进行层级界定
       list.get(length).add(cur.val);
       order(cur.left,list,length+1);
       order(cur.right,list,length+1);
    }
}

以下题目均类似:

107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
       List<List<Integer>>list=new ArrayList<List<Integer>>();
       order(root,list,0);
       Collections.reverse(list);
       return list;
    }
    public void order(TreeNode cur,List<List<Integer>> list,int length){
        if(cur==null)
        return;
        if(length==list.size()){
            list.add(new ArrayList<Integer>());
        }
        list.get(length).add(cur.val);
        order(cur.left,list,length+1);
        order(cur.right,list,length+1);
    }
}

199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

思路:在层序遍历的基础上将每层最后一个元素放入list

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

    }
}

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

注意:相加的结果会超过int表示范围

    public List<Double> averageOfLevels(TreeNode root) {
    List <Double> list=new ArrayList<>();
    if(root==null)
       return list;
        Queue<TreeNode> muQ=new LinkedList<TreeNode> ();
        muQ.offer(root);
        while(!muQ.isEmpty()){
            int len=muQ.size();
            long sums=0;
            int nums=len;
            while(len-->0){
            TreeNode  temp=muQ.poll();
            sums+=temp.val;
            if(temp.left!=null) muQ.add(temp.left);
            if(temp.right!=null) muQ.add(temp.right);
            }
            list.add(sums*1.0/nums);
        }
    return list;
    }
   
}

429. N 叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

思路:将二叉树层序遍历的模版中将左右孩子结点加入队列改成将孩子结点(0-N个)加入队列

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
  List<List<Integer>> list=new ArrayList<>();
         if(root==null){
            return list;
         }
         Queue<Node> myQueue=new LinkedList<>();
         Node cur=root;
         myQueue.offer(cur);
        while(!myQueue.isEmpty()){
            List<Integer>list1=new ArrayList<>();
            int len=myQueue.size();
            while(len-->0){
                Node temp=myQueue.poll();
                list1.add(temp.val);
                List<Node> children=temp.children;
                int i=0;;
                while(i<children.size()){
                    myQueue.add(children.get(i));
                    i++;
                }
            }
            list.add(list1);
        }
        return list;

      }
}

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

思路:与637二叉树的层平均值相似

class Solution {
    public List<Integer> largestValues(TreeNode root) {
  List <Integer> list=new ArrayList<>();
    if(root==null)
       return list;
        Queue<TreeNode> muQ=new LinkedList<TreeNode> ();
        muQ.offer(root);
        while(!muQ.isEmpty()){
            int len=muQ.size();
            int maxx=Integer.MIN_VALUE;
            while(len-->0){
            TreeNode  temp=muQ.poll();
            maxx=Math.max(maxx,temp.val);
            if(temp.left!=null) muQ.add(temp.left);
            if(temp.right!=null) muQ.add(temp.right);
            }
            list.add(maxx);
        }
    return list;
    }
}

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

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

思路:层序遍历时,当前结点指向下一结点

117. 填充每个节点的下一个右侧节点指针 II也是一样做法

class Solution {
    public Node connect(Node root) {
    if(root==null)
       return root;
        Queue<Node> muQ=new LinkedList<Node> ();
        muQ.offer(root);
        while(!muQ.isEmpty()){
            int len=muQ.size();
             Node  temp=null;
             Node   next=null;
            while(len-->0){
              temp=muQ.poll();
              if(len>0) next=muQ.peek();
              else{next=null;}
              temp.next=next;
            if(temp.left!=null) muQ.add(temp.left);
            if(temp.right!=null) muQ.add(temp.right);
            }
        }
    return root;
    }
}

104. 二叉树的最大深度

class Solution {
    public int maxDepth(TreeNode root) {
            int length=0;
         if(root==null){
            return length;
         }
         Queue<TreeNode> myQueue=new LinkedList<>();
         TreeNode cur=root;
         myQueue.offer(cur);
        while(!myQueue.isEmpty()){
            List<Integer>list1=new ArrayList<>();
            int len=myQueue.size();
            while(len-->0){
                TreeNode temp=myQueue.poll();
                if(temp.left!=null){myQueue.offer(temp.left);}
                if(temp.right!=null){myQueue.offer(temp.right);}
            }
            length++;

        }
        return length;
    }
}

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点

思路:层序遍历到左右孩子都为空的结点时,这个结点的深度就是树的最小深度

class Solution {
    public int minDepth(TreeNode root) {
        int length=0;
         if(root==null){
            return length;
         }
         Queue<TreeNode> myQueue=new LinkedList<>();
         TreeNode cur=root;
         myQueue.offer(cur);
        while(!myQueue.isEmpty()){
            List<Integer>list1=new ArrayList<>();
            int len=myQueue.size();
            while(len-->0){
                TreeNode temp=myQueue.poll();
                if(temp.left==null&&temp.right==null){
                    return length+1;
                }
                if(temp.left!=null){myQueue.offer(temp.left);}
                if(temp.right!=null){myQueue.offer(temp.right);}
            }
            length++;

        }
        return length;
    }
}

101. 对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

思路:本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。

1.确定传递参数

因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。

返回值自然是bool类型。

bool compare(TreeNode* left, TreeNode* right)

2.确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

左节点为空，右节点不为空，return false
左不为空，右为空 return false
左右都为空，对称，返回true
左右都不为空，比较节点数值，不相同就return false

3.确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理左右节点都不为空，且数值相同的情况。

比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
如果左右都对称就返回true ，有一侧不对称就返回false 。

class Solution {
    public boolean isSymmetric(TreeNode root) {
     if(root==null)
      return true;
      return Comparet(root.left,root.right);
    }

    public boolean Comparet(TreeNode left,TreeNode right){
    if(left==null&&right==null){return true;}
    else if(left==null&&right!=null){return false; }
    else if(left!=null&&right==null){return false;}
    else{
        if(left.val!=right.val) return false;
    }
    //左右结点值相等,这两棵树才会是翻转树
    boolean l1=Comparet(left.left,right.right);
    boolean l2=Comparet(left.right,right.left);
    return l1&&l2;
    }
}

226. 翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

思路:采用递归的思想,先翻转左子树,再翻转右子树,然后翻转当前结点

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null)
        return root;
        invertTree(root.left);
        invertTree(root.right);
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        return root;
    }
}

采用先序遍历,先翻转当前结点,再翻转左右结点

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null)
        return root;   
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
          invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}