代码随想录算法训练营第二十二天|LeetCode235、LeetCode701、LeetCode450

LeetCode235

 解法1：（所有二叉树找公共祖先）

class Solution {
public:
    TreeNode* node;
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        TreeNode* leftnode = NULL;
        TreeNode* rightnode = NULL;
        if(root -> left) leftnode = lowestCommonAncestor(root -> left, p, q);
        if(root -> right) rightnode = lowestCommonAncestor(root -> right, p, q);
        if(root == NULL || root == p || root == q)  return root;
        if(leftnode && rightnode)  node = root;
        if(leftnode && !rightnode) return leftnode;
        if(rightnode && !leftnode) return rightnode;
        if(!rightnode && !leftnode) return NULL;
        return node;
    }
};

解法2：（利用二叉搜索树性质，从上到下找在pq区间里的第一个数）

class Solution {
public:
    void findnode(TreeNode* root, TreeNode* p, TreeNode* q,TreeNode* &x){
        if(root == NULL && x!= NULL) return ;
        if(root -> val >= min(p ->val,q->val) && root ->val <= max(p -> val,q ->val)){
           x = root;
           return;
        }
        if(root -> left) findnode(root -> left,p,q,x);
        if(root -> right) findnode(root -> right,p,q,x);
        return;

    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
       TreeNode* x =NULL;
       findnode(root,p,q,x);
       return x;
    }
};

解法三：（迭代法）

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
      while(root){
          if(root -> val < q ->val && root-> val < p -> val){
              root = root ->right;
          }
          if(root -> val > q ->val && root-> val > p -> val){
              root = root ->left;
          }
          if(root -> val >= min(q ->val, p -> val) &&root -> val <= max(q ->val, p -> val))
          {
              break;
          }
      }
      return root;
    }
};

leetcode 701

题目：

 解法1：

class Solution {
public:
    TreeNode* pre = NULL;
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if(root == NULL) {
            TreeNode* result = new TreeNode(val);
            return result;
        }
        TreeNode* result = root;
        while(1){
            if(root == NULL && pre != NULL){
                TreeNode* node = new TreeNode(val);
                if(pre -> val > val) pre -> left = node;
                if(pre -> val < val) pre -> right = node;
                break;
            }
            if(val < root -> val ) {
            pre = root;
            root = root ->left;
            continue;  
            }
            if(val > root -> val){
            pre = root;
            root = root ->right;
            continue;  
            }
        }
        return result;
    }
};

解法2：（递归）

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

LeetCode450

题目：

 

解法：（迭代法）

class Solution {
public:
    TreeNode* pre = new TreeNode(0);
    void findde(TreeNode* root, int key)
    {
        if(root == NULL) return;
        if(root -> val == key && pre != NULL) 
        {
                    TreeNode* node;
                    if(root -> left) 
                    {
                        node = root ->left;
                         if(pre -> left == root) pre ->left = node;
                         if(pre -> right == root)  pre ->right = node;
                        while(node -> right != NULL) node = node ->right;
                        node ->right = root -> right;
                    }
                    else if(root -> right){
                        node = root ->right;
                        if(pre -> left == root) pre ->left = node;
                        if(pre -> right == root)  pre ->right = node;
                    }
                    else if(!root -> left && !root -> right ){
                        if(pre -> left == root) pre ->left = NULL;
                        if(pre -> right == root) pre ->right = NULL;
                        return;
                }
            }
        pre = root;
        if(root ->left)  findde(root ->left,key);
        pre = root;
        if(root ->right)  findde(root ->right,key);
        pre = root;
        return;
        }

    TreeNode* deleteNode(TreeNode* root, int key) {   
        if(root == NULL) return NULL;
        pre -> left = root; 
        TreeNode* result = pre;
        findde(root,key);
        return result -> left;
    }
};

解法2：（递归法）

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {   
        if(root == NULL) return root;
        if(root -> val == key){
            if(root -> left == NULL && root -> right == NULL)
            {
                delete root;
                return NULL;
            }
            else if(root -> left == NULL){
                TreeNode* rnode = root -> right;
                delete root;
                return rnode;
            }
            else if(root -> right == NULL){
                TreeNode* lnode = root -> left;
                delete root;
                return lnode;
            }
            else if(root -> left && root ->right){
                TreeNode* node = root ->left;
                while(node -> right != NULL) node = node ->right;
                node ->right = root -> right;
                return root -> left;
            }
        }
        if(root -> left) root ->left = deleteNode(root ->left,key);
        if(root -> right) root ->right = deleteNode(root ->right,key);
        return root;
    }
};