二叉搜索树 练习

###binary_search_tree.h

#pragma once 
#include<stdio.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)
{
	BSTreeNode *newnode = (BSTreeNode*)malloc(sizeof(BSTreeNode));
	assert(newnode);
	newnode->_data = x;
	newnode->_left = NULL;
	newnode->_right = NULL;
	return newnode;
}


//向二叉搜索树中插入一个节点
int BSTreeInsert(BSTreeNode** tree, DataType x)
{
	//如果该树为空树，则直接把该节点作为根节点
	//如果该树不是空树，则寻找该节点的位置，如果发现该节点已经存在于树中，则插入失败，返回0
	//插入成功返回1

	assert(tree);
	BSTreeNode *cur = *tree;
	BSTreeNode *parent = *tree;
	if (*tree == NULL)
	{
		*tree = BuyBSTreeNode(x);
		return 1;
	}
	else
	{
		while (cur)
		{
		    if (cur->_data > x)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_data<x)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				printf("该二叉搜索树中已经存在该值的节点\n");
				return 0;
			}
			
		}
		//运行到此处说明已经找到了要插入的位置及他的父亲节点
		cur = BuyBSTreeNode(x);
		if (parent->_data > x)//需要确定cur是链在parent左还是parent右
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return 1;
	}
}


//在二叉搜索树中查找一个值为x的节点是否存在，存在返回1，不存在返回0
const BSTreeNode* BSTreeFind(BSTreeNode* tree, DataType x)
{
	//根据二叉搜索树的性质，如果该节点的值等于x，直接返回节点地址，
	//大于x，进左数查找，小于x，进右树查找。如果找到空，这说明该节点不存在与此二叉搜索树中。
	assert(tree);
	while (tree != NULL)
	{
		if (tree->_data == x)
		{
			return tree;
		}
		else if (tree->_data > x)
		{
			tree = tree->_left;
		}
		else
		{
			tree = tree->_right;
		}
	}
	return NULL;
}


//删除二叉搜索树中值为x的节点
int BSTreeRemove(BSTreeNode** tree, DataType x)
{
	/*1.树不可以是空树
	2.删除成功返回1，失败返回0
	3.删除的节点的种类：1)叶子节点  2)无左孩子或无右孩子  3)两个孩子都有*/

	assert(tree);
	BSTreeNode* cur = *tree;
	BSTreeNode* parent = NULL;
	//第一步先找到要删除的节点的位置
	while (cur!=NULL)
	{
		if (cur->_data > x)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_data < x)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			//运行到这里说明已经找到了要删除的节点和它父亲节点的位置，
			//然后分类讨论：1)叶子节点  2)无左孩子或无右孩子  3)两个孩子都有
			//1和2可以算作1种情况，因为叶子节点可以视作左为空或右为空


			if (cur->_left == NULL)//左为空
			{
				if (parent == NULL)//右单边结构删头结点
				{
					*tree = (*tree)->_right;
					return 1;
				}
				if (parent->_left == cur)//左为空且cur是parent的左孩子
				{
					parent->_left = cur->_right;//连右
				}
				else//cur是parent的右孩子
				{
					parent->_right = cur->_right;
				}
				return 1;
			}


			else if (cur->_right == NULL)//右为空
			{
				if (parent == NULL)//左单边结构删根节点
				{
					*tree = (*tree)->_left;
					return 1;
				}
				if (parent->_left == cur)//右为空且cur是parent的左孩子
				{
					parent->_left = cur->_left;//连左
				}
				else//cur是parent的右孩子
				{
					parent->_right = cur->_left;
				}
				return 1;
			}


			else//要删的节点有左右孩子
			{
				//删除方法：找到替换节点：左树的最右节点（及父亲节点）或者右树的最左节点（及父亲节点），
				//判断替换节点是否还有孩子，有则令其父亲连上后面的节点
				//此时cur是要删除的节点，parent是他的父亲节点(当删除的是根节点时parent为空)

				//第一步要找到替换节点，及替换节点的父亲
				BSTreeNode *subright = cur->_left;
				BSTreeNode *father = cur;
				while (subright->_right)
				{
					father = subright;
					subright = subright->_right;
				}
				//已经找到了替换节点和它的父亲节点
			
				if (father->_left == subright)
				{
					if (subright->_left)
					{
						father->_left = subright->_left;
						
					}
					else
						father->_left = NULL;
				}
				else
				{
					if (subright->_left)
					{
						father->_right = subright->_left;
					}
					else
					{
						father->_right = NULL;
					}
					
				}
				//运行到这里说明已经已经完成了替换节点的父亲和替换节点的孩子的链接，只剩下
				//替换掉删除节点的值，再free掉替换节点即可
				cur->_data = subright->_data;
				free(subright);
				return 1;
			}
			
			
		}
	}

	return 0;
}


