BST树

BST树：二叉排序树
首先是树的基础架构，我采用的是三叉链表，即leftchild,parent,data,rightchild.

构造链表：

typedef struct BstNode
{
	ElemType data;
	BstNode *leftchild;
	BstNode *rightchild;
	BstNode *parent;
}BstNode;

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

然后就是对其进行初始化和购买结点和释放操作：

BstNode* BuyNode(BstNode* par=NULL,BstNode* left=NULL,BstNode* right=NULL)
{
	BstNode* node = (BstNode*)malloc(sizeof(BstNode));
	//没有申请成功
	if(node == NULL) exit(1);
	node->leftchild = left;
	node->parent = par;
	node->rightchild = right;
	return node;
}

void FreeNode(BstNode *p)
{
	free(p);
}

void Init_BSTree(BSTree &myt)
{
	myt.head = BuyNode();
	myt.cursize = NULL;
}

接下来是查找，分为常规查找和递归查找：

BstNode* FindVal(BSTree &myt,ElemType x)
{
	BstNode* p = myt.head->parent;
	while(p != NULL && p->data != x)
	{
		p = x<p->data?p->leftchild:p->rightchild;
	}
	return p;
}

//递归查找
BstNode* Search(BstNode* ptr,ElemType x)
{
	if(ptr == NULL && ptr->data == x)
		return ptr;
	else if(x < ptr->data)
		return Search(ptr->leftchild,x);
	else
		return Search(ptr->rightchild,x);
}

BstNode* SearchVal(BSTree &myt,ElemType x)
{
	return Search(myt.head->parent,x);
}

找树的最左边：

BstNode* First(BstNode *p)
{
	while(p != NULL && p->leftchild != NULL)
	{
		p = p->leftchild;
	}
	return p;
}

找直接后继：

BstNode* Next(BSTree &myt,BstNode *p)
{
	if(p == NULL)
		return p;
	if(p->rightchild != NULL)
	{
		return First(p->rightchild);
	}
	else
	{
		BstNode *pa = p->parent;
		while(pa != myt.head && pa->leftchild != p)
		{
			p = pa;
			pa = pa->parent;
		}
		if(pa == myt.head)
		{
			return NULL;
		}
		return  pa;
	}
}

中序遍历：

void NiceInOrder(BSTree &myt)
{
	for(BstNode *p = First(myt.head->parent);p != NULL;p = Next(myt,p))
	{
		cout << p->data << " ";
	}
	cout << endl;
}

插入函数，分为有结点的插入和空树

bool insert(BSTree &myt,ElemType val)
{
	BstNode *pa = myt.head;
	BstNode *p = GetRoot(myt);
	while(p != NULL &&	p->data != val)
	{
		pa = p;
		p = val<p->data?p->leftchild:p->rightchild;
	}
	if(p != NULL)
		return false;
	p = BuyNode(pa);
	p->data = val;
	if(pa == myt.head)
	{
		myt.head->parent = p;
		myt.head->leftchild = p;
		myt.head->rightchild = p;
	}
	else
	{
		if(p->data < pa->data)
		{
			pa->leftchild = p;
			if(p->data < myt.head->leftchild->data)
			{
				myt.head->leftchild = p;
			}
		}
		else
		{
			pa->rightchild = p;
			if(p->data > myt.head->rightchild->data)
			{
				myt.head->rightchild = p;
			}
		}
	}
	myt.cursize += 1;
	return true;
}

删除操作：
1.删除叶子结点：

void Del_Leaf(BSTree &myt,BstNode *p)
{
	BstNode *pa = p->parent;
	if(pa->leftchild == p)
	{
		pa->leftchild = NULL;
	}
	else
	{
		pa->rightchild = NULL;
	}
	FreeNode(p);
	myt.cursize -= 1;
}

2.删除单分支结点

void Del_Single(BSTree &myt,BstNode *p)
{
	BstNode *pa = p->parent;
	BstNode *child = p->leftchild != NULL? p->leftchild:p->rightchild;
	if(child != NULL) child->parent = pa;
	
	//只有一边的分支，下一步就是删除根节点
	if(pa == myt.head)
	{
		pa->parent = child;
	}
	//删除普通的节点
	else
	{
		if(pa->leftchild == p)
		{
			pa->leftchild = child;
		}
		else
		{
			pa->rightchild = child;
		}
	}
	FreeNode(p);
	myt.cursize -= 1;
}

3.删除总函数

bool remove(BSTree &myt,ElemType val)
{
	bool flag = false;
	BstNode *p = FindVal(myt,val);
	if(p == NULL) return flag;

	if(p->leftchild != NULL && p->rightchild != NULL)
	{
		BstNode *q = First(p);
		p->data = q->data;
		p = q;
	}
	BstNode *pa = p->parent;
	BstNode *child = p->leftchild != NULL?p->leftchild:p->rightchild;
	if(child != NULL)
	{
		child->parent = pa;
	}
	if(pa == myt.head)
	{
		pa->parent = child;
	}
	else
	{
		if(pa->leftchild = p)
		{
			pa->leftchild = child;
		}
		else
		{
			pa->rightchild = child;
		}
	}
	FreeNode(p);
	myt.cursize -= 1;
	flag = true;

	return flag;
}