二叉排序树

首先二叉排序树可以为空树，若不为空：

⑴若它的左子树不空，则左子树上所有结点的值均小于根结点的值；
⑵若它的右子树不空，则右子树上所有结点的值均大于根结点的值；
⑶ 它的左右子树也都是二叉排序树。

#include <iostream>
using namespace std;

template <class DataType> 
struct BiNode{   
   DataType data;     
   BiNode *lchild, *rchild;  
};

class BiSortTree {
private:
   void Release(BiNode *bt);
   BiNode *InsertBST(BiNode *bt , int x);  
   BiNode *SearchBST(BiNode *bt, int k); 
   
   void InOrder(BiNode *bt); //中序遍历函数调用
   BiNode *root; //二叉排序树的根指针
   
public:
    BiSortTree(int a[ ], int n); //建立查找集合a[n]的二叉排序树
     ~ BiSortTree( ){ Release(root); } //析构函数，同二叉链表的析构函数 
     
    void InOrder( ){InOrder(root);} //中序遍历二叉树
    BiNode *InsertBST(int x) {return InsertBST(root, x);} //插入记录x
    BiNode *SearchBST(int k) {return SearchBST(root, k);} //查找值为k的结点
    void DeleteBST(BiNode *p, BiNode *f ); //删除f的左孩子p

};

构造算法

BiSortTree::BiSortTree(int a[ ], int n)
{
	root = NULL;
	for (int i = 0; i < n; i++)
		root = InsertBST(root, a[i]);
}

二叉排序树的插入

分析：若二叉排序树为空树，则新插入的结点为新的根结点；否则，新插入的结点必为一个新的叶子结点，其插入位置由查找过程得到。

1.若二叉排序树为空树，则新插入的结点为新的根结点；
2.否则，如果插入的值比根节点值大，则在右子树中进行插入；
3.否则，在左子树中进行插入。

BiNode *BiSortTree::InsertBST(BiNode *bt, int x)
{
	if (bt == NULL) { //找到插入位置
		BiNode *s = new BiNode; 
		s->data = x;
		s->lchild = NULL;
		s->rchild = NULL;
		bt = s;
		return bt;
	}
	else if (bt->data > x) 
		bt->lchild = InsertBST(bt->lchild, x);
	else
		bt->rchild = InsertBST(bt->rchild, x);
}

void BiSortTree :: InOrder(BiNode *bt) 
{
    if (bt == nullptr) 
       return; //递归调用的结束条件
    else {
        InOrder(bt->lchild); //前序递归遍历bt的左子树
        cout << bt->data << "	"; //访问根结点bt的数据域
        InOrder(bt->rchild); //前序递归遍历bt的右子树 
    }
}

BiNode * BiSortTree :: SearchBST(BiNode *bt, int k)
{
     if (bt == nullptr) 
        return nullptr;
    if (bt->data == k) 
        return bt;
    else if (bt->data > k) 
              return SearchBST(bt->lchild, k);
         else 
             return SearchBST(bt->rchild, k);
}

BiNode *BiSortTree::InsertBST(BiNode *bt, int x)
{
    if (bt == nullptr) { //找到插入位置
      BiNode *s = new BiNode; 
      s->data = x;
      s->lchild = nullptr; 
      s->rchild = nullptr;
      bt = s;
      return bt;
   }
     else if (bt->data > x) 
           bt->lchild = InsertBST(bt->lchild, x);
          else 
          bt->rchild = InsertBST(bt->rchild, x);
}

BiSortTree::BiSortTree(int a[ ], int n)
{
       root = nullptr;
       for (int i = 0; i < n; i++)
          root = InsertBST(root, a[i]);
}

