搜索结构搜索二叉树

#include<stdio.h>
#include<malloc.h>
#include<windows.h>
#include<assert.h>

typedef int DataType;

typedef struct BSTreeNode{
	struct BSTreeNode* _left;
	struct BSTreeNode* _right;
	DataType _data;
}BSTreeNode;

BSTreeNode* BuyBSTreeNode(DataType x);
int BSTreeInsert(BSTreeNode* tree, DataType x);
BSTreeNode* BSTreeFind(BSTreeNode* tree, DataType x);
int BSTreeRemove(BSTreeNode* tree,DataType x);
void BSTreeDestory(BSTreeNode* tree);


BSTreeNode* BuyBSTreeNode(DataType x){
	BSTreeNode* node=(BSTreeNode*)malloc(sizeof(BSTreeNode));
	assert(node);
	node->_data=x;
	node->_left=NULL;
	node->_right=NULL;
}

//中序遍历
void InBSTree(BSTreeNode *tree){
	if(tree==NULL)
		return;
	InBSTree(tree->_left);
	printf("%d ",tree->_data);
	InBSTree(tree->_right);
}

int BSTreeInsert(BSTreeNode** pptree, DataType x){
	BSTreeNode* cur=*pptree;
	BSTreeNode* per=NULL;
	if(*pptree==NULL){          //为空直接赋值，返回
		*pptree=BuyBSTreeNode(x);
		return 0;
	}

	while(cur){  
		if(cur->_data<x){
			per = cur;    //使用per使他做为cur的父节点
			cur=cur->_right;
		}
		else if(cur->_data>x){
			per = cur;
			cur=cur->_left;
		}
		else{
			return -1;
		}
	}
	cur=BuyBSTreeNode(x);
	if(cur->_data<per->_data)  //比较per与cur的大小来决定放左孩子还是右孩子
		per->_left=cur;
	else
		per->_right=cur;
	return 0;
}

BSTreeNode* BSTreeFind(BSTreeNode* tree, DataType x){
	BSTreeNode* cur = tree;
	assert(tree);
	while(cur){
		if(cur->_data>x)
			cur=cur->_left;
		else if(cur->_data<x)
			cur=cur->_right;
		else
			return cur;
	}
	return NULL;
}

int BSTreeRemove(BSTreeNode** tree,DataType x){//4
//a. 要删除的结点无孩子结点 
//b. 要删除的结点只有左孩子结点 
//c. 要删除的结点只有右孩子结点 
//d. 要删除的结点有左、右孩子结点
	int tmp;
	BSTreeNode* parent,*cur;
	BSTreeNode* del=BSTreeFind(*tree,x);

	if(tree==NULL||del==NULL){
		return 0;
	}
//	printf("del  %d 
",del->_data);
	parent=cur=*tree;
	while(cur!=del){
		parent=cur;
		if(cur->_data>x)
			cur=cur->_left;
		else if(cur->_data<x)
			cur=cur->_right;
		else
			break;
	}
	//若删除的为根节点
	if(parent==del&&del->_right==NULL&&del->_left){
		parent->_data=parent->_left->_data;
		parent->_left=parent->_left->_left;
		parent->_right=parent->_left->_right;
		return 1;
	}
	if(parent==del&&del->_left==NULL&&del->_right){
		parent->_data=parent->_right->_data;
		parent->_left=parent->_right->_left;
		parent->_right=parent->_right->_right;
		return 1;
	}
	if(parent==del&&del->_left==NULL&&del->_right==NULL){
		(*tree)=NULL;
		return 1;
	}

	if(del->_left&&del->_right==NULL){   //只有左子树
		if(parent->_left==del){
			parent->_left=del->_left;
		}
		else{
			parent->_right=del->_left;
		}
		return 1;
	}
	else if(del->_right&&del->_left==NULL){ //只有右子树
		if(parent->_left==del){
			parent->_left=del->_right;
		}
		else {
			parent->_right=del->_right;
		}
		return 1;
	}
	else if(del->_left&&del->_right){   //有左右子树
		cur=cur->_right;
		while(cur->_left){
			parent=cur;
			cur=cur->_left;
		}
		tmp=cur->_data;
		BSTreeRemove(tree,cur->_data);
		del->_data=tmp;
	}
	else{
		if(parent->_left==del){
			parent->_left=NULL;
		}
		if(parent->_right==del){	
			parent->_right=NULL;
		}	
	}
	return 1;
}

void BSTreeDestory(BSTreeNode** tree){
   if ((*tree)!=NULL)  {      
	   if ((*tree)->_left){  
			BSTreeDestory((*tree)->_left);  
			(*tree)->_left = NULL;  
	   }  
	   if ((*tree)->_right){  
			BSTreeDestory((*tree)->_right);  
			(*tree)->_right = NULL;  
	   }  
	   if ((*tree)!=NULL){  
			free((*tree));  
			(*tree)=NULL;  
	   }  
	}
}

