算法通关村--第六关白银挑战

class Solution {
        int count=0;
        public void dfs_count(TreeNode root,int level){
            if(root==null)
                return;
            if(level>count)
                count=level;
            dfs_count(root.left,level+1);
            dfs_count(root.right,level+1);
        }
        public void dfs( List<List<Integer>> ans,TreeNode root,int level){
        if(root==null)
            return;
        ans.get(count-level).add(root.val);//核心操作，将结果集中下标为level-1的集合取出，将root的值加入该层所对应的集合中。
        if(root.left!=null)
            dfs(ans,root.left,level+1);
        if(root.right!=null)
            dfs(ans,root.right,level+1);
    }
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ans=new ArrayList<List<Integer>>();
        dfs_count(root,1);
        for(int i=0;i<count;i++){
        List<Integer> layer=new ArrayList<Integer>();
        ans.add(layer);            
        }
        dfs(ans,root,1);

        return ans;
    }
}

 

class Solution {
    public void dfs(List<List<Integer>> ans,TreeNode root,int level){
        if(root==null)
            return;
        if(ans.size()<level){
            List<Integer> layer=new LinkedList<Integer>();
            ans.add(layer);
        }
        if(level%2==0)
            ans.get(level-1).add(0,root.val);
        else
            ans.get(level-1).add(root.val);
        dfs(ans,root.left,level+1);
        dfs(ans,root.right,level+1);
    }
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ans=new ArrayList<List<Integer>>();
        dfs(ans,root,1);
        return ans;
    }
}

 

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> ans=new ArrayList<List<Integer>>();
        Queue<Node> queue=new LinkedList<Node> ();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            List<Integer> level=new ArrayList<Integer>();
            for(int i=0;i<size;i++){
                Node node=queue.poll();
                if(node==null)
                    continue;
                level.add(node.val);
                for(int j=0;j<node.children.size();j++){
                    queue.offer(node.children.get(j));
                }
            }
            if(!level.isEmpty())
                ans.add(level);
        }
        return ans;
    }
}

 

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> ans=new ArrayList<Integer>();
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            int max=Integer.MIN_VALUE;
            int flag=0;
            for(int i=0;i<size;i++){
               TreeNode node=queue.poll();
               if(node==null)
                 continue;
               if(node.val>=max){
                 max=node.val;     
                 flag=1;
               }
                queue.offer(node.left);
                queue.offer(node.right);
            }
            if(flag!=0)
                ans.add(max);
        }
        return ans;
    }
}

 

class Solution {
    public void dfs(List<Double> ans,List<Integer> count,TreeNode root,int level){
        if(root==null)
            return;
        if(ans.size()<level){
            Double value=Double.valueOf(root.val);
            ans.add(level-1,value);
            count.add(level-1,1);
        }
        else{
            Double sum=root.val+ans.get(level-1);
            count.set(level-1,count.get(level-1)+1);
            ans.set(level-1,sum);
        }
        dfs(ans,count,root.left,level+1);
        dfs(ans,count,root.right,level+1);
    }
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ans=new ArrayList<Double>();
        List<Integer> count=new ArrayList<Integer>();
        dfs(ans,count,root,1);
        for(int i=0;i<ans.size();i++){
            Double ave=ans.get(i)/count.get(i);
            ans.set(i,ave);
        }
        return ans;
    }
}

 

class Solution {
    public void dfs(List<Integer> ans,TreeNode root,int level){
        if(root==null)
            return;
        if(ans.size()<level)
            ans.add(level-1,root.val);
        else{
            ans.set(level-1,root.val);
        }
        dfs(ans,root.left,level+1);
        dfs(ans,root.right,level+1);
    }
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ans=new ArrayList<Integer>();
        dfs(ans,root,1);
        return ans;
    }
}

 

class Solution {
    int count=0;
    int ans=0;
    public void dfs(TreeNode root,int level){
        if(root==null)
            return;
        if(count<level){
            count++;
            ans=root.val;
        }
        dfs(root.left,level+1);
        dfs(root.right,level+1);
    }
    public int findBottomLeftValue(TreeNode root) {
        dfs(root,1);
        return ans;
    }
}