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

思路：首先确定vector中最大值（查找最大值），将之赋值给节点n中的val（即需创建一个新的节点），然后根据最大值的位置划分左右两部分，然后分别对左右两部分进行相同操作（所以选用递归），返回的指针分别是节点n的左右子树的指针。所以需要知道递归的出口，即vector中只有一个数的时候是递归的出口，此时即为叶节点。

C++知识点：

1.使用STL的Vector时，利用函数 max_element，min_element，distance可以获取Vector中最大、最小值的值和位置索引，需要包括头文件<algorithm>。

2.创立新节点，需要利用new（原因未知），大致用法：

class A{
    int i;
public:
    A(int _i) :i(_i*_i) { }
    void Say()  { printf("i=%d/n", i); }
};
A* pa = new A(3); //调用new（摘自百度知道）

3.访问结构体成员，若生成是该结构体的指针，则利用“->”访问成员，若为实例，则用“.”进行访问。

4.vector的使用，包括如何生成vector的“子集”（vector初始化可以利用容器的指针进行初始化）。

代码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()==1){
            TreeNode* node = new TreeNode(nums[0]);
            return node;
        }
        vector<int>::iterator itmax = max_element(nums.begin(),nums.end());
        TreeNode* node = new TreeNode(*itmax);
        int pos=(int)(itmax-nums.begin());
        if(pos!=0){
            vector<int> leftsub(nums.begin(),nums.begin()+pos);
            node->left=constructMaximumBinaryTree(leftsub);
        }
        if(pos!=(nums.size()-1)){
            vector<int> rightsub(nums.begin()+pos+1,nums.end());
            node->right=constructMaximumBinaryTree(rightsub);
        }
        return node;
    }
};

代码2：

/**
 * 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()==1){
            TreeNode* root = new TreeNode(nums[0]);
            return root;
        }
        //else if(nums.size()==0){return NULL;}
        vector<int>::iterator biggest=max_element(nums.begin(),nums.end());
        TreeNode* root = new TreeNode(*biggest);
        //int pos=(int)(biggest-nums.begin());
        if(biggest!=nums.begin()){
            vector<int> leftsub(nums.begin(),biggest);
            root->left=constructMaximumBinaryTree(leftsub);
        }
        if(biggest!=nums.end()-1){
            vector<int> rightsub(biggest+1,nums.end());
            root->right=constructMaximumBinaryTree(rightsub);
        }
        return root;
    }
};

代码3（http://blog.youkuaiyun.com/linshuqun4/article/details/77972428）：

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

代码3的思路：从第一个数开始，新加入的数比前一个的小，该数一定是前一个的右子树成员，加入碰到一个比前一个的大，根据划分的办法，得一直比较当前的一个是不是根节点，若不是则找到对应位置插入。（时间差不多）