void BiSortTree::DeleteBST(BiNode *p, BiNode *f ) 
{
    if ((p->lchild == nullptr) && (p->rchild == nullptr)) { //p为叶子
       f->lchild = nullptr; delete p; return;
     }
   if (p->rchild == nullptr) { //p只有左子树
      f->lchild = p->lchild; 
      delete p;
       return;
    }
    if (p->lchild == nullptr) { //p只有右子树
      f->lchild = p->rchild; 
      delete p; 
      return;
     }
     BiNode *par = p, *s = p->rchild; //p的左右子树均不空
    while (s->lchild != nullptr) //查找最左下结点
       {
         par = s;
         s = s->lchild;
        }
      p->data = s->data;
   if (par == p) 
       par->rchild = s->rchild; //特殊情况，p的右孩子无左子树
   else 
        par->lchild = s->rchild; 
    delete s;
} 

void BiSortTree :: Release(BiNode *bt)
{
      if (bt == nullptr) 
         return;
      else{
        Release(bt->lchild); //释放左子树
        Release(bt->rchild); //释放右子树
        delete bt; //释放根结点
     }
}

int main()
{
      BiNode *p = nullptr;
      int arr[10] = {7 ,2, 3, 10, 5, 6, 1, 8, 9, 4};
      BiSortTree B{arr,10}; 
      B.InOrder();
      int key;
       cout << "请输入查找的元素值";
       cin >> key; 
     p = B.SearchBST(key);
       if (p != nullptr)
          cout << p->data << endl;
       else 
          cout << "查找失败" << endl;
     system("pause");
   return 0;
}

二叉排序树的删除

分三种情况讨论：
1.被删除的结点是叶子；
2.被删除的结点只有左子树或者只有右子树；
3.被删除的结点既有左子树，也有右子树。

二叉排序树的删除算法——伪代码

1.若结点p是叶子，则直接删除结点p；
2. 若结点p只有左子树， 则只需重接p的左子树；
若结点p只有右子树， 则只需重接p的右子树；
3. 若结点p的左右子树均不空，则
3.1 查找结点p的右子树上的最左下结点s及s双亲结点par；
3.2 将结点s数据域替换到被删结点p的数据域；
3.3 若结点p的右孩子无左子树，
则将s的右子树接到par的右子树上；
否则，将s的右子树接到结点par的左子树上；
3.4 删除结点s；

void BiSortTree::DeleteBST(BiNode<int> *p, BiNode<int> *f ) {
	 if (!p->lchild && !p->rchild) 	{   
              if(f->child==p)        f->lchild= NULL;  
              else  f->lchild= NULL; 
              delete p;
	  }
	 else if (!p->rchild) {     //p只有左子树
             if(f->child==p)   f->lchild=p->lchild;
             else f->rchild=p->lchild;
	               delete p;
	 }
	 else if (!p->lchild) {   //p只有右子树
		 if(f->child==p)  f->lchild=p->rchild;
		 else f->rchild=p->rchild;
            delete p;
        	}
        else {   //左右子树均不空
             par=p;  s=p->rchild;  
             while (s->lchild!=NULL)   //查找最左下结点
             {
               par=s;
               s=s->lchild;
             }
             p->data=s->data;
             if (par==p) p->rchild=s->rchild;  //处理特殊情况
                 else par->lchild=s->rchild;    //一般情况
             delete s;
           } //左右子树均不空的情况处理完毕
 }

二叉排序树的查找

在二叉排序树中查找给定值k的过程是：

⑴ 若root是空树，则查找失败；
⑵ 若k＝root->data，则查找成功；否则
⑶ 若k＜root->data，则在root的左子树上查找；否则
⑷ 在root的右子树上查找。
上述过程一直持续到k被找到或者待查找的子树为空，如果待查找的子树为空，则查找失败。
二叉排序树的查找效率在于只需查找二个子树之一。

BiNode *BiSortTree::SearchBST(BiNode<int> *root, int k)
{
    if (root==NULL)
    return NULL；
    else if (root->data==k) 
              return root;
    else if (k<root->data) 
              return SearchBST(root->lchild, k);
    else 
	         return SearchBST(root->rchild, k);
}

二叉排序树的查找性能分析