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

创建一个根节点，其值为nums中的最大值。
递归地在最大值左边的子数组前缀上构建左子树。
递归地在最大值右边的子数组后缀上构建右子树。
返回 nums 构建的最大二叉树 。

示例 1：

输入：nums = [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：

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

思路：

首先找最大树作为根节点，并记录索引，索引左边的为二叉树的左子树，右边为右子树，不断递归遍历左右两边。

struct TreeNode {
    int val;
    TreeNode* left; //左节点
    TreeNode* right; //右节点
    TreeNode(int x):val(x),left(NULL),right(NULL){} //构造函数，初始化val，left，right
};

class Solution {
public:
    //构建二叉树的函数，接受nums数组和左右边界
    TreeNode* buildtree(vector<int>& nums, int left, int right) {
        //如果左边界大于右边界，返回空节点
        if (left > right) {
            return NULL;
        }
        //取当前区间内最大数的下标
        int best = left;
        for (int i = left + 1; i <= right; i++) {
            if (nums[i] > nums[best]) {
                best = i;
            }
        }
        //用当前区间最大数构建新节点
        TreeNode* node = new TreeNode(nums[best]);
        //分别对左右区间递归调用buildtree函数
        node->left = buildtree(nums, left, best - 1);
        node->right = buildtree(nums, best + 1, right);
        //返回新节点
        return node;
    }
    //对二叉树进行层序遍历的函数
    vector<int> test(TreeNode* root) {
        queue<TreeNode*> que; //定义队列que
        if (root != NULL) {
            que.push(root); //如果根节点不为空，将根节点加入队列
        }
        vector<int> result; //定义返回结果result
        while (!que.empty()) { //当队列不为空时
            int size = que.size(); //获取队列大小
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front(); //获取队首元素
                result.push_back(node->val); //将队首元素的值加入result
                que.pop(); //弹出队首元素
                if (node->left)que.push(node->left); //如果该节点的左子节点不为空，将左子节点加入队列
                if (node->right)que.push(node->right); //如果该节点的右子节点不为空，将右子节点加入队列
            }
        }
        //返回结果result
        return result;
    }
};

//主函数
int main() {
    vector<int> nums = { 3, 2, 1, 6, 0, 5 }; //初始化nums数组
    Solution ss; //定义解决方案实例ss
    TreeNode* root = ss.buildtree(nums,0,nums.size()-1); //用buildtree函数构建二叉树，并将根节点指针赋给root
    vector<int> vec = ss.test(root); //用test函数对构建的二叉树进行层序遍历，结果存入vec
    for (vector<int>::iterator it = vec.begin(); it != vec.end();it++) {
        cout << *it << " "; //输出vec中的元素
    }
    cout << endl; //输出