《算法导论》第12章 二叉查找树 (2)查找、插入与删除

1. 查找

利用二叉查找树左小右大的性质，可以很容易实现查找任意值和最大/小值。

[cpp]  view plain copy

1. BSTNode * bst_search(BSTNode *node, int key)  
2. {  
3.      while (node && key != node->key) {  
4.           if (key < node->key)  
5.                node = node->left;  
6.           else  
7.                node = node->right;  
8.      }  
9.      return node;  
10. }  
11.   
12. BSTNode * bst_minimum(BSTNode *node)  
13. {  
14.      while (node->left != NULL)  
15.           node = node->left;  
16.      return node;  
17. }  

2. 插入

插入新结点的逻辑比较简单，关键是确定插入位置。

1. 首先为新结点分配内存并初始化。

2. 从根结点开始比较，小于已存在结点的键值则继续与其左子结点比较，

     否则与其右子结点比较。一直这样比较到叶子结点从而确定插入位置。

3. 将新结点与此叶子结点关联。

[cpp]  view plain copy

1. void bst_insert(BSTNode **root, int key, char *val)  
2. {  
3.      // 1.New node inserted to BST  
4.      BSTNode *newNode = malloc(sizeof(BSTNode));  
5.      newNode->left = newNode->right = NULL;  
6.      newNode->key = key;  
7.      newNode->value = val;  
8.       
9.      // 2.Locate insert location  
10.      BSTNode *pNode = NULL;  
11.      BSTNode *node = *root;  
12.      while (node != NULL) {  
13.           pNode = node;  
14.           if (key < node->key)  
15.                node = node->left;  
16.           else  
17.                node = node->right;  
18.      }  
19.       
20.      // 3.Link newNode to pNode  
21.      newNode->parent = pNode;  
22.   
23.      // Link pNode to newNode  
24.      if (pNode == NULL)  
25.           *root = newNode;  
26.      else if (key < pNode->key)  
27.           pNode->left = newNode;  
28.      else  
29.           pNode->right = newNode;           
30. }  

3. 删除

3.1 三种情况

删除二叉查找树中的结点稍微复杂一些，根据要删除结点的孩子结点的个数

，可以分为三种情况来处理：（假定要删除的结点为Z）

1. 结点Z没有孩子结点，那么直接删除Z就行了。

2. 结点Z有一个孩子结点，那么删除Z，将Z的父结点与此孩子结点（子树）关联就可以了。

（图中的a和b）

3. 结点Z有两个孩子结点，删除Z该怎样将Z的父结点与这两个孩子结点关联呢？

这种情况下不能直接删除Z，而是要用Z的后继（比Z的键值稍大的结点）来替代Z。

实现方法就是将后继从二叉树中删除，将后继的数据覆盖到Z中。

（图中的d）

图片来自《算法导论》第三版，与第二版的删除算法不太一样，而且多处理了一种特殊情况c，

即删除结点Z是二叉树的根结点。后面的删除代码是第二版的算法，在看删除代码前，先看

如何找到一个结点的后继。

3.2 后继

一个结点的后继是该结点的后一个，即比该结点键值稍大的结点。

所以，该结点右子树中的最小结点就是该结点的后继。如图结点7的后继就是9。

即可以直接从该结点的右子树中，沿左一直遍历到叶子结点从而找到最小值。

但如果该结点没有右孩子怎么办？例如结点13的后继。

结点没有右孩子，说明该结点在子树中是最大值。

那么就要找到13所在子树的父结点，并且：

1. 该子树的是这个父结点的左孩子。

2. 高度最低的这样的父结点。

[cpp]  view plain copy

1. BSTNode * bst_successor(BSTNode *node)  
2. {  
3.      if (node->right != NULL)  
4.           return bst_minimum(node);  
5.   
6.      BSTNode *sucNode = node->parent;  
7.      while (sucNode != NULL && node == sucNode->right) {  
8.           node = sucNode;  
9.           sucNode = sucNode->parent;  
10.      }  
11.      return sucNode;  
12. }  

3.3 删除

学会了如何找到任意结点的后继，现在接着说二叉查找树的结点删除。

对于情况3，要删除结点Z的左右孩子都存在的情况，要用Z的后继要替代Z。

这需要先删掉后继，那如果Z的后继也有两个孩子怎么办？

这种情况是不可能的。习题12.2-5要证明的就是：如果二叉查找树中的

某个结点有两个子女，则其后继没有左子女，其前趋没有右子女。

简单地想，后继的左子女比后继小，结点与后继之间是不可能有其他结点的。

删除的步骤：

1. 确定实际要删除的结点是Z还是Z的后继。

2. 实际删除结点的孩子，Z的左/右孩子或者后继的右孩子。

3. 将实际要删除结点的父结点与其孩子关联。

4. 如果实际删除的是后继，则把后继中的数据拷贝到Z，替换它。

[cpp]  view plain copy

1. BSTNode * bst_delete(BSTNode **root, BSTNode *delNode)  
2. {  
3.      // Real delete node: delNode or its successor  
4.      // (if delNode has both left and right child)  
5.      BSTNode *realDelNode;  
6.      if (delNode->left && delNode->right)  
7.           realDelNode = bst_successor(delNode);  
8.      else  
9.           realDelNode = delNode;  
10.   
11.      // Child of real delete node  
12.      BSTNode *childNode;  
13.      if (delNode->left)  
14.           childNode = realDelNode->left;  
15.      else  
16.           childNode = realDelNode->right;  
17.   
18.      // Link realDelNode child and parent  
19.      if (childNode)  
20.           childNode->parent = realDelNode->parent;  
21.   
22.      if (realDelNode->parent == NULL)  
23.           *root = childNode;  
24.      else if (realDelNode == realDelNode->parent->left)  
25.           realDelNode->parent->left = childNode;  
26.      else  
27.           realDelNode->parent->right = childNode;  
28.   
29.      // Copy successor data to delNode (override)  
30.      // if real delete node is not delNode but its successor           
31.      if (realDelNode != delNode) {  
32.           delNode->key = realDelNode->key;  
33.           delNode->value = realDelNode->value;  
34.      }  
35.   
36.      return realDelNode;  
37. }