LeetCode OJ 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

Subscribe to see which companies asked this question

解答：

啊哈这个操作好常规啊……假设这个函数可以在以root为根节点的子树中删除值为key的节点并返回新的BST的根节点，先通过BST的性质递归找到待删除节点，如果是叶节点就直接删，如果左右子节点有NULL就直接删了把下面的子树接上去，如果是左右子节点均存在就把中缀后继的值换上来然后在右子树中继续调用函数删除中缀后继的那个节点，最后递归返回。注意递归延查找路径返回时，一定要先将递归调用的返回值赋值给上一层调用中的树的节点，而不是单纯的返回递归调用的返回值，即应该是：

else if(key < root->val){
        root->left = deleteNode(root->left, key);
    }
    else{
        root->right = deleteNode(root->right, key);
    }
    return root;

而不是

else if(key < root->val){
        return deleteNode(root->left, key);
    }
    else{
        return deleteNode(root->right, key);
    }

因为如果按第二种那样返回的话最后得到的根节点有可能只是原来整棵树的一部分……

当然啦，作为树的题目，一如既往的应该考虑root为NULL的情况……

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* deleteNode(struct TreeNode* root, int key) {
    struct TreeNode *tmp;

    if(NULL == root)
        return NULL;

    if(root->val == key){
        if(NULL == root->left&&NULL == root->right){
            return NULL;
        }
        else if(NULL == root->left){
            return root->right;
        }
        else if(NULL == root->right){
            return root->left;
        }
        else{
            tmp = root->right;
            while(NULL != tmp->left){
                tmp = tmp->left;
            }
            root->val = tmp->val;
            root->right = deleteNode(root->right, tmp->val);
        }
    }
    else if(key < root->val){
        root->left = deleteNode(root->left, key);
    }
    else{
        root->right = deleteNode(root->right, key);
    }
    return root;
}