代码随想录算法训练营第二十天|● 654.最大二叉树 ● 617.合并二叉树 ● 700.二叉搜索树中的搜索 ● 98.验证二叉搜索树

•  654.最大二叉树 

• class Solution {
  public:
      TreeNode* solve(vector<int>& a) {
          TreeNode* node = new TreeNode(0);
          if (a.size() == 1) {
              node->val = a[0];
              return node;
          }
          int ma = -1;
          int index = -1;
          for (int i = 0; i < a.size(); i++) {
              if (a[i] > ma) {
                  ma = a[i];
                  index = i;
              }
          }
          node->val = a[index];
          if (index > 0) {
              vector<int> z(a.begin(), a.begin() + index);
              node->left = solve(z);
          }
          if (index < a.size() - 1) {
              vector<int> k(a.begin() + index+1, a.end());
              node->right = solve(k);
          }
          return node;
      }
      TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
          TreeNode* root = solve(nums);
          return root;
      }
  };

•  617.合并二叉树 

• class Solution {
  public:
      TreeNode* jiatree(TreeNode* r1, TreeNode* r2) {
          if (r1 == NULL)
              return r2;
          if (r2 == NULL)
              return r1;
          r1->val+=r2->val;
          r1->left = jiatree(r1->left, r2->left);
          r1->right = jiatree(r1->right, r2->right);
          return r1;
      }
      TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
          if(root1==NULL)
          return root2;
          jiatree(root1, root2);
          return root1;
      }
  };

•  700.二叉搜索树中的搜索 

• class Solution {
  public:
      TreeNode* dfs(TreeNode* node, int val) {
          if (node == NULL || node->val == val) {
              return node;
          }
          TreeNode* ret=NULL;
          if (node->val > val) {
             ret= dfs(node->left, val);
          } else
              ret=dfs(node->right, val);
          return ret;
      }
      TreeNode* searchBST(TreeNode* root, int val) {
          TreeNode* ret = dfs(root, val);
          return ret;
      }
  };

•  98.验证二叉搜索树 

• class Solution {
  public:
      int flag = 1;
      long long pre = -21474836480;
      void solve(TreeNode* node) {
          if (node == NULL)
              return;
          solve(node->left);
          if (pre >= node->val)
              flag = 0;
          pre = node->val;
          solve(node->right);
      }
      bool isValidBST(TreeNode* root) {
          if (root->left == NULL && root->right == NULL)
              return 1;
          solve(root);
          return flag;
      }
  };