数据结构-二叉搜索树(BST binary search tree)

本文由@呆代待殆原创，转载请注明出处：http://www.cnblogs.com/coffeeSS/

二叉搜索树简介

顾名思义，二叉搜索树是以一棵二叉树来组织的，这样的一棵树可以用一个链表数据结构来表示，每个节点除了key和卫星数据（除了二叉树节点的基本数据以外人为添加的数据，这些数据和树的基本结构无关），还有left、right、parent，分别指向节点的左孩子、右孩子和父节点，如果对应的节点不存在则指向NIL节点（因为最简单的二叉搜索树中的NIL节点里并没有有用的信息，所以在实现的时候简单的指向null也可以，本文的代码部分就会这么处理）。

二叉搜索树的性质

1，任意节点x，其左子树中的key不大于x.key，其右子树中的key不小于x.key。

2，不同的二叉搜索树可以代表同一组值的集合。

3，二叉搜索树的基本操作和树的高度成正比，所以如果是一棵完全二叉树的话最坏运行时间为Θ(lgn)，但是若是一个n个节点连接成的线性树，那么最坏运行时间是Θ(n)。

4，根节点是唯一一个parent指针指向NIL节点的节点。

5，每一个节点至少包括key、left、right与parent四个属性，构建二叉搜索树时，必须存在针对key的比较算法。

下面给出一张wiki百科上的二叉搜索树的图示

二叉搜索树的操作

二叉搜索树的基本结构（C++）

 //节点结构
 struct Node{
     Node(int k=):key(k){}
     Node* parent = nullptr;
     Node* left = nullptr;
     Node* right = nullptr;
     int key;
 };
 //我把二叉搜索相关的基本方法放到了一个类里
 class MyBST{
 private:
     Node* root=nullptr;
 public:
     MyBST(){};
     MyBST(vector<int> v);
     Node* getRoot(){ return root; }
     void insertNode(int k);
     void deleteNode(int k);
     Node* findByKey(int k);
     Node* findSuccessor(int k);//寻找后继节点
     Node* findPredecessor(int k);//寻找前驱节点
     void traversal(Node* root, void(*f)(int k) = [](int k)->void{cout <<k << " "; });//遍历输出所有节点

     void insertNode(Node* n);
     void deleteNode(Node* n);
     Node* findSuccessor(Node* n);
     Node* findPredecessor(Node* n);
 };

基本的构造函数代码如下（另一个是是空的就当成内联函数写在声明里了，同样是内联函数的还有getRoot()）

 MyBST::MyBST(vector<int> v):MyBST(){
     for (auto n : v){
         insertNode(n);
     }
 }

下面我们来实现类中所有的方法，并同时了解二叉搜索树操作的细节。

查找操作

查找具有特定key的节点

当我们要查找一个具有给定key的节点时，我们从根节点开始与节点的key值进行比较，若是小于此节点的key则继续比对这个节点的左孩子的key，若是大于此节点的key，则继续比对这个节点的右孩子的key，直到key相等返回节点，或者查找失败，节点不存在返回null，这是一个明显类似递归查找的过程，但是我们可以用一个循环来代替这个递归过程，这样的效率更好一点。

 Node* MyBST::findByKey(int k){
     Node* temp = root;//获取根节点
     while (temp != nullptr){
         if (k == temp->key)//当key匹配的时候返回匹配节点
             return temp;
         temp = k < temp->key ? temp->left : temp->right;//通过比较key的值来决定搜索向哪一棵子树进行
     }
     cout << "can't find" << endl;
     return nullptr;
 }

查找特定节点的前驱

节点x的前驱，就是指key值小于x.key的节点中key值最大的那个，若x的左子树不为空，则x前驱是x节点左子树里最靠右的那个节点，如果x的左子树为空，那么我们就要向上找x的第一个有右孩子且左子树里没有x节点的祖先。（此时x就相当于这个祖先的后继，结合后继的查找方式来理解第二种情况会比较简单，看看图中两个节点的位置关系会很有助于理解）

 Node* MyBST::findPredecessor(Node* n){
     if (n->left != nullptr){//若x的左子树不为空，则x前驱是x节点左子树里最靠右的那个节点
         n = n->left;
         while (n->right != nullptr)
             n = n->right;
         return n;
     }
     while (n->parent != nullptr&&n->parent->left == n)//如果x的左子树为空，那么我们就要向上找x的第一个有右孩子且左子树里没有x节点的祖先
         n = n->parent;
     return n->parent;
 }

 Node* MyBST::findPredecessor(int k){
     return findPredecessor(findByKey(k));
 }

查找特定节点的后继

节点x的后继，就是指key值大于x.key的节点中key值最小的那个，若x的右子树不为空，则x后继是x节点右子树里最靠左的那个节点，如果x的右子树为空，那么我们就要向上找x的第一个有左孩子且右子树里没有x节点的祖先。（此时x就相当于这个祖先的前驱，结合前驱的查找方式来理解第二种情况会比较简单，所以前驱和后继的查找要两个一起看，因为如果x是y的前驱，那么y就是x的后继，所以画一个图来看他们的位置关系会有助于理解，可以试试上面那张二叉树的图例）

 Node* MyBST::findSuccessor(Node* n){
     if (n->right != nullptr){//若x的右子树不为空，则x后继是x节点右子树里最靠左的那个节点
         n = n->right;
         while (n->left != nullptr)
             n = n->left;
         return n;
     }
     while (n->parent != nullptr&&n->parent->right == n)//如果x的左子树为空，那么我们就要向上找x的第一个有右孩子且左子树里没有x节点的祖先
         n = n->parent;
     return n->parent;
 }
 Node* MyBST::findSuccessor(int k){
     return findSuccessor(findByKey(k));
 }

