<medium> Leetcode Problem -- 654. Maximum Binary Tree

• Given an integer array with no duplicates. A maximum tree building on this array is defined as follow:

  1.The root is the maximum number in the array.
  2.The left subtree is the maximum tree constructed from left part subarray divided by the maximum number.
  3.The right subtree is the maximum tree constructed from right part subarray divided by the maximum number.

Construct the maximum tree by the given array and output the root node of this tree.

Example 1:

Input: [3,2,1,6,0,5]
Output: return the tree root node representing the following tree:

   6
 /   \
3     5
\    / 
 2  0   
   \
    1

• 分析：题目给定一个数组，要求以数组中的最大元素为根结点，并且以最大的数为中心，每个节点选择子序列的最大值来构建二叉树。
• 思路一：在数组最大值位置进行分割，分别处理左子树和右子树。

/**
 * 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:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if (nums.size()) return find(nums, 0, nums.size());
        return NULL;

    }
private:
    TreeNode* find(vector<int>& nums, int left, int right) {
        if (left >= right) return NULL;
        int max = nums[left];
        int index = left;
        for (int i = left; i < right; i++) {
            if (nums[i] >= max) {
                max = nums[i];
                index = i;
            }
        }
        TreeNode *head = new TreeNode(max);
        head -> left = find(nums, left, index);
        head -> right = find(nums, index + 1, right);
        return head;
    }
};

• 思路二：LeetCode高票解答。LeetCode这个解答使用了栈的思想，通过存储数组的状态来进行二叉树的构建，提高了时间效率。

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        vector<TreeNode*> stk;
        for (int i = 0; i < nums.size(); ++i)
        {
            TreeNode* cur = new TreeNode(nums[i]);
            while (!stk.empty() && stk.back()->val < nums[i])
            {
                cur->left = stk.back();
                stk.pop_back();
            }
            if (!stk.empty())
                stk.back()->right = cur;
            stk.push_back(cur);
        }
        return stk.front();
    }
};