654. Maximum Binary Tree

https://leetcode.com/problems/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

Note:

1. The size of the given array will be in the range [1,1000].

/**
 * 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) {}
 * };
 */

---

算法思路：

方法1:递归构建

// O(n^2) --> 如果划分比较合理，那么时间复杂度接近O(nlogn)，最坏O(n^2)
class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        // array with no duplicates
        return constructBinaryTree(nums, 0, nums.size() - 1);
    }
private:
    TreeNode* constructBinaryTree(vector<int>& nums, int left, int right) {
        if (left > right) return nullptr;
        if (left == right) return new TreeNode(nums[left]);
        
        int maxVal = -1; int p;
        for (int i = left; i <= right; i++) {
            if (nums[i] > maxVal) {
                maxVal = nums[i];
                p = i;
            }
        }
        
        TreeNode* root = new TreeNode(maxVal);
        root->left = constructBinaryTree(nums, left, p - 1);
        root->right = constructBinaryTree(nums, p + 1, right);
        
        return root;
    }
};

方法2：维护一个从栈底到栈顶单调递小的树节点栈（广义上的栈，可以使用一个stack，也可以使用vector实现）

// 维护一个从栈底到栈顶单调递小的树节点栈
// O(n) --> 均摊法时间复杂度分析
class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        stack<TreeNode*> stk;
        for (int i = 0, n = nums.size(); i < n; i++) {
            TreeNode* node = new TreeNode(nums[i]);
            while (!stk.empty() && stk.top()->val < nums[i]) {
                node->left = stk.top();  // 存在更新，保证接到左边最大的
                stk.pop();
            }
            if (!stk.empty()) {
                stk.top()->right = node; // 存在更新，保证接到右边最大的
            }
            stk.push(node);
        }
        TreeNode* root;
        while (!stk.empty()) {
            root = stk.top(); stk.pop();
        }
        return root;
    }
};

// 维护一个从栈底到栈顶单调递小的树节点栈
class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        vector<TreeNode*> stk;
        for (int i = 0, n = nums.size(); i < n; i++) {
            TreeNode* node = new TreeNode(nums[i]);
            while (!stk.empty() && stk.back()->val < nums[i]) {
                node->left = stk.back();  // 存在更新，保证接到左边最大的
                stk.pop_back();
            }
            if (!stk.empty()) {
                stk.back()->right = node; // 存在更新，保证接到右边最大的
            }
            stk.push_back(node);
        }
        return stk[0];
    }
};