題目：

給定一個二叉樹，返回其節點值自底向上的層次遍歷。 （即按從葉子節點所在層到根節點所在的層，逐層從左向右遍歷）

例如：
給定二叉樹 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其自底向上的層次遍歷為：

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

集合方面還是比較懵。。。直接網上找了大神們的思路和程式碼。

思路一：整體的思路是將樹的每一層存入集合LinkedList中，使用addFirst順序新增每層，這樣就可以從下到上完成層次遍歷。在以下程式碼中，result用於儲存最後的結果數字，queue用於儲存每一行的節點，sin用於儲存每一行的節點的值.將節點一次加入到queue中，當佇列不為空時，取出佇列中的節點，將其值加入sin中，並且判斷該節點的左右節點是否為空，不為空時將其加入佇列。當對一層處理完後，將每一行的sin加入result中。

程式碼：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        //result用於儲存最後的結果數字，注意使用linkedList。放的是Integer
      LinkedList<List<Integer>> result=new LinkedList<List<Integer>>();
        if(root==null) return result;
       //queue用於儲存每一行的節點，放的是TreeNode
      Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.add(root);
        //每一行的節點個數
        int i=queue.size();
        TreeNode tem=null;
        //用於儲存每一行的節點的值
        List<Integer> sin=new ArrayList<>();
        //一行的節點不為空
        while(!queue.isEmpty())
        {
            if(i==0){  //將一行的資料處理完
                //注意用addFirst，總是新增在頭部
                result.addFirst(sin);  
                i=queue.size();
                sin=new ArrayList<>();
            }
            --i;
            //取出每一行中的節點
            tem=queue.poll();
            sin.add(tem.val);
            
            if(tem.left!=null)
            {queue.add(tem.left);}
            if(tem.right!=null)
            {queue.add(tem.right);}
            
        }
        
         result.addFirst(sin);
        return result;
    }
}

思路二：這個是網上大神遞推的演算法。在這裡最重要的是知道每一層的層號。按照節點從左往右的順序呼叫函式。對於每個節點先判斷是否為空，不為空 的話，先給結果result中新增一個ArrayList,然後計算相應的層號加值加入。最後對當前節點的左右節點遞迴呼叫函式，直到為空。

public List<List<Integer>> levelOrderBottom2(TreeNode root) {
        LinkedList<List<Integer>> result = new LinkedList<List<Integer>>();

        levelRecursion(root, result, 0);

        return result;
    }

    /**
     * 遞迴方法
     */
    private void levelRecursion(TreeNode node,
            LinkedList<List<Integer>> result, int level) {
        if (node == null) {
            return;
        }
        if (result.size() < level + 1) {// 說明還需要新增一行
            result.addFirst(new ArrayList<Integer>());
        }
        result.get(result.size() - 1 - level).add(node.val);

        levelRecursion(node.left, result, level + 1);
        levelRecursion(node.right, result, level + 1);
    }
 

執行用時最快的範例：和以上的思路一基本一致

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> l = new LinkedList();
        if (root == null) return l;
        Queue<TreeNode> q = new LinkedList();
        Stack<List<Integer>> s = new Stack();
        q.offer(root);
        int i = q.size();
        List<Integer> list = new LinkedList();
        TreeNode p = null;
        while(q.size() > 0) {
            if (i == 0) {
                l.addFirst(list);
                i = q.size();
                list = new LinkedList();
            }

            p = q.poll();
            list.add(p.val);
            
            --i;
            
            if (p.left != null) q.offer(p.left);
            if (p.right != null) q.offer(p.right);
            
        }
        
        l.addFirst(list);
            
        return l;
    }
}