const BSTreeNode* BSTreeFindR(BSTreeNode* tree, DataType x){
	if(tree==NULL)
		return NULL;
	if(tree->_data==x){
		return tree;
	}
	if(tree->_data>x){
		return BSTreeFindR(tree->_left, x);
	}
	else if(tree->_data<x){
		return BSTreeFindR(tree->_right, x);
	}
}

int BSTreeInsertR(BSTreeNode** ppTree, DataType x){
	if(*ppTree == NULL){          
		*ppTree=BuyBSTreeNode(x); //pptree指向当前空孩子，在此为其赋一个节点
		return 0;
	}

	if((*ppTree)->_data>x){
		return BSTreeInsertR(&(*ppTree)->_left,x);
	}
	else if((*ppTree)->_data<x){
		return BSTreeInsertR(&(*ppTree)->_right,x);
	}
	else 
		return -1;
}

int BSTreeRemoveR(BSTreeNode** pptree,DataType x){
	BSTreeNode* del;
	if(*pptree == NULL){
		return -1;
	}
	if((*pptree)->_data>x){
		return BSTreeRemoveR(&(*pptree)->_left,x);
	}
	else if((*pptree)->_data<x){
		return BSTreeRemoveR(&(*pptree)->_right,x);
	}
	else{
		//1.left empty
		//2.right empty
		//3.l and r isnt empty
		BSTreeNode* cur = *pptree;
		if((*pptree)->_left == NULL){
			*pptree = cur->_right;
		}
		else if((*pptree)->_right == NULL){
			*pptree = cur->_left;
		}
		else{
			BSTreeNode* parent=cur;
			BSTreeNode* sub = cur->_right;
			while(sub->_left){
			//	parent=sub;
				sub=sub->_left;
			}
			//	del = sub;
			cur->_data=sub->_data;
			return BSTreeRemoveR(&(cur->_right),sub->_data);

			//if(parent->_left==sub){
			//	parent->_left=sub->_left;
			//}
			//else{
			//	parent->_right=sub->_right;
			//}
		}
//		free(del);
		return 0;
	}
}


void TestBSTree(){      //5,3,4,1,7,8,2,6,0,9
	BSTreeNode* tree = NULL;
	BSTreeInsert(&tree,5);
	BSTreeInsert(&tree,3);
	BSTreeInsert(&tree,4);
	BSTreeInsert(&tree,1);
	BSTreeInsert(&tree,7);
	BSTreeInsert(&tree,8);
	BSTreeInsert(&tree,2);
	BSTreeInsert(&tree,6);
	BSTreeInsert(&tree,0);
	BSTreeInsert(&tree,9);
	InBSTree(tree);
	printf("
");

	printf("Find 5  %d 
",BSTreeFindR(tree,5)->_data);

	//BSTreeRemove(&tree, 4); 
	//BSTreeRemove(&tree, 8); 
	//BSTreeRemove(&tree, 3); 
	//BSTreeRemove(&tree, 7); 
	//BSTreeRemove(&tree, 5); 
 //
	//InBSTree(tree);
	//printf("
"); 

	//BSTreeRemove(&tree,0);
	//BSTreeRemove(&tree,1);
	//BSTreeRemove(&tree,2);
	//BSTreeRemove(&tree,3);
	//BSTreeRemove(&tree,4);
	//BSTreeRemove(&tree,5);
	//BSTreeRemove(&tree,6);
	//BSTreeRemove(&tree,7);
	//BSTreeRemove(&tree,8);
	//BSTreeRemove(&tree,9);
	//InBSTree(tree);
	//printf("
"); 

	//BSTreeInsertR(&tree, 1);
	//BSTreeInsertR(&tree, 5);
	//BSTreeInsertR(&tree, 2);
	//BSTreeInsertR(&tree, 3);
	//BSTreeDestory(&tree);
	//InBSTree(tree);
	//printf("
"); 


	BSTreeRemoveR(&tree, 4); 
	BSTreeRemoveR(&tree, 8); 
	BSTreeRemoveR(&tree, 3); 
	BSTreeRemoveR(&tree, 7); 
	BSTreeRemoveR(&tree, 5); 
 
	InBSTree(tree);
	printf("
"); 

	BSTreeRemoveR(&tree,0);
	BSTreeRemoveR(&tree,1);
	BSTreeRemoveR(&tree,2);
	BSTreeRemoveR(&tree,3);
	BSTreeRemoveR(&tree,4);
	BSTreeRemoveR(&tree,5);
	BSTreeRemoveR(&tree,6);
	BSTreeRemoveR(&tree,7);
	BSTreeRemoveR(&tree,8);
	BSTreeRemoveR(&tree,9);
	InBSTree(tree);
	printf("
"); 
}