二叉搜索树

#include<iostream>
#include<stack>
#include<stdlib.h>
#define N 1000
#define random(i) (rand()%i)
using namespace std;
struct BinTreeNode
{
	int key;
	BinTreeNode *llink,*rlink;
};	
//插入结点
int insertNode(BinTreeNode **ptree,int key)
{
	if(ptree==NULL)
		return -1;
	BinTreeNode *p=*ptree;
	BinTreeNode *parent=NULL;
	while(p!=NULL)
	{
		parent=p;
		if(p->key==key)
			return -1;
		else if(p->key>key)
			p=p->llink;
		else
			p=p->rlink;
	}
	BinTreeNode *newNode=new BinTreeNode;
	newNode->key=key;
	newNode->llink=newNode->rlink=NULL;
	if(parent==NULL)
		*ptree=newNode;
	else if(parent->key>key)
		parent->llink=newNode;
	else
		parent->rlink=newNode;
	return 0;
}
//删除结点
int deleteNode(BinTreeNode **ptree,int key)
{
	if(ptree==NULL||*ptree==NULL)
		return -1;
	BinTreeNode *delNode=*ptree;
	BinTreeNode *parent=NULL;
	while(delNode!=NULL)
	{
		if(delNode->key==key)
			break;
		parent=delNode;
		if(delNode->key>key)
			delNode=delNode->llink;
		else
			delNode=delNode->rlink;
	}
	if(delNode==NULL)
		return -1;
	if(delNode->llink==NULL)
	{
		if(parent==NULL)
			*ptree=delNode->rlink;
		else if(parent->llink==delNode)
			parent->llink=delNode->rlink;
		else
			parent->rlink=delNode->rlink;
	}
	else
	{
		BinTreeNode *p=delNode->llink;
		while(p->rlink!=NULL)
			p=p->rlink;
		p->rlink=delNode->rlink;
		if(parent==NULL)
			*ptree=delNode->llink;
		else if(parent->llink==delNode)
			parent->llink=delNode->llink;
		else
			parent->rlink=delNode->llink;
	}
	return 0;
}
//判断是否是二叉搜索树
bool isSearchTree(BinTreeNode *tree)
{
	if(tree==NULL)
		return true;
	stack<BinTreeNode*> st;
	BinTreeNode *p=tree;
	int buf=0;
	while(p||!st.empty())
	{
		while(p)
		{
			st.push(p);
			p=p->llink;
		}
		p=st.top();
		st.pop();
		if(p->key<buf)
			return false;
		buf=p->key;
		p=p->rlink;
	}
	return true;
}
//销毁二叉树
void destroyTree(BinTreeNode **ptree)
{
	if(ptree==NULL||*ptree==NULL)
		return;
	destroyTree(&(*ptree)->llink);
	destroyTree(&(*ptree)->rlink);
	delete *ptree;
	*ptree=NULL;
}
//中序遍历
void inOrder(BinTreeNode *tree)
{
	if(tree==NULL)
		return;
	stack<BinTreeNode*> st;
	BinTreeNode *p=tree;
	while(p||!st.empty())
	{
		while(p)
		{
			st.push(p);
			p=p->llink;
		}
		p=st.top();
		st.pop();
		cout<<p->key<<' ';
		p=p->rlink;
	}
	cout<<endl;
}
int main()
{
	BinTreeNode *tree=NULL;
	int num=0;
	while(num<N)                         //向空树插入N个结点
	{
		if(insertNode(&tree,random(N))==0)
		{
			num++;
		}
	}
	inOrder(tree);                       //中序遍历
	num=0;
	while(num<N)                         //删除N个结点
	{
		if(deleteNode(&tree,random(N))==0)
		{
			num++;
			if(!isSearchTree(tree))      //判断删除一个结点后的二叉树是否还是二叉搜索树
				cout<<"delete wrong"<<endl;
		}
	}
	destroyTree(&tree);
	return 0;
}