【leetcode/BST】二叉搜索树——删除

 问题描述：

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

1. 首先找到需要删除的节点；
2. 如果找到了，删除它。

说明： 要求算法时间复杂度为 O(h)，h 为树的高度。

示例:

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

    5
   / \
  3   6
 / \   \
2   4   7

给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。

一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。

    5
   / \
  4   6
 /     \
2       7

另一个正确答案是 [5,2,6,null,4,null,7]。

    5
   / \
  2   6
   \   \
    4   7

基本思路：

从问题的描述中我们不难看出，删除一个节点后的二叉搜索树有多种多样，我们最好还是选择删除节点后对原来的树影响最小的。这个在上面的例子中毫无疑问是第一种。leetcode前面也有这种算法的描述：

1. 如果待删除的节点是叶子节点，那就直接删除。
2. 如果待删除的节点只有一个子树，那就把子树提到原来节点的位置上（这当然也删除了那个节点）
3. 如果待删除的节点有两个子树，那就把该节点和这个节点的后继交换，然后删除该节点。

我下面的算法是严格遵循这一个步骤的，他有以下几个槽点：

1. 之前讲过，二叉树是有向图，BST也是如此。而且和链表的操作一样，我们删除一个节点，必须要知道他的前继。在BST中体现为其父节点，所以在搜索的过程中，我们不得不保存其父节点——更要命的是，我们必须处理根节点，他是唯一没有父节点的节点了。
2. 不过这个程序还有一个值得称道的地方——之前有提到过要交换两个节点，我这里并没有直接交换两个节点。考虑到节点的值只是普通的int类型，我就直接交换了该节点和其后继节点的值，并把p指向其后继节点。再交由后面的删除叶子节点的程序处理。

AC代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void SearchNode(TreeNode *root, int val, TreeNode *&target, TreeNode *&parent) {
    // 寻找相应的节点（这种题就属于自顶向下的递归）
      // 找不到返回NULL
      if (!root) {
        target = NULL;
        parent = NULL;
        return;
      }
      // 找到了返回该节点对应的子树
      if (root->val == val) {
        target = root;
        return;
      }
      (root->val < val)? SearchNode(root->right, val, target, parent = root) 
                              : SearchNode(root->left, val, target, parent = root); 
    }
  
    TreeNode *Successor(TreeNode *root, TreeNode *parent) {
    // 找到下一个值比他大的节点
    // 如果有右子树就到右子树中找最左的节点
    // 如果没有的话就是其父节点
      if (root->right) {
        auto p = root->right;
        stack<TreeNode *> s;
        // 搜索最左边的节点
        while (p) {
          s.push(p);
          p = p->left;
        }
        return s.top();
      } else {
        return parent;
      }        
    }
  
    TreeNode* deleteNode(TreeNode* root, int key) {
    // 删除相应的节点
      TreeNode *q;    // 相应的节点
      TreeNode *parent = NULL;   // 相应节点的父节点
      SearchNode(root, key, q, parent);
      if (!q) return root;    // 如果没有找到相应的节点直接返回没有修改过的树
      // 如果这个节点即有左子树又有右子树（因为可以和既无左子树又无右子树的节点一起处理）
      if (q->left && q->right) {
        auto next = Successor(q, parent);
        // swap(q->val, next->val);     // 错误的原因：你这里交换元素，其实已经破坏了原来BST的结构，所以不行了
        auto temp = q;
        SearchNode(root, next->val, q, parent);
        temp->val = next->val;
      }
      // 既无左子树又无右子树的情况
      if (!q->left && !q->right) {
        if (!parent) return NULL;   // 如果删除的是没有子树的根节点
        if (parent->left == q) {
          parent->left = NULL;
        } else {
          parent->right = NULL;
        }
      } else {    // 最后一种情况，只有一个左子树或者右子树
        TreeNode *child_node;
        // 获得其子树
        if (q->left) {
          child_node = q->left;
        } else {
          child_node = q->right;
        }
        if (!parent) return child_node;   // 如果删除的是只有一个子树的根节点
        // 转移其子树(删除p)
        if (parent->left == q) {
          parent->left = child_node;
        } else {
          parent->right = child_node;
        }
      }
      return root;
    }
};

可以改进的地方：

不得不说叶神真的有眼光，它推荐的书中的代码真的极为优雅，这是我从leetcode高分解答中直接抄的，虽然使用的是java，但是并没有什么关系。

它值得称道的地方就在于——它使用递归删除节点。最大的好处就是我们不用考虑头结点的问题了

每次递归时，只考虑头结点是否是要删除的节点——这样也避免考虑了头结点没有先继的特殊情况。

代码如下：

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if (root == null) {
            return null;
        }
        if (key < root.val) {
            // 待删除节点在左子树中
            root.left = deleteNode(root.left, key);
            return root;
        } else if (key > root.val) {
            // 待删除节点在右子树中
            root.right = deleteNode(root.right, key);
            return root;
        } else {
            // key == root.val，root 为待删除节点
            if (root.left == null) {
                // 返回右子树作为新的根
                return root.right;
            } else if (root.right == null) {
                // 返回左子树作为新的根
                return root.left;
            } else {
                // 左右子树都存在，返回后继节点（右子树最左叶子）作为新的根
                TreeNode successor = min(root.right);
                successor.right = deleteMin(root.right);
                successor.left = root.left;
                return successor;
            }
        }
    }

    private TreeNode min(TreeNode node) {
        if (node.left == null) {
            return node;
        }
        return min(node.left);
    }

    private TreeNode deleteMin(TreeNode node) {
        if (node.left == null) {
            return node.right;
        }
        node.left = deleteMin(node.left);
        return node;
    }

其他经验：

最近一段时间也写了不少题了，我愈加发现有些东西伪代码和实际的代码差别还是挺大的。

如果遵循伪代码的逻辑，确实也写的出来，程序可能也更加看得懂。但是实际的代码更为简洁和优雅。

可以改进的地方就在于：

一个代码块并不把所有的东西全部完成，可以交给其他代码来做。

比如之前的树三（4）种遍历合并的while，和我这里的AC代码中的交给处理叶子节点的代码。

其实递归，本质上也是这种东西。

这个还是有点深奥了，需要继续写，细细品味。