/ 
 递归 
//递归插入节点
int BSTreeInsertR(BSTreeNode** tree, DataType x)
{
	if (*tree == NULL)
	{
		*tree = BuyBSTreeNode(x);
		return 1;
	}
	if ((*tree)->_data > x)
	{
		return BSTreeInsertR(&((*tree)->_left), x);//这里的&((*tree)->_left)非常关键，是能保证新插入节点
												   //和原节点实现连接的原因：每次传参时，都已经将对接的口：
												   //左子树指针的地址，右子树指针的地址传给了下一层栈帧，下一层栈帧只需要
												   //解引用并指向新创建的节点即可
	}
	else if ((*tree)->_data < x)
	{
		return BSTreeInsertR(&((*tree)->_right), x);
	}
	else
		return 0;
}
//递归查找
const BSTreeNode* BSTreeFindR(BSTreeNode* tree, DataType x)
{
	if (tree == NULL) 
	{
		return NULL;
	}
	if (tree->_data == x)
	{
		return tree;
	}
	else if (tree->_data > x)
	{
		return BSTreeFindR(tree->_left, x);
	}
	else
		return BSTreeFindR(tree->_right, x);
}
//递归删除
int BSTreeRemoveR(BSTreeNode** tree, DataType x)
{
	if (*tree == NULL)
	{
		return 0;
	}

	 if ((*tree)->_data > x)
	{
		 return BSTreeRemoveR(&((*tree)->_left), x);//这里的二级指针同样是保证删除节点的父亲和删除节点的孩子
												    //能够连接的关键，每次传参时，都已经把接口：删除节点的父亲的
													//左右指针的地址传进来了。
	}
	 else if ((*tree)->_data < x)
	 {
		 return BSTreeRemoveR(&((*tree)->_right), x);
	 }
	 else//找到要删除的节点
	 {
		 if ((*tree)->_left == NULL)
		 {
			 *tree = (*tree)->_right;//<-------------详解见图1
			
		 }                           //              
		 else if ((*tree)->_right == NULL)
		 {
			 *tree = (*tree)->_left;//<--------------详解见图1
		 }
		 else//见图2
		 {
			 BSTreeNode *subright = (*tree)->_left;
			 while (subright->_right)
			 {
				 subright = subright->_right;
			 }
			 (*tree)->_data = subright->_data;
			 return BSTreeRemoveR(&(*tree)->_left, subright->_data);
		 }
		 return 1;
	 }

}


//删除二叉搜索树
void BSTreeDestory(BSTreeNode** tree)
{
	//因为二叉搜索树是一个二叉链表，在删去某个节点前要保证他的左右孩子均被释放(后序遍历)。
	//所以这里适合用递归,
	if (*tree == NULL)
	{
		return;
	}
	BSTreeDestory(&( (*tree)->_left ) );
	BSTreeDestory(&( (*tree)->_right) );
	free(*tree);
}
void BSTreeInOrder(BSTreeNode* tree)
{
	if (tree == NULL)
	{
		return;
	}
	BSTreeInOrder(tree->_left);
	printf("%d ", tree->_data);
	BSTreeInOrder(tree->_right);
	
}

#图1

#图2

###test.c

#include"binary_search_tree.h"


void TestBSTree()
{

	int a[] = { 5,3,4,1,7,8,2,6,0,9 };
	BSTreeNode* tree = NULL;

	for (int i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
	{
 		BSTreeInsertR(&tree, a[i]);
	}

	BSTreeInOrder(tree);
	printf("\n");
	printf("%p\n", BSTreeFind(tree, 1));
	printf("%p\n", BSTreeFind(tree, 10));
	
	BSTreeRemoveR(&tree, 5); 
	BSTreeInOrder(tree);
	
	
		
}

int main()
{
	TestBSTree();
	system("pause");
	return 0;
}