遍历操作

如果我们想按照key的从小到大的顺序遍历整个树，我们只要对树进行中序遍历即可，另外特别说明一下遍历函数的两个参数

void traversal(Node* root, void(*f)(int k) = [](int k)->void{cout <<k << " "; });//遍历输出所有节点

第一个参数是为了进行递归而设立的。

第二个参数是一个函数指针，这个函数指针指向一个没有返回值同时有一个int类型参数的函数，并且我用lamda表达式给这个函数指针赋了一个默认值，这个默认函数的功能是输出参数k，被我用来遍历输出每一个节点的key值，大家可以用别的lamda表达式或者函数来覆盖这个默认值，以达到定制功能的目的（和二叉搜索树的性质关系不大，是博主用来练手兼复习用的= =）

 void MyBST::traversal(Node* root, void(*f)(int k)){
     if (root == nullptr)
         return;
     traversal(root->left);
     f(root->key);
     traversal(root->right);
 }

插入操作

新插入的节点一定会取代一个原来的叶子节点，我们只要确定被取代的是哪一个叶子节点就行了，我们从根节点开始，利用二叉搜索树的性质比对key值来向下查找，直到到达最后的叶子节点，这个节点就是要用插入节点替换的叶子节点。

 void MyBST::insertNode(int k){
     Node* n = new Node(k);
     insertNode(n);
 }

 void MyBST::insertNode(Node* n){
     Node* temp = root;
     if (temp==nullptr){//树为空就设置根节点
         root = n;
         return;
     }
     while (true){//这个循环里有一个大的if-else结构，用来决定插入到左子树还是右子树
         if (temp->key > n->key){
             if (temp->left != nullptr)//里层各有一个if-else结构判断是否已经到达要插入的地方，到达则替换，没有则深入
                 temp = temp->left;
             else{
                 temp->left = n;//因为我们用null代替了NIL节点，所以替换时只需要修改两个指针
                 n->parent = temp;
                 return;
             }
         }
         else{
             if (temp->right != nullptr)
                 temp = temp->right;
             else{
                 temp->right = n;
                 n->parent = temp;
                 return;
             }
         }
     }
 }

删除操作

删除的情况比插入复杂，一共有3种可能的情况。

1，被删除的节点x没有NIL节点以外的孩子节点时，直接删除，修改父节点指针指向NIL节点即可。

2，被删除的节点x只有一个孩子时，用这个孩子节点替换被删除节点的位置即可。

3，被删除的节点x有两个孩子时，我们就要查找x节点的后继y节点，注意y节点一定在x节点的右子树中而且y节点没有左孩子，此时，我们先用y节点的右孩子代替y节点原先的位置，然后再用y节点代替x节点位置即可完成删除操作。（其实我们用x的前驱节点代替x也是可以的，不过本文只写一种情况，另一种情况是类似的，大家可以自行实现）

 void MyBST::deleteNode(Node* n){
     Node* temp;//用来存取代n节点位置的节点，下面的if分三种情况确定取代n节点位置的节点temp的取值
     if (n->left == nullptr&&n->right == nullptr)//情况一：n没有孩子节点
         temp = nullptr;
     else if (n->left == nullptr || n->right == nullptr){//情况二：n有一个孩子节点
         temp = (n->left == nullptr) ? n->right : n->left;//我们用这个孩子节点当做取代n的节点
         temp->parent = n->parent;//因为temp要取代n，所以要用temp复制n的属性，因为temp就是n的孩子节点之一，且另一个孩子节点是nullptr，所以n的孩子节点的信息不用复制
     }
     else{//情况三：n有两个孩子节点
         temp = findSuccessor(n);//我们用n节点的后继y当做取代n的节点
         Node* successor_right;//y只可能有一个右孩子或者没有孩子，我们先要让y的右孩子取代y，再让y取代n
         if (temp->right == nullptr)//如果y没有孩子，则用nullptr取代y
             successor_right = nullptr;
         else{
             successor_right = temp->right;
             successor_right->parent = temp->parent;//y有右孩子的时候要处理右孩子的父节点
         }

         if (temp->parent->left == temp)//这个if用来让y的父节点指向取代y的节点
             temp->parent->left = successor_right;
         else
             temp->parent->right = successor_right;
         //接下来要让y取代n了，其实我们只需要把y的key值给n就行了,然后直接退出，不需要再修改其他的部分了
         n->key = temp->key;
         delete temp;
         return;
     }
     //情况一和情况二到此为止取代n节点的temp已经确定，而且当temp不是nullptr的时候，temp也已经复制了必要的n的属性，剩下的就是让n的父节点指向temp了
     //注意被删除的节点有可能是根节点，所以当我们发现被删除的是根节点时，不需要让n的父节点指向temp，因为n没有父节点了，但是这个时候必须修改root指针的指向
     if (n->parent != nullptr){
         if (n->parent->left == n)
             n->parent->left = temp;
         else
             n->parent->right = temp;
     }
     else
         root = temp;//修改root指针的指向
     delete n;
 }

到此二叉搜索树基本相关操作实现完成，大家可以自行调试输出观察效果（记得加上必要的头文件哦）

参考资料：

1，《算法导论 中文版》（英文版第三版）（美）ThomasH.Cormen，CharlesE.Leiserson，RonaldL.Rivest，CliffordStein 著；王刚，邹恒明，殷建平，王宏志等译。

2，WIKI百科https://en.wikipedia.org/wiki/Binary_search_tree