【Leetcode】Binary Tree Level Order Traversal II

最新推荐文章于 2025-09-09 08:37:13 发布

原创最新推荐文章于 2025-09-09 08:37:13 发布 · 111 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #leetcode #arraylist #LinkedList

本文介绍了一种解决二叉树底部向上层次遍历的方法，提供了两种不同的Java实现方案，并详细解释了每种方法的工作原理。

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},

return its bottom-up level order traversal as:

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

confused what "{1,#,2,3}" means?

OJ's Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}".

Java:

利用链表add的性质,每次加到res第0位，就是从后往前了

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<ArrayList<Integer>> levelOrderBottom(TreeNode root) {
          ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
       if(root==null) return res;
       ArrayList<TreeNode> level=new ArrayList<TreeNode>();
       level.add(root);
       while(level.size()!=0)
       {
           ArrayList<TreeNode> next=new ArrayList<TreeNode>();
           ArrayList<Integer> list= new ArrayList<Integer>();
           for(TreeNode node:level){
               list.add(node.val);
               if(node.left!=null)
               {
                   next.add(node.left);
               }
               if(node.right!=null)
               {
                   next.add(node.right);
               }
           }
           res.add(0,list);
           level=next;
       }
       return res; 
    }
}

其他解法：

1.http://blog.youkuaiyun.com/linhuanmars/article/details/23414711

几乎和他的1一样就是加了level 和反转

public ArrayList<ArrayList<Integer>> levelOrderBottom(TreeNode root) {  
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();  
    if(root == null)  
        return res;  
    LinkedList<TreeNode> queue = new LinkedList<TreeNode>();  
    int lastNum = 1;  
    int curNum = 0;  
    int level = 0;  
    queue.add(root);  
    while(!queue.isEmpty())  
    {  
        TreeNode n = queue.pop();  
        if(res.size()<=level)  
            res.add(new ArrayList<Integer>());  
        res.get(level).add(n.val);  
        lastNum--;  
        if(n.left!=null)  
        {  
            queue.add(n.left);  
            curNum++;  
        }  
        if(n.right!=null)  
        {  
            queue.add(n.right);  
            curNum++;  
        }  
        if(lastNum==0)  
        {  
            level++;  
            lastNum = curNum;  
            curNum = 0;  
              
        }  
    }  
    Collections.reverse(res);  
    return res;  
}

2. http://blog.youkuaiyun.com/ljphhj/article/details/22428939

public class Solution {  
    public ArrayList<ArrayList<Integer>> levelOrderBottom(TreeNode root) {  
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();  
        if (root == null)  
            return result;  
        Queue<TreeNode> queue = new LinkedList<TreeNode>();  
        ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();  
          
        //初始化先放入根结点到队列中, 为第一层结点  
        queue.add(root);  
          
        //这里采取一层层的方式加入到队列中  
        while (!queue.isEmpty()){  
            ArrayList<TreeNode> tempList = new ArrayList<TreeNode>();  
            ArrayList<Integer> tempValueList = new ArrayList<Integer>();  
              
            //先取出队列中的所有结点，因为它们是属于同一个层次的,并把这一层结点对应的ArrayList<Integer>值加入到list中。  
            while (!queue.isEmpty()){  
                TreeNode node = queue.remove();  
                tempList.add(node);  
                tempValueList.add(node.val);  
            }  
            list.add(tempValueList);  
              
            //对刚取出的这一个层次的下一个层次进行遍历加入到队列中。  
            for (int i=0; i<tempList.size(); ++i){  
                TreeNode node = tempList.get(i);  
                if (node.left != null){  
                    queue.add(node.left);  
                }  
                if (node.right != null){  
                    queue.add(node.right);  
                }  
            }  
        }  
          
        //结果List的翻转  
        for (int i=list.size()-1; i>=0; --i){  
            result.add(list.get(i));  
        }  
        return result;  
    }  
}