二叉搜索树的基本操作

本文主要介绍二叉搜索树的C语言代码实现，关于二叉搜索树的讲解后续会补充。下面是代码实现：

//--------------------------二叉搜索树--------------------
//定义二叉搜索树节点的结构体
typedef struct BinaryTree{
	int m_value;
	BinaryTree *m_left;
	BinaryTree *m_right;
	BinaryTree *m_parent;
}BinaryTree;

//二叉搜索树插入节点
void InsertTreeNode(BinaryTree *pHead, BinaryTree *newNode)
{
	BinaryTree *preNode = NULL;
	BinaryTree *node = pHead;

	while(node)
	{
		preNode = node;
		if(newNode->m_value > node->m_value)
			node = node->m_right;
		else
			node = node->m_left;
	}
	newNode->m_parent = preNode;

	if(newNode->m_value > preNode->m_value)
		preNode->m_right = newNode;
	else
		preNode->m_left = newNode;

}
//创建二叉搜索树
BinaryTree *CreateTree(BinaryTree *pHead)
{
	if (pHead == NULL)
		return NULL;
	int value = 0;
	printf("please input head node:");
	scanf("%d",&value);

	pHead->m_value = value;
	pHead->m_parent = NULL;
	pHead->m_right = NULL;
	pHead->m_left = NULL;

	printf("please input node value:");
	scanf("%d",&value);
	while(value != -1){
		BinaryTree* tmp = (BinaryTree*)malloc(sizeof(BinaryTree));
		tmp->m_value = value;
		tmp->m_parent = NULL;
		tmp->m_right = NULL;
		tmp->m_left = NULL;

		InsertTreeNode(pHead,tmp);

		printf("please input node value:");
		scanf("%d",&value);
	}
	return pHead;
}
//中序遍历
void InoderTreeNode(BinaryTree* pHead)
{
	if(pHead == NULL){
		return;
	}
	InoderTreeNode(pHead->m_left);
	printf("%d  ",pHead->m_value);
	InoderTreeNode(pHead->m_right);
}
//二叉搜索树的查询
bool Tree_Search(BinaryTree *pHead, int value)
{
	if(pHead == NULL)
		return NULL;
	BinaryTree *tmp = pHead;
	while(tmp && tmp->m_value != value)
	{
		if(tmp->m_value > value)
			tmp = tmp->m_left;
		else
			tmp = tmp->m_right;
	}
	if(tmp)
		return true;
	else
		return false;
}
//二叉搜索树的最小值对应的的节点
BinaryTree *Tree_Minimum(BinaryTree *pHead)
{
	if(pHead == NULL)
		return NULL;
	BinaryTree *tmp = pHead;
	while(tmp->m_left)
		tmp = tmp->m_left;

	return tmp;
}
//二叉搜索树最大的节点
BinaryTree *Tree_Maximum(BinaryTree *pHead)
{
	if(pHead == NULL)
		return NULL;
	BinaryTree *tmp = pHead;
	while(tmp->m_right)
		tmp = tmp->m_right;

	return tmp;
}
//二叉搜索树节点的前驱节点
BinaryTree *Tree_Successor(BinaryTree *pHead, BinaryTree *x)
{
	if(pHead == NULL)
		return NULL;
	if(x->m_right)
		return Tree_Minimum(x->m_right);

	BinaryTree *p = x->m_parent;
	while(p != NULL && x == p->m_right){
		x = p;
		p = p->m_parent;
	}
	return p;
}
//二叉搜索树节点替代，用v代替u
void TransPlant(BinaryTree *pHead,BinaryTree *u, BinaryTree *v)
{
	if(u->m_parent == NULL)
		pHead = v;
	else if(u == u->m_parent->m_left)
		u->m_parent->m_left = v;
	else
		u->m_parent->m_right = v;

	if(v != NULL)
		v->m_parent = u->m_parent;

}
//二叉搜索树节点的删除节点
void Tree_DeleteNode(BinaryTree *pHead, BinaryTree *delNode)
{
	if(pHead == NULL)
		return;
	BinaryTree *tmp = pHead;
	BinaryTree *y = NULL;

	if(delNode->m_left == NULL)
		TransPlant(pHead,delNode,delNode->m_right);
	else if(delNode->m_right == NULL)
		TransPlant(pHead,delNode,delNode->m_left);
	else
	{
		y = Tree_Minimum(delNode->m_right);
		if(y->m_parent != delNode)
		{
			TransPlant(pHead,y,y->m_right);
			y->m_right = delNode->m_right;
			y->m_right->m_parent = y;
		}
		y->m_left = delNode->m_left;
		y->m_left->m_parent = y;
	}
}

int main()
{
	//构造根节点
	BinaryTree *pHead = NULL;
	pHead = (BinaryTree *)malloc(sizeof(BinaryTree));
	pHead = CreateTree(pHead);//构造二叉搜索树
	if(pHead == NULL)
		return -1;
	InoderTreeNode(pHead);//中序遍历二叉搜索树,由性质知，中序遍历为数值的递增排序

	//在树中插入一个节点，节点的数值需要手动输入
	int value = 0;
	printf("please input insert node value:");//插入节点值
	scanf("%d",&value);
	BinaryTree *node1 = (BinaryTree*)malloc(sizeof(BinaryTree));
	node1->m_value = value;
	node1->m_parent = NULL;
	node1->m_left = NULL;
	node1->m_right = NULL;
	InsertTreeNode(pHead,node1);
	InoderTreeNode(pHead);
	
	//二叉树的查找
	int value2 = 0;
	printf("please input search node value:");
	scanf("%d",&value2);
	bool bo = Tree_Search(pHead,value2);
	printf("%d\n",bo);

	//二叉树节点的前驱
	printf("tree node successor: ");
	BinaryTree *node2 = Tree_Successor(pHead,node1);
	printf("%d\n",node2->m_value);

	//二叉树删除节点
	printf("delete node: ");
	Tree_DeleteNode(pHead,node2);
	InoderTreeNode(pHead);

	return 0;
}