二叉排序树

1.二叉树节点定义类型

typedef int KeyType;
typedef struct node 
{       KeyType key;            	  //关键字项
        struct node *lchild,*rchild; 	  //左右孩子指针
}  BSTNode;

2.BSTNode* SearchBST(BSTNode* bt, KeyType k);//查找,使用递归算法

//伪代码
BSTNode* SearchBST(BSTNode* bt, KeyType k)
{
    if (bt为空 || bt->key == k)
        返回 bt;//出口
    if (bt->key > k)
        返回 SearchBST(bt->lchild, k);
    else
        返回 SearchBST(bt->rchild, k);
}

//实现

BSTNode* SearchBST(BSTNode* bt, KeyType k)
{
    if (bt==NULL || bt->key == k)
        return bt;//出口
    if (bt->key > k)
        return SearchBST(bt->lchild, k);
    else
        return SearchBST(bt->rchild, k);
}

3.int InsertBST(BSTNode*& T, KeyType k);//插入节点

//伪代码

int InsertBST(BSTNode *&T，KeyType k)	
{ 
     if (T为空)	 //原树为空，建根节点
     {      创建新节点T;
            T->key=k;
            左右孩子置为null;
            return 1;
      }
      else if  (k==T->key) 	//存在相同关键字的结点，返回0
           return 0;
      else if (k<T->key) 
          return InsertBST(T->lchild，k);　	
      else  
          return InsertBST(T->rchild，k);  	
 }

//实现

int InsertBST(BSTNode *&T，KeyType k)	
{ 
     if (T == NULL)	 
     {      T=new BSTNode;
            T->key=k;
            T->lchild = T->rchild = NULL;
            return 1;
      }
      else if  (k==T->key) 	
           return 0;
      else if (k<T->key) 
          return InsertBST(T->lchild，k);　	
      else  
          return InsertBST(T->rchild，k);  	
 }

4.BSTNode* CreateBST(BSTNode* bt, KeyType a[], int n)//生成二叉排序树

//伪代码

BSTNode* CreateBST(BSTNode* bt, KeyType a[], int n)
{   int i=0;
    while (i < n) {
        InsertBST(bt, a[i]);
        i++;
    }
    返回bt;
}

//实现

BSTNode* CreateBST(BSTNode* bt, KeyType a[], int n)
{
    int i=0;
    while (i < n) {
        InsertBST(bt, a[i]);
        i++;
    }
    return bt;
}

//效果如图

4.删除指定节点

//伪代码

int DeleteBST(BSTNode *&T，KeyType k) //此函数是为了找到被删除节点
{ 
        if (T为空) return 0;	//空树删除失败
        else 
        {      if (k<T->key) return DeleteBST(T->lchild，k);	
                       //递归,在左子树中删除为k的结点
	           else if (k>T->key) return DeleteBST(T->rchild，k);
	               //递归,在右子树中删除为k的结点
               else  
               {       Delete(T);    //调用Delete(T)函数删除*T结点
	                   return 1;
              }
      }
} 

 void Delete(BSTNode *&p)   	 //从二叉排序树中删除结点，分情况处理
{     BSTNode *q;
      if (p结点无右子树)        	
      {    用其左孩子结点替换它
      }
      else if (p结点无左子树)    	
      {    用其右孩子结点替换它
      }
      else Delete1(p，p->lchild);	
            //*p结点既无左子树又无右子树的情况
}

void Delete1(BSTNode *p，  BSTNode *&r)
  //当被删*p结点有左右子树时
  {     BSTNode *q;
         if (r的右孩子不为空)
	   		Delete1(p，r->rchild);	//递归找*r的最右下结点
        else  		              //r指向最右下结点
        {   
        	用r结点替换p；
	        删除r结点；
       }
  }

//实现

int DeleteBST(BSTNode*& T,KeyType k)  
{
    if (T == NULL) return 0;	
    else
    {
        if (k < T->key) 
        	return DeleteBST(T->lchild,k);
        else if (k >T->key) 
        	return DeleteBST(T->rchild,k);
        else   
        {
            Delete(T);    
            return 1;
        }
    }
}

void Delete(BSTNode*& p)   	 
{
    BSTNode* q;
    if (p->rchild == NULL)        	
    {
        q = p; 
        p = p->lchild;		
        free(q);
    }
    else if (p->lchild == NULL)    	
    {
        q = p; 
        p = p->rchild;	
        free(q);
    }
    else Delete1(p,p->lchild);
}

void Delete1(BSTNode* p,BSTNode*& r)
{
    BSTNode* q;
    if (r->rchild != NULL)
        Delete1(p,r->rchild);	
    else  		              
    {
        p->key = r->key;  
        q = r; 
        r = r->lchild;          
        free(q); 	              
    }
}

//效果如下