107. Binary Tree Level Order Traversal II(easy)

版权声明：文章都是原创，转载请注明~~~~ https://blog.csdn.net/SourDumplings/article/details/88131480

Easy

639113FavoriteShare

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,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its bottom-up level order traversal as:

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

C++:

DFS:

/*
 * @Author: SourDumplings
 * @Link: https://github.com/SourDumplings/
 * @Email: [email protected]
 * @Description: https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
 * @Date: 2019-03-04 17:36:39
 */

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution
{
  public:
	vector<vector<int>> levelOrderBottom(TreeNode *root)
	{
		vector<vector<int>> res(1000);
		dfs(root, 0, res);
		for (auto it = res.begin(); it < res.end(); it++)
		{
			if (it->empty())
			{
				res.erase(it, res.end());
				break;
			}
		}
		reverse(res.begin(), res.end());

		return res;
	}

	void dfs(TreeNode *node, int level, vector<vector<int>> &res)
	{
		if (node)
		{
			res[level].push_back(node->val);
			dfs(node->left, level + 1, res);
			dfs(node->right, level + 1, res);
		}
	}
};

BFS:

/*
 * @Author: SourDumplings
 * @Link: https://github.com/SourDumplings/
 * @Email: [email protected]
 * @Description: https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
 * @Date: 2019-03-04 17:36:39
 */

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution
{
  public:
	vector<vector<int>> levelOrderBottom(TreeNode *root)
	{
		vector<vector<int>> res(1000);
		queue<pair<TreeNode *, int>> q;
		q.push(make_pair(root, 0));

		if (root == nullptr)
		{
			res.clear();
			return res;
		}

		while (!q.empty())
		{
			pair<TreeNode *, int> p = q.front();
			TreeNode *node = p.first;
			int level = p.second;
			q.pop();
			res[level].push_back(node->val);
			if (node->left)
			{
				q.push(make_pair(node->left, level + 1));
			}
			if (node->right)
			{
				q.push(make_pair(node->right, level + 1));
			}
		}

		for (auto it = res.begin(); it < res.end(); it++)
		{
			if (it->empty())
			{
				res.erase(it, res.end());
			}
		}

		reverse(res.begin(), res.end());

		return res;
	}
};

Java:

BFS:

import java.util.List;

/*
 * @Author: SourDumplings
 * @Link: https://github.com/SourDumplings/
 * @Email: [email protected]
 * @Description: https://leetcode.com/problems/binary-tree-level-order-traversal-ii/
 * @Date: 2019-03-04 18:20:04
 */

/**
* 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<List<Integer>>();
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        if (root == null)
        {
            return res;
        }
        q.add(root);
        while (!q.isEmpty())
        {
            int levelNum = q.size();
            List<Integer> subList = new LinkedList<Integer>();
            for (int i = 0; i < levelNum; i++)
            {
                TreeNode node = q.poll();
                if (node.left != null)
                {
                    q.add(node.left);
                }
                if (node.right != null)
                {
                    q.add(node.right);
                }
                subList.add(node.val);
            }
            res.add(0, subList);
        }
        return res;

    }
}