代码随想录刷题打卡day22

1 最大二叉树

使用递归的思路构造二叉树，一般选择前序遍历对树进行构造，需要先构造中间节点，然后递归构造左子树和右子树。
三部曲

• 确定递归函数的参数和返回值
  参数传入的是存放元素的数组，返回该数组构造的二叉树的头结点，返回类型是指向节点的指针。TreeNode* constructMaximumBinaryTree(vector<int>& nums)
• 确定终止条件
  可能要考虑数字长度小于1的情况，如果递归遍历到传入数组的长度为1时，此时遍历到了叶子节点。
  此时需要返回最后这一个值，需要按照节点的形式进行返回

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;
      }
  }
  TreeNode* node = new TreeNode(0);
  node->val = maxValue;
  

  • 最大值所在下标左区间构造左子树，数组长度应该大于0

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

  • 最大值所在下标右区间构造右子树，数组长度应该大于0

  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;
    }
};

2 合并二叉树

前序遍历，同时进行加法

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        // 重新定义新的节点，不修改原有两个树的结构
        TreeNode* root = new TreeNode(0);
        root->val = t1->val + t2->val;
        root->left = mergeTrees(t1->left, t2->left);
        root->right = mergeTrees(t1->right, t2->right);
        return root;
    }
};

3 二叉搜索树中的搜索

二叉搜索树是一个有序树：

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉搜索树
  迭代法进行求解，因为左小右大，一路查下去就ok了

TreeNode* searchBST(TreeNode* root, int val) {
    while (root != NULL) {
        if (root->val > val) root = root->left;
        else if (root->val < val) root = root->right;
        else return root;
    }
    return NULL;
}

4 验证二叉搜索树

中序遍历为一个数组，然后看这个数组是否有序

class Solution {
private:
    vector<int> vec;
    void traversal(TreeNode* root) {
        if (root == NULL) return;
        traversal(root->left);
        vec.push_back(root->val); // 将二叉搜索树转换为有序数组
        traversal(root->right);
    }
public:
    bool isValidBST(TreeNode* root) {
        vec.clear(); // 不加这句在leetcode上也可以过，但最好加上
        traversal(root);
        for (int i = 1; i < vec.size(); i++) {
            // 注意要小于等于，搜索树里不能有相同元素
            if (vec[i] <= vec[i - 1]) return false;
        }
        return true;
    }
};