leetcode 654 学习笔记（递归）

654.最大二叉树

问题描述：传送门

思路：

1、递归

① 确定递归函数的参数和返回值

参数：存放元素的数组。
返回值：返回该数组构造的二叉树的头结点
返回类型：指向节点的指针

TreeNode* constructMaximumBinaryTree(vector<int>& nums)

②确定终止条件

题目中说了输入的数组大小一定是大于等于1的，所以我们不用考虑小于1的情况。

那么当递归遍历的时候，如果传入的数组大小为1，说明遍历到了叶子节点

即应定义一个新的节点，并把这个数组的数值赋给新的节点，然后返回这个节点。

表示一个数组大小是1的时候，构造了一个新的节点，并返回。

代码如下：

TreeNode* node = new TreeNode(0);
if (nums.size() == 1) {
    node->val = nums[0];
    return node;
}

③ 确定单层递归的逻辑
分三步解决：
1、先要找到数组中最大的值和对应的下表

最大的值构造根节点，下表分割数组。

int maxValue = 0;
int maxValueIndex = 0;
for (int i = 0; i < nums.size(); i++) {
    if (nums[i] > maxValue) {
        maxValue = nums[i];
        maxValueIndex = i;
    }
}
TreeNode* node = new TreeNode(0);
node->val = maxValue;

2、找到最大值所在的下表左区间，构造左子树

这里要判断maxValueIndex > 0，因为要保证左区间至少有一个数值。

if (maxValueIndex > 0) {
    vector<int> newVec(nums.begin(), nums.begin() + maxValueIndex);
    node->left = constructMaximumBinaryTree(newVec);
}

3、找到最大值所在的下表右区间，构造右子树

判断maxValueIndex < (nums.size() - 1)，确保右区间至少有一个数值。

代码如下：

	if (maxValueIndex < (nums.size() - 1)) {
    vector<int> newVec(nums.begin() + maxValueIndex + 1, nums.end());
    node->right = constructMaximumBinaryTree(newVec);
}

整体代码如下：

class Solution {
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        TreeNode* node = new TreeNode(0);
        if (nums.size() == 1) {
            node->val = nums[0];
            return node;
        }
        // 找到数组中最大的值，及对应下表
        int maxValue = 0;
        int maxValueIndex = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > maxValue) {
                maxValue = nums[i];
                maxValueIndex = i;
            }
        }
        node->val = maxValue;
        // 最大值所在的下表左区间 构造左子树
        if (maxValueIndex > 0) {
            vector<int> newVec(nums.begin(), nums.begin() + maxValueIndex); 
            node->left = constructMaximumBinaryTree(newVec);
        }
        // 最大值所在的下表右区间 构造右子树
        if (maxValueIndex < (nums.size() - 1)) {
            vector<int> newVec(nums.begin() + maxValueIndex + 1, nums.end());
            node->right = constructMaximumBinaryTree(newVec);
        }
        return node;
    }
};

以上代码虽然逻辑清晰，但比较冗余，在构造左子树和右子树时，都要定义新的vector。

优化：下表索引直接在原数组上操作。

优化后代码如下：

class Solution {
private:
    // 在左闭右开区间[left, right)，构造二叉树
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left >= right) 
        	return nullptr;
        // 分割点下表：maxValueIndex
        int maxValueIndex = left;
        for (int i = left + 1; i < right; ++i) {
            if (nums[i] > nums[maxValueIndex]) 
            	maxValueIndex = i;
        }
        TreeNode* root = new TreeNode(nums[maxValueIndex]);

        // 左闭右开：[left, maxValueIndex)
        root->left = traversal(nums, left, maxValueIndex);

        // 左闭右开：[maxValueIndex + 1, right)
        root->right = traversal(nums, maxValueIndex + 1, right);

        return root;
    }
public:
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());
    }
};

by the way：

第一种方案和第二种方案的不同之处，在于第一用if语句不让空节点进入递归：

if (maxValueIndex > 0) { // 这里加了判断是为了不让空节点进入递归
    vector<int> newVec(nums.begin(), nums.begin() + maxValueIndex); 
    node->left = constructMaximumBinaryTree(newVec);
}

if (maxValueIndex < (nums.size() - 1)) { // 这里加了判断是为了不让空节点进入递归
    vector<int> newVec(nums.begin() + maxValueIndex + 1, nums.end());
    node->right = constructMax

第二就没有：

root->left = traversal(nums, left, maxValueIndex);

root->right = traversal(nums, maxValueIndex + 1, right);

第一个方案终止条件，是遇到叶子节点就终止，因为空节点不会进入递归。第二是遇到空节点，也就是数组区间为0，就终止了。