[LeetCode] Binary Tree Level Order Traversal II

Question：

Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree {3,9,20,#,#,15,7},

    3
   / 
  9  20
    /  
   15   7

return its bottom-up level order traversal as:

[
  [15,7],
  [9,20],
  [3]
]

1、题型分类：

2、思路：先计算深度，递归添加每一个点，根据所在深度，确定所在链表

3、时间复杂度：

4、代码：

public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> list=new ArrayList<List<Integer>>();
        if(root==null) return list;
        int depth=depth(root);
        for(int i=0;i<depth;i++)
        {
            List<Integer> temp=new ArrayList<Integer>();
            list.add(temp);
        }
        traverDepth(root, list, 1, depth);
        Collections.reverse(list);
        return list;
    }
    public void traverDepth(TreeNode node,List<List<Integer>> list,int curDepth,int depth)
    {
        
        if(node!=null) { list.get(curDepth-1).add(node.val);} else return;
        curDepth++;
        if(node.left!=null) traverDepth(node.left, list, curDepth, depth);
        if(node.right!=null) traverDepth(node.right, list, curDepth, depth);
    }
    public int depth(TreeNode root){  
        if(root==null){  
            return 0;  
        }  
        return 1+Math.max(depth(root.left), depth(root.right));  
    } 
}

5、优化：

　　网上有的方法采用两个辅助链表，第一个记录当层的node,第二个记录下一层的所有node，遍历完后，将第一个假如到返回的总链表中，当层指向下一层，下一层为空，这样不断往下迭代。

　　

        List<List<Integer>> list=new ArrayList<List<Integer>>();
        if(root==null) return list;
        
        List<TreeNode> listCur=new ArrayList<TreeNode>();
        List<TreeNode> listNex=new ArrayList<TreeNode>();
        
        listCur.add(root);// add first
        while(!listCur.isEmpty())
        {
            List<Integer> listTemp=new ArrayList<Integer>();
            for(int i=0;i<listCur.size();i++)
            {
                TreeNode treeNode=listCur.get(i);
                listTemp.add(treeNode.val);
                if(treeNode.left!=null) listNex.add(treeNode.left);
                if(treeNode.right!=null) listNex.add(treeNode.right);
            }
            list.add(listTemp);
            
            
            List<TreeNode> temp=listCur;
            listCur=listNex;
            listNex=temp;
            listNex.clear();
        }
        Collections.reverse(list);
        return list;

6、扩展

　　顺序

public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list=new ArrayList<List<Integer>>();
        if(root==null) return list;
        
        List<TreeNode> listCur=new ArrayList<TreeNode>();
        List<TreeNode> listNex=new ArrayList<TreeNode>();
        
        listCur.add(root);// add first
        while(!listCur.isEmpty())
        {
            List<Integer> listTemp=new ArrayList<Integer>();
            for(int i=0;i<listCur.size();i++)
            {
                TreeNode treeNode=listCur.get(i);
                listTemp.add(treeNode.val);
                if(treeNode.left!=null) listNex.add(treeNode.left);
                if(treeNode.right!=null) listNex.add(treeNode.right);
            }
            list.add(listTemp);
            
            
            List<TreeNode> temp=listCur;
            listCur=listNex;
            listNex=temp;
            listNex.clear();
        }
        return list;
    }
}