每日一道算法题彩灯装饰记录 I-CSDN博客

本文链接：https://blog.csdn.net/weixin_65816128/article/details/140196588

题目

Python

# 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 decorateRecord(self, root: Optional[TreeNode]) -> List[int]:
        if not root:return []
        qu=[root]
        ans=[]
        while qu:
            cur=qu.pop(0)
            ans.append(cur.val)
            if cur.left:
                qu.append(cur.left)
            if cur.right:
                qu.append(cur.right)
        return ans

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:
    vector<int> decorateRecord(TreeNode* root) 
    {
        vector<int> ans;
        if(!root) return ans;

        queue<TreeNode*> qu;

        qu.push(root);
        while(!qu.empty())
        {
            TreeNode* cur=qu.front();
            qu.pop();
            ans.push_back(cur->val);
            if(cur->left) qu.push(cur->left);
            if(cur->right) qu.push(cur->right);
        }
        return ans;

    }
};

C语言

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* decorateRecord(struct TreeNode* root, int* returnSize) 
{
    int* ans=(int*)malloc(sizeof(int)*1100);
    if(root==NULL)
    {
        *returnSize=0;
        return ans;
    }

    struct TreeNode* qu[1100];
    struct TreeNode* cur;
    int size=0;
    int front=0;  
    int rear=0;

    qu[rear++]=root;
    while(front<rear)
    {
        cur=qu[front++];
        ans[size++]=cur->val;
        if(cur->left) qu[rear++]=cur->left;
        if(cur->right) qu[rear++]=cur->right;
    }
    *returnSize=size;
    return ans;

}