删除二叉搜索树中的节点，时间60，内存50

struct TreeNode {
       int val;
       TreeNode *left;
       TreeNode *right;
       TreeNode() : val(0), left(nullptr), right(nullptr) {}
       TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
       TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
   };
class Solution {
 public:
     TreeNode* deleteNode(TreeNode* root, int key) {
         if(!root){
             return root;
         }
         stack<TreeNode*> s;
         vector<int> inorder;
         unordered_set<TreeNode*> hashset;
         s.push(root);
         while(!s.empty()){
             TreeNode* cur = s.top();
             if(cur->left!=NULL&&hashset.count(cur)==0){
                 s.push(cur->left);
                 hashset.insert(cur);
             }
             else{
                 inorder.push_back(cur->val);
                 s.pop();
                 if(cur->right!=NULL){
                     s.push(cur->right);
                 }
             }
         }

         TreeNode* node = root;
         TreeNode* pre = root;
         while(node){
             if(node->val == key){
                 break;
             }
             else if(node->val<key){
                 pre = node;
                 node = node->right;
             }
             else{
                 pre = node;
                 node = node->left;
             }
         }
         if(!node){
             return root;
         }
         //check left
         bool left = true;
         if(pre->val<node->val){
             left = false;
         }
         //check sons
         if(!node->left&&!node->right){
             if(node == pre){
                 root = NULL;
                 return root;
             }
             else{
                 if(left){
                     pre->left = NULL;
                 }
                 else{
                     pre->right = NULL;
                 }
             }
         }
         else if(node->left&&!node->right){
             if(node == pre){
                 root = root->left;
             }
             else{
                 if(left){
                     pre->left = node->left;
                 }
                 else{
                     pre->right = node->left;
                 }
             }
         }
         else if(!node->left&&node->right){
             if(node == pre){
                 root = root->right;
             }
             else{
                 if(left){
                     pre->left = node->right;
                 }
                 else{
                     pre->right = node->right;
                 }
             }
         }
         else{
             int index  = 0;
             for(;index<inorder.size();index++){
                 if(inorder[index]==key){
                     break;
                 }
             }
             if(index>0){
                 TreeNode* tnode = root;
                 TreeNode* tpre;
                 while(tnode){
                     if(tnode->val == inorder[index-1]){
                         break;
                     }
                     else if(tnode->val<inorder[index-1]){
                        tpre = tnode;
                         tnode = tnode->right;
                     }
                     else{
                         tpre = tnode;
                         tnode = tnode->left;
                     }
                 }
                 //check left
                 bool tleft = true;
                 if(tpre->val<tnode->val){
                     tleft = false;
                 }
                 if(tleft){
                     if(!tnode->left){
                         tpre->left = NULL;
                     }
                     else{
                         tpre->left = tnode->left;
                     }
                 }
                 else{
                     if(tnode->left){
                         tpre->right = tnode->left;
                     }
                     else{
                         tpre->right = NULL;
                     }
                 }
                 node->val = tnode->val;
             }
             else{
                 TreeNode* tnode = root;
                 TreeNode* tpre;
                 while(tnode){
                     if(tnode->val == inorder[index+1]){
                         break;
                     }
                     else if(tnode->val<inorder[index+1]){
                        tpre = tnode;
                         tnode = tnode->right;
                     }
                     else{
                         tpre = tnode;
                         tnode = tnode->left;
                     }
                 }
                 //check left
                 bool tleft = true;
                 if(tpre->val<tnode->val){
                     tleft = false;
                 }
                 if(tleft){
                     if(!tnode->left){
                         tpre->left = NULL;
                     }
                     else{
                         tpre->left = tnode->left;
                     }
                 }
                 else{
                     if(!tnode->right){
                         tpre->right = NULL;
                     }
                     else{
                         tpre->right = tnode->right;
                     }
                 }
                 node->val = tnode->val;

             }
         }
         return root;
     }
 };

遍历树，找出该节点和它的父节点，判断是父节点的哪一边

三个情况：

1 该节点是叶子节点：直接父节点这边指向NULL；

2 该节点有一个子节点：父节点指向它的子节点；

3 该节点有两个子节点：获取二叉树的前序遍历，在其中找出该节点的索引，通过索引-1或者+1，遍历二叉树，找到节点的需要替换的节点和替换节点的父节点：替换节点的父节点指向替换节点的子节点（必然只有一个或者没有），节点的值换成替换节点的值。