二叉树层次遍历 Leecode总结

Leecode107：层序遍历,从叶子节点到根节点

　　正常的层序遍历之后,对resList进行反转,调用Collections.reverse(resList);或者每次添加list时，从resList的头部开始添加

class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        checkfun(root);
        return resList;
    }
    public void checkfun(TreeNode root){
        if(root == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(root);
        while(!que.isEmpty()){
            List<Integer> list  = new ArrayList<Integer>();
            int len = que.size();
            while(len > 0) {
                TreeNode node = que.poll();
                list.add(node.val);
                if(node.left != null) {que.offer(node.left);}
                if(node.right != null) {que.offer(node.right);}
                len--;
            }
            resList.add(0,list);//Collections.reverse(resList);
        } 
    }
}

Leecode 199二叉树的右视图

　　思路：层序遍历，每层只保留最后一个数，即判断len =1时，将val添加到list中。同理左视树，可以len = qun.size()得到。

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

Leecode 637 二叉树的平均值

返回每层的平均值,可在每层遍历的循环中增加一个变量sum,每次处理节点是,将节点从队列中弹出，用sum累加。

/**

* Definition for a binary tree node.

* public class TreeNode {

* int val;

* TreeNode left;

* TreeNode right;

* TreeNode() {}

* TreeNode(int val) { this.val = val; }

* TreeNode(int val, TreeNode left, TreeNode right) {

* this.val = val;

* this.left = left;

* this.right = right;

* }

class Solution {

List<Double> resList = new ArrayList<Double>();

public List<Double> averageOfLevels(TreeNode root) {

checek(root);

return resList;

}

public void checek(TreeNode root) {

double sum = 0;

if(root == null) return;

Queue<TreeNode> que = new LinkedList<TreeNode>();

que.offer(root);

while(!que.isEmpty()) {

sum = 0;

int len = que.size();

for(int i =0;i<len;i++)

{

TreeNode node =que.poll();

sum += node.val;

if(node.left != null) {que.offer(node.left);}

if(node.right != null) {que.offer(node.right);}

}

resList.add((sum /len));

}

Leecode429 N叉树的层序遍历

要将节点从List<Node>chidren里面取出来！！！

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
     public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(Node root) {
        checkfun02(root);
        
        return resList;

    }
     public void checkfun02(Node root){
         if (root == null) {return;}
         Queue<Node> que = new LinkedList<Node>();
         que.offer(root);
         while(!que.isEmpty()){
             List<Integer> list = new ArrayList<Integer>();
             int len = que.size();
             for(int i = 0; i < len; i++){
                 Node node = que.poll();
                 list.add(node.val);
                 if(node.children == null && node.children.size() ==0) {
                    continue;
                         }
                        for(Node n:node.children){
                         if(n != null){
                         que.offer(n);
                     }
                 }
                 }
                 resList.add(list);
             }
         }
     
     }

Leecode515 在每个树行中找最大值

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public static final int   INT_MIN = 0x80000000;
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> list  = new ArrayList<>();
        Queue<TreeNode> que = new LinkedList<>();
        if(root == null) {return list;}
        que.offer(root);
       
        while(!que.isEmpty()) {
            int temp = INT_MIN;
            int len = que.size();
            for(int i = 0; i < len; i++) {
                TreeNode node = que.poll();
                //将当前节点的值保存在temp变量中，和下一次进行比较
  　　　　　　　　　 temp = temp > node.val ? temp:node.val;
                if(node.left != null) {que.offer(node.left);}
                if(node.right != null) {que.offer(node.right);}
            }
            list.add(temp);
        }
        return list;
    }
}

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

每层遍历到最后一个节点之前，进行连接。连接时获取下一节点用peek()方法,不弹出队列。

判断条件注意 (i < len - 1) 最后一个节点不需要连接。所以不考虑。即 i = len -1；

class Solution {
    public Node connect(Node root) {
        if(root == null) {return root;}
        Queue<Node> que = new LinkedList<Node>();
        que.offer(root);
        while(!que.isEmpty()) {
            int len = que.size();
            for(int i = 0; i < len; i++) {
                Node node = que.poll();
                if( i < len -1){
                    node.next = que.peek();//连接
                } 
                if(node.left != null) {que.offer(node.left);}
                if(node.right != null) {que.offer(node.right);}
            }
        }
        return root;
    }
}