LeetCode 102. 二叉树的层次遍历（C、C++、python）

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

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

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

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

C

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *columnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

int depth(struct TreeNode* root)
{
    if(NULL==root)
    {
        return 0;
    }
    else
    {
        int tmp1=depth(root->left)+1;
        int tmp2=depth(root->right)+1;
        return tmp1>tmp2?tmp1:tmp2;
    }
}

void func(struct TreeNode* root,int** res,int** columnSizes,int n)
{
    if(NULL==root)
    {
        return;
    }
    else
    {
        res[n][(*columnSizes)[n]]=root->val;
        (*columnSizes)[n]++;
        func(root->left,res,columnSizes,n+1);
        func(root->right,res,columnSizes,n+1);
    }
}

int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize) 
{
    int num=depth(root);
    int** res=(int**)malloc(sizeof(int*)*num);
    for(int i=0;i<num;i++)
    {
        res[i]=(int*)malloc(sizeof(int)*1000);
    }
    *columnSizes=malloc(sizeof(int)*num);
    for(int i=0;i<num;i++)
    {
        (*columnSizes)[i]=0;
    }
    func(root,res,columnSizes,0);
    *returnSize=num;
    return res;
}

C++

/**
 * 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:
    void func(TreeNode* root, vector<vector<int>>& res, int n)
    {
        if(NULL==root)
        {
            return;
        }
        else
        {
            if(n==res.size())
            {
                res.push_back({});
            }
            res[n].push_back(root->val);
            func(root->left,res,n+1);
            func(root->right,res,n+1);
        }
    }

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

python

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

class Solution:
    def func(self,root,res,n):
        if None==root:
            return res
        else:
            if n==len(res):
                res.append([])
            res[n].append(root.val)
            res=self.func(root.left,res,n+1)
            res=self.func(root.right,res,n+1)
            return res
    
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res=[]
        res=self.func(root,res,0)
        return res