【树】107. 二叉树的层次遍历 II

题目：

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

3
/ \
9 20
/ \
15 7
返回其自底向上的层次遍历为：

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

解答：

方法一：层序遍历 + 翻转结果列表

/**
 * 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) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;

        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.addLast(root);

        Stack<List<Integer>> stack = new Stack<>();

        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> tmp = new ArrayList<>();

            for(int i = 0;i < size;i++){
                TreeNode node = queue.removeFirst();
                tmp.add(node.val);
                if(node.left!=null) queue.addLast(node.left);
                if(node.right!=null) queue.addLast(node.right);
                
            }
            stack.push(tmp);
        }
        int stackSize = stack.size();
        for(int i = 0;i<stackSize;i++){
            res.add(stack.pop());
        }

        return res;
    }
}

 

方法一的改进：层序遍历 + 使用链表在0号索引处插入新的元素（头插法）

/**
 * 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) {
        List<List<Integer>> res = new LinkedList<>();
        if(root == null) return res;

        //由于链表中插入删除操作复杂度为O(1)，所以使用LinkedList
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.addLast(root);

        

        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> tmp = new ArrayList<>();

            for(int i = 0;i < size;i++){
                TreeNode node = queue.removeFirst();
                tmp.add(node.val);
                if(node.left!=null) queue.addLast(node.left);
                if(node.right!=null) queue.addLast(node.right);
                
            }

            //在链表的0号索引处添加新的元素。
            res.add(0,tmp);
        }

        return res;
    }
}

 方法二：DFS

 

 

/**
 * 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>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;

        dfs(root,0,res);

        return res;
    }

    public void dfs(TreeNode root,int level,List<List<Integer>> res){
        
        //如果是第一次进入当前层，创建新的链表存储这一层的节点
        if(level>=res.size()){
            LinkedList<Integer> tmp = new LinkedList<>();
            //tmp.add(root.val);
            res.add(tmp);
        }
        if(level%2 == 0){
            res.get(level).add(root.val);
        }
        else{
            res.get(level).add(0,root.val);
        }

        if(root.left!=null) dfs(root.left,level+1,res);
        if(root.right!=null) dfs(root.right,level+1,res);
    }
}