102. 二叉树的层序遍历

1 题目

        102. 二叉树的层序遍历 - 力扣（LeetCode）

        类似;107. 二叉树的层序遍历 II - 力扣（LeetCode）

        给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

2 参考：

        代码随想录 (programmercarl.com)

        102. 二叉树的层序遍历 - 力扣（LeetCode）

3 代码：

C++

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

/* 递归 */
class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& res, int depth){
        if (cur==nullptr) return ;
        if (res.size() == depth) res.push_back(vector<int>());
        res[depth].push_back(cur->val);
        order(cur->left, res, depth+1);
        order(cur->right, res, depth+1);
    }

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        int depth = 0;
        order(root, res, depth);
        return res;
    }
};

/* 迭代 */

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

Python3:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

# 递归
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        levels = []
        self.lorder(root, 0, levels)

        return levels

    def lorder(self, cur, level, levels):
        if cur == None: return 
        if len(levels) == level:
            levels.append([])
        levels[level].append(cur.val)
        self.lorder(cur.left, level+1, levels)
        self.lorder(cur.right, level+1, levels)

# 迭代
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
        return result

107. 二叉树的层序遍历 II - 力扣（LeetCode） 的解法：

C++:使用

reverse(res.begin(), res.end()); // 在这里反转一下数组即可

Python利用list的性质，[::-1]就好。

return levels[::-1]