day36_0654.最大二叉树

0654.最大二叉树

• 该题 部分没思路 部分有思路但不会写代码

• 因为自己写不出完整代码 所以笔记就看卡哥解答过程吧详细通俗易懂

• 我这里简单记录一下我都卡在什么地方了

• 基础版本三部曲

  • 确定递归函数的参数和返回值---------可以想到数据类型 但想不到为什么是主函数而不需要构造子函数进行递归

  参数就是传入的是存放元素的数组，返回该数组构造的二叉树的头结点，返回类型是指向节点的指针。

  代码如下：

  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（也就是数组），但逻辑比较清晰。

• 优化版本

  • 以上代码比较冗余，效率也不高，每次还要切割的时候每次都要定义新的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());
      }
  };
  

  • 版本对比分析

  可以发现上面的代码看上去简洁一些，主要是因为第二版其实是允许空节点进入递归，所以不用在递归的时候加判断节点是否为空

  第一版递归过程：（加了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 = constructMaximumBinaryTree(newVec);
  }
  

  第二版递归过程： （如下代码就没有加if判断）

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

  第二版代码是允许空节点进入递归，所以没有加if判断，当然终止条件也要有相应的改变。

  第一版终止条件，是遇到叶子节点就终止，因为空节点不会进入递归。

  第二版相应的终止条件，是遇到空节点，也就是数组区间为0，就终止了。