二叉排序树的C++实现，包括难点删除

#include <iostream>
using namespace std;
struct node{
	int num;
	node* Lnext;
	node* Rnext;
};
//建立二叉排序树
class list{
public:
	list();
	void node_insert();
	//p为要删除的节点，p0为删除节点的前一个节点，当然两节点可能重合
	//flag为标志位，0代表p0左节点与下一节点相连，1代表p0右节点域下一节点相连
	void node_delete(node* p,node* p0,bool flag);
	void mid_tranverse(node* p);
	void mid_print();
	void delete_place(int n);
private:
	node* head;
};
//n为要删除的数字大小
void list::delete_place(int n){
    node* p=head;
	node* p0=p;
	bool flag=0;
	while(p!=NULL){
		if(n<p->num){
			p0=p;
			p=p->Lnext;
			flag=0;
		}
		else if(n>p->num){
			p0=p;
			p=p->Rnext;
			flag=1;
		}
		else {
			node_delete(p,p0,flag);
			return;
		}
	}
	cout<<"抱歉，未找到您要删除的节点"<<endl;
}
//p对应要删除的数字n的地址
void list::node_delete(node *p,node* p0,bool flag){
	//情况1：叶子节点
	if(!(p->Lnext) && !(p->Rnext)){
		//如果p和p0不等
		if(p!=p0){
			free(p);
			p=NULL;
			if(!flag)
				p0->Lnext=NULL;
			else
				p0->Rnext=NULL;
		}
		//如果p和p0相等，那么说明p为根节点
		else{
			free(p);
			p=NULL;
		}
	}
	//情况2：p左节点为空
	else if(!(p->Lnext)){
        if(!flag)
			p0->Lnext=p->Rnext;
		else
			p0->Rnext=p->Rnext;
		free(p);
		p=NULL;
	}
	//情况3：p右节点为空
	else if(!(p->Rnext)){
		if(!flag)
			p0->Lnext=p->Lnext;
		else
			p0->Rnext=p->Lnext;
		free(p);
		p=NULL;
	}
	//情况4：p左右节点都不为空
	else{
		//合理利用p0，将p0变为要交换的节点
		node* temp=p;
		p0=p->Lnext;
		while(p0->Rnext!=NULL){
			temp=p0;
			p0=p0->Rnext;
		}
		p->num=p0->num;
		if(p0->Lnext==NULL){
			if(p==temp)
				temp->Lnext=NULL;
			else
			    temp->Rnext=NULL;
			free(p0);
			p0=NULL;
		}
		else{
			temp=p0->Lnext;
			free(temp);
			p0->Lnext=NULL;
	   }
	}
}

void list::mid_print(){
  mid_tranverse(head);
}
void list::mid_tranverse(node* p){
   if(p==NULL)
	   return;
   mid_tranverse(p->Lnext);
   cout<<p->num<<"    ";
   mid_tranverse(p->Rnext);
}

//二叉排序树的初始化
list::list(){
    node* p;
	node* q;
	int i;
	cout<<"请输入您要输入的数字，按任意非数字键结束！"<<endl;
	cin>>i;
	if(cin.fail()){
		cout<<"您的输入有误"<<endl;
		exit(-1);
	}
	else{
		  head=new node;
		  head->num=i;
		  head->Lnext=NULL;
		  head->Rnext=NULL;
		  while(1){
			  cout<<"输入您要输入的数字："<<endl;
			  cin>>i;
		      if(cin.fail())
				 break;
			  p=new node;
			  p->num=i;
			  p->Lnext=NULL;
			  p->Rnext=NULL;
			  q=head;
			  while(1){
				  if(p->num<q->num){
					  if(q->Lnext==NULL){
						  q->Lnext=p;
						  break;
					  }
					  else
						  q=q->Lnext;
				  }
				  else{
					  if(q->Rnext==NULL){
						  q->Rnext=p;
						  break;
					  }
					  else
						  q=q->Rnext;
				  }
			 }
		 }					 
	}
}

void main()
{
	list test;
	test.mid_print();
	cout<<endl<<endl;
    test.delete_place(4);
	test.mid_print();
	system("pause");
}

/*
#include <iostream>
 using namespace std;
 typedef struct BSTNode
 {
     int key;
     struct BSTNode *lchild,*rchild;
 }BSTNode,*BSTree;
 //二叉排序树的插入——递归实现
 void InsertBST(BSTree &DT,BSTNode *p)
 {
     if(DT==NULL)
         DT=p;
     else if((DT->key) > (p->key))
         InsertBST(DT->lchild,p);
     else
         InsertBST(DT->rchild,p);
 }
 //二叉排序树结点的删除
 void DeleteBST(BSTree &DT,BSTNode *p)
 {//要删除结点p，f是p的双亲
     BSTNode *f;
     BSTNode *q,*fq;
     if(!(p->lchild)&&!(p->rchild))//第一种情况：p是叶子结点
     {
         if(f->lchild==p)//p是左孩子
             f->lchild=NULL;
         else//p是右孩子
             f->rchild=NULL;
         q=p;
     }
     else if(!(p->rchild))//第二种情况：（1）p只有左子树
     {
         if(f->lchild==p)
             f->lchild=p->lchild;
         else
             f->rchild=p->lchild;
         q=p;
     }
     else if(!(p->lchild))//第二种情况：（2）p只有右子树
     {
         if(f->lchild==p)
             f->lchild=p->rchild;
         else
             f->rchild=p->rchild;
         q=p;
     }
     else //第三种情况：p既有左子树又有右子树
     {//用p的中序后继来代替p
         fq=p;//fq是q的双亲
         q=p->lchild;
         while(q->lchild)
         {//遍历找到p的中序后继
             fq=q;
             q=q->lchild;
         }
         p->key=q->key;
         if(fq==p)
             fq->rchild=q->rchild;
         else
             fq->lchild=q->rchild;
     }
     delete q;
 }
 //二叉排序树的构造
 void CreateBST(BSTree &DT,int n)
 {
     int i,j;
     int r[100];
     BSTNode *s;
     DT=NULL;//这里一定要将DT置空，表示刚开始的时候是空树，不置空的话，编译器分配的DT是非空的
     for(j=0;j<n;j++)
         cin>>r[j];
     for(i=0;i<n;i++)
     {
         s=new BSTNode;
         s->key=r[i];
         s->lchild=NULL;
         s->rchild=NULL;
         InsertBST(DT,s);
     }
 }
 //二叉排序树的搜索——递归实现
 BSTNode * SearchBST(BSTree &DT,int k)
 {
     BSTNode *p;
     p=DT;
     if(DT==NULL)
         return NULL;
     else if(p->key==k)
         return p;
     else if(p->key>k)
         return SearchBST(p->lchild,k);
     else
         return SearchBST(p->rchild,k);
 }
 void main()
 {
     freopen("in.txt","r",stdin);
     BSTree DT;
     BSTNode *p;
     int k;
     CreateBST(DT,13);
     cin>>k;
     p=SearchBST(DT,k);
     cout<<p->key<<endl;
     //DeleteBST(DT,p);
 }
*/