树的层序遍历(深度优先 和 队列)

题目： 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).

DFS算法：

public List<List<Integer>> levelOrderBottom(TreeNode root) {
    List<List<Integer>> res = new ArrayList<List<Integer>>();
    helper(root,0,res);
    return res;
}
// 一个前序遍历 
public void helper(TreeNode root, int n, List<List<Integer>> res){
    if(root==null) return;
    // 取得同一层的链表 如果没有则 添加一个
    if(res.size()<=n) res.add(0,new ArrayList<Integer>());
    res.get(res.size()-n-1).add(root.val);
    helper(root.left,n+1,res);
    helper(root.right,n+1,res);
}

队列实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> result = new LinkedList<> ();
        LinkedList<TreeNode> queue = new LinkedList<> ();

        if(root == null) return result;
        int cur = 1;
        int next = 0;
        queue.add(root);
        List<Integer> list = new ArrayList<> ();

        int count = 0;
        while(!queue.isEmpty()) {
            // 遍历完一层
            if(count == cur) {
                cur = next;
                result.addFirst(list);
                list = new ArrayList<> ();
                // 这两个置0
                count = 0;
                next = 0;
            }
            TreeNode node = queue.removeFirst();
            list.add(node.val);
            count++;
            if(node.left != null) {
                next++;
                queue.add(node.left);
            }
            if(node.right != null) {
                next++;
                queue.add(node.right);
            }
            if(queue.isEmpty()) {
                result.addFirst(list);
            }
        }

        return result;
    }

}