【东华大学oj】最大二叉树

最大二叉树

时间限制: 1s

类别: DS：树->力扣

问题描述

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

   创建一个根节点，其值为 nums 中的最大值。

   递归地在最大值 左边 的 子数组构建左子树。

   递归地在最大值 右边 的 子数组构建右子树。

返回 nums 构建的 最大二叉树 。

示例 1：

输入：

6

3 2 1 6 0 5

输出：

6 3 5 null 2 0 null null 1

解释：递归调用如下所示：

- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。

   - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。

       - 空数组，无子节点。

       - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。

           - 空数组，无子节点。

           - 只有一个元素，所以子节点是一个值为 1 的节点。

   - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。

       - 只有一个元素，所以子节点是一个值为 0 的节点。

       - 空数组，无子节点。

示例 2：

3

   \

      2

          \

            1

输入：

3

3 2 1

输出：

3 null 2 null 1

输入说明

首先输入数组的元素个数n

然后输入n个结点的数据。

提示：

    1 <= nums.length <= 1000

    0 <= nums[i] <= 1000

    nums 中的所有整数 互不相同

输出说明

输出结果，需要填充为空的结点，输出null，每个数据的后面跟一个空格。

#include <vector>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;

class TreeNode
{
public:
    int val;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int _val) : val(_val), left(nullptr), right(nullptr) {}
};

class Solution
{
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums)
    {
        return traverse(nums, 0, nums.size() - 1);
    }

private:
    TreeNode* traverse(vector<int>& nums, int left, int right)
    {
        if (left > right) return nullptr;

        int max = INT_MIN;
        int mid = 0;
        for (int i = left; i <= right; i++)
        {
            if (nums[i] > max)
            {
                max = nums[i];
                mid = i;
            }
        }

        TreeNode* root = new TreeNode(max);
        root->left = traverse(nums, left, mid - 1);
        root->right = traverse(nums, mid + 1, right);
        return root;
    }
};
void printTree(TreeNode* root) {
    queue<TreeNode*> q;
    if (root != nullptr) {
        q.push(root);
    }

    bool hasNextLevel = true; // Initialize with the assumption of having nodes in the next level

    while (!q.empty() && hasNextLevel) {
        int levelSize = q.size();  // Number of nodes at current level
        hasNextLevel = false; // Reset the flag for the next level

        for (int i = 0; i < levelSize; ++i) {
            TreeNode* node = q.front();
            q.pop();

            if (node == nullptr) {
                cout << "null ";
            } else {
                cout << node->val << " ";

                // Push children to the queue even if they are null
                q.push(node->left);
                q.push(node->right);

                // If there's at least one non-null child, set the flag
                if (node->left != nullptr || node->right != nullptr) {
                    hasNextLevel = true;
                }
            }
        }
    }
}

int main()
{
    int n;
    cin >> n;

    vector<int> nums(n);
    for (int i = 0; i < n; i++)
    {
        cin >> nums[i];
    }

    Solution solution;
    TreeNode* root = solution.constructMaximumBinaryTree(nums);

    printTree(root);
    cout << endl;

    return 0;
}