【数据结构】二叉查找树（BST树）的构建、查找、插入、删除操作

二叉查找树又叫二叉排序树、二叉搜索树；

二叉查找树其实是数据域有序的二叉树，即树上的每个节点都满足左子树上结点小于等于根节点，右子树上结点大于等于根节点数值；   Ps：BST树中不能包含重复元素 

二叉树的操作包含建树、查询、删除、插入结点；

构建BST树架构 

typedef int KeyType;
typedef struct BstNode
{
	BstNode *leftchild;
	BstNode *parent;
	BstNode *rightchild;
	KeyType key;
}BstNode;

typedef struct
{
	BstNode *head;
	int cursize;
}BSTree;

 创建、更新、释放BST树操作

BstNode * Buynode(BstNode *pa = NULL)
{
	BstNode *s = (BstNode *)malloc(sizeof(BstNode));
	if(NULL == s) exit(1);
	memset(s,0,sizeof(BstNode));
	s->parent = pa;
	return s;
}
void Freenode(BstNode *p)
{
	free(p);
}
void InitBSTree(BSTree &myt)
{
	myt.head = Buynode();
	myt.cursize = 0;
}
void DestroyBSTree(BSTree &myt)
{
}

 查找BST树中kx值【递归+非递归】 

BstNode * FindValue(BSTree &myt,KeyType kx)
{
	BstNode * p = myt.head->parent; // root;
	while(p != NULL && p->key != kx)
	{
		p = kx < p->key? p->leftchild:p->rightchild;
	}
	return p;
}
BstNode * Search(BstNode *p,KeyType kx)
{
	if(p == NULL || p->key == kx) 
		return p;
	else if(kx < p->key)
		return Search(p->leftchild,kx);
	else 
		return Search(p->rightchild,kx);
}
BstNode * SearchValue(BSTree &myt,KeyType kx)
{
	return Search(myt.head->parent,kx);
}

 查找BST树中第一个元素值、最后一个元素值以及前一个和后一个元素值

BstNode * First(BstNode *ptr) // Min;
{
	while(ptr != NULL && ptr->leftchild != NULL)
	{
		ptr = ptr->leftchild;
	}
	return ptr;
}
BstNode * Next(BSTree &myt,BstNode *ptr) //Next;
{
	if(ptr == NULL || ptr == myt.head) return NULL;
	if(ptr->rightchild != NULL) 
	{  //rightchild->leftchild;
		return First(ptr->rightchild);
	}
	else
	{
		//parent结点就是下一个结点
		BstNode *pa = ptr->parent;
		while(pa != myt.head && pa->leftchild != ptr)
		{   //不断向上指向
			ptr = pa;
			pa = pa->parent;
		}
		if(pa == myt.head)
		{
			pa = NULL;
		}
		return pa;
	}
}
BstNode *Last(BstNode *ptr) // Max;
{
	while(ptr != NULL && ptr->rightchild != NULL)
	{
		ptr = ptr->rightchild;
	}
	return ptr;
}
BstNode * Prev(BSTree &myt,BstNode *ptr)
{
	if(ptr == NULL || ptr == myt.head) return NULL;
	if(ptr->leftchild != NULL)
	{
		return Last(ptr->leftchild);
	}
	else
	{
		BstNode *pa = ptr->parent;
		while(pa != myt.head && pa->rightchild != ptr)
		{
			ptr = pa;
			pa = pa->parent;
		}
		if(pa == myt.head)
		{
			pa = NULL;
		}
		return pa;
	}
}

 BST树值进行有序排列

void NiceInOrder(BSTree &myt) //从小到大
{
	for(BstNode *p = First(myt.head->parent);
		p !=NULL; p = Next(myt,p))
	{
		cout<<p->key<<" ";
	}
	cout<<endl;
}
void ResNiceInOrder(BSTree &myt) //从大到小
{
	for(BstNode *p = Last(myt.head->parent); 
		p != NULL; p = Prev(myt,p))
	{
		cout<<p->key<<" ";
	}
	cout<<endl;
}

 向BST树中插入元素

bool InsertBST(BSTree &myt,KeyType kx)
{
	BstNode *pa = myt.head ; // head;
	BstNode *p = myt.head->parent;// root;
	while(p != NULL && p->key != kx)
	{
		pa = p;
		p = kx < p->key? p->leftchild:p->rightchild;
	}
	if(p != NULL)  return false;
	p = Buynode(pa);
	p->key = kx;
	if(pa == myt.head)
	{
		myt.head->leftchild = p;
		myt.head->rightchild = p;
		myt.head->parent = p;
	}
	else
	{
		if(p->key < pa->key)
		{
			pa->leftchild = p;
			if(p->key < myt.head->leftchild->key)
			{
				myt.head->leftchild = p;
			}
		}
		else
		{
			pa->rightchild = p;
			if(p->key > myt.head->rightchild->key)
			{
				myt.head->rightchild = p;
			}
		}
	}
	myt.cursize+=1;
	return true;
}

 删除BST树中某值

bool RemoveBST(BSTree &myt,KeyType kx)
{
	BstNode *pa = myt.head; // head
	BstNode *p = myt.head->parent; // root;
	while(p != NULL && p->key != kx)
	{
		pa = p;
		p = kx < p->key? p->leftchild:p->rightchild; //找kx
	}
	if(p == NULL) return false;
	if(p->leftchild != NULL && p->rightchild != NULL)
	{ //找到kx后左右子树都不为空的情况
		BstNode *nt = Next(myt,p->rightchild);
		p->key = nt->key;
		p = nt;
	}
	BstNode * child = p->leftchild != NULL? p->leftchild:p->rightchild;
	if(child != NULL) child->parent = pa;
	if(pa == myt.head)
	{
		myt.head->parent = child;
	}
	else
	{
		if(p == pa->leftchild)
		{
			pa->leftchild = child;
		}
		else
		{
			pa->rightchild = child;
		}
	}
	Freenode(p);
	myt.cursize-=1;
	return true;
}