Leetcode 450. Delete Node in a BST

Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST.

Basically, the deletion can be divided into two stages:

1. Search for a node to remove.
2. If the node is found, delete the node.

Note: Time complexity should be O(height of tree).

Example:

root = [5,3,6,2,4,null,7]
key = 3

    5
   / 
  3   6
 /    
2   4   7

Given key to delete is 3. So we find the node with value 3 and delete it.

One valid answer is [5,4,6,2,null,null,7], shown in the following BST.

    5
   / 
  4   6
 /     
2       7

Another valid answer is [5,2,6,null,4,null,7].

    5
   / 
  2   6
      
    4   7

解题思路：删除二叉查找树上的节点，要考虑到几种情况:
1)待删除的节点包含有左，右子树，那删除的时候，要找到后继节点，这个后继节点只可能在删除节点的右子树找。
2）待删除的节点只包含有一个子树，直接拿父亲节点与删除节点的子节点相连 
3）待删除节点是叶节点，那原来相连的节点就得赋为空

#include <stdio.h>

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* BST_search(TreeNode *node, int value, TreeNode *&parent){
    while(node){
        if (node->val == value){
            break;
        }
        parent = node;
        if (value < node->val){
            node = node->left;
        }
        else{
            node = node->right;
        }
    }
    return node;
}

void delete_node(TreeNode *parent, TreeNode *node){
    if (node->val < parent->val){
        if (node->left && !node->right){
            parent->left = node->left;
        }
        else if (!node->left && node->right){
            parent->left = node->right;
        }
        else{
            parent->left = NULL;
        }
    }
    else if(node->val > parent->val){
        if (node->left && !node->right){
            parent->right = node->left;
        }
        else if (!node->left && node->right){
            parent->right = node->right;
        }
        else{
            parent->right = NULL;
        }
    }
}

TreeNode* find_successor(TreeNode *node, TreeNode *&parent){
    parent = node;
    TreeNode *ptr = node->right;
    while(ptr->left){
        parent = ptr;
        ptr = ptr->left;
    }
    return ptr;
}

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        TreeNode *parent = NULL;
        TreeNode *node = BST_search(root, key, parent);
        if (!node){
            return root;
        }
        if (node->left && node->right){
            TreeNode *successor = find_successor(node, parent);
            delete_node(parent, successor);
            node->val = successor->val;
            return root;
        }
        if (parent){
               delete_node(parent, node);
               return root;
        }
           if (node->left){
               root = node->left;
        }
        else{
               root = node->right;
        }
        return root;
    }
};

void preorder_print(TreeNode *node,int layer){
    if (!node){
        return;
    }
    for (int i = 0; i < layer; i++){
        printf("-----");
    }
    printf("[%d]
", node->val);
    preorder_print(node->left, layer + 1);
    preorder_print(node->right, layer + 1);
}

int main(){
    for (int i = 1; i <= 7; i++){
        printf("key = %d
", i);
        TreeNode a(5);
        TreeNode b(3);
        TreeNode c(6);
        TreeNode d(2);
        TreeNode e(4);
        TreeNode f(7);
        a.left = &b;
        a.right = &c;
        b.left = &d;
        b.right = &e;
        c.right = &f;
        Solution solve;
        TreeNode *root = solve.deleteNode(&a, i);
        preorder_print(root, 0);
        printf("
");
    }
    return 0;
}