Binary Tree Level Order Traversal II

题目描述

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]
]

解题思路

首先可以去看一下对LevelOrderTraversal的分析，我在前面的文章中有介绍，此题也是层次遍历，只是要求返回的结果集结构不同，结果集中在前的是底层的节点集合，也就是从下向上从左向右这样遍历，我们采用和LevelOrderTraversal1中一样的结构，记录层次信息，采用同样的辅助队列去遍历，和1不同的就是我们遍历完一个层次后在加入结果集的时候是插入在头部，这样结果集的头部就是底层的节点结合，这里我们使用LinkedList作为List接口的实现类，这样在插入数据的时候效率高，O(1),那么代码和1不同的就是我们使用LinkedList取代了ArrayList，代码中有两处add函数，改为add(0,List)即可。

详细代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
    //Binary Tree Level Order Traversal
    class TreeNodeWithDepth
    {
        TreeNode treeNode;
        int depth;

        public TreeNodeWithDepth(TreeNode treeNode, int depth)
        {
            this.treeNode = treeNode;
            this.depth = depth;
        }
    }

public class Solution {
    //Given a binary tree, return the level order traversal of its nodes‘ values. (ie, from left to right, level by level).
    //二叉树的层次遍历 2 最底层最先遍历
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        int depth = 1;
        int lastLevel = 1; //while中用来标示上一次节点的level
        List<List<Integer>> resultsList = new LinkedList<List<Integer>>();  //注意初始化 List是接口类 //这点和levelOrder不同使用LinkedList
        Queue<TreeNodeWithDepth> queue = new LinkedList<>();
        TreeNodeWithDepth pNode = null;
        if(root != null)
        {
            pNode = new TreeNodeWithDepth(root, 1);
            queue.offer(pNode);
        }
        List<Integer> listPerLevel = new ArrayList<>();//每层的list 
        while(!queue.isEmpty())
        {
            pNode = queue.poll();//程序加入时已经判断不为空节点

            if(pNode.depth > lastLevel)
            {
                //说明是新的一层
                if(listPerLevel.size()!=0)
                {
                    //把上一层的列表加入result中 插入到第一个位置 
                    resultsList.add(listPerLevel);
                }
                listPerLevel = new ArrayList<>(); //重新另起一个listPerLevel
                listPerLevel.add(pNode.treeNode.val);//在新列表中加入当前节点
                lastLevel = pNode.depth;//更新lastLevel
            }
            else 
            {
                listPerLevel.add(pNode.treeNode.val);
            }
            //确定子节点深度
            depth = pNode.depth+1;

            //子节点入队列
            if(pNode.treeNode.left != null)
            {
                queue.offer(new TreeNodeWithDepth(pNode.treeNode.left, depth));
            }
            if(pNode.treeNode.right != null)
            {
                queue.offer(new TreeNodeWithDepth(pNode.treeNode.right, depth));
            }

        }

        //while循环中最后一次的listPerLevel也要加入
        if(listPerLevel.size()>0)
        {
            resultsList.add(0,listPerLevel);
        }
        return resultsList;
    }
}