代码随想录算法训练营第二十二天|● 235. 二叉搜索树的最近公共祖先 ● 701.二叉搜索树中的插入操作 ● 450.删除二叉搜索树中的节点

•  235. 二叉搜索树的最近公共祖先 

• class Solution {
  public:
      int l, r;
      TreeNode* solve(TreeNode* node) {
          TreeNode* left = NULL;
          TreeNode* right = NULL;
          if (node == NULL)
              return node;
          if (node->val <= r && node->val >= l)
              return node;
          if (node->val < l)
              right = solve(node->right);
          if (node->val > r)
              left = solve(node->left);
          if (left == NULL && right != NULL)
              return right;
          if (left != NULL && right == NULL)
              return left;
          else
              return NULL;
      }
      TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
          l = min(p->val,q->val), r = max(q->val,p->val);
          TreeNode* ret = solve(root);
          return ret;
      }
  };

•  701.二叉搜索树中的插入操作 

• class Solution {
  public:
      TreeNode* cur = NULL;
      int k;
      TreeNode* solve(TreeNode* node) {
          if (node == NULL) {
              TreeNode* cur = new TreeNode(k);
              return cur;
          }
          if(node->val>k)
          node->left = solve(node->left);
          if(node->val<k)
          node->right = solve(node->right);
          return node;
      }
      TreeNode* insertIntoBST(TreeNode* root, int val) {
          k = val;
          if(root==NULL)
          return new TreeNode(val);
          solve(root);
          return root;
      }
  };

•  450.删除二叉搜索树中的节点 

• class Solution {
  public:
      int k;
      TreeNode* solve(TreeNode* node) {
          if (node == NULL)
              return node;
          if (node->val == k) {
              if (node->left == NULL && node->right == NULL) {
                  
                  return NULL;
              }
              if (node->left != NULL && node->right == NULL) {
                 
                  return node->left;
              }
              if (node->left == NULL && node->right != NULL) {
                 
                  return node->right;
              }
              if (node->left != NULL && node->right != NULL) {
                  TreeNode* a = node->right;
                  while (a->left != NULL)
                      a = a->left;
                  a->left = node->left;
                 
                  node = node->right;
                
                  return node;
              }
          }
          if (node->val > k)
              node->left = solve(node->left);
          if (node->val < k)
              node->right = solve(node->right);
          return node;
      }
      TreeNode* deleteNode(TreeNode* root, int key) {
          k = key;
          if (root != NULL && !root->left && !root->right && root->val == key)
              return root->left;
         TreeNode* ret= solve(root);
          return ret;
      }
  };