c语言实现二叉排序树的插入、查找、删除、打印树

2019年3月16日 280次阅读来源: 二叉查找树

目录：

文章目录

##二叉树的关键概念：

每个节点是一个自引用结构体，形式如下：

struct TreeNode {
	struct TreeNode *leftPtr;  /* pointer to left subtree */
	int data;                  /* node data */
	struct TreeNode *rightPtr; /* pointer to right subtree */
};

从根部节点开始，每个节点拥有两个子节点（NULL或者一个节点），称为左节点与右节点，每个节点的左部分与右部分又分别称为该节点的左子树与右子树。
每个节点的键值大于左节点，小于右节点；每个节点的键值大于左子树所有节点的键值，小于右子树所有节点的键值。所以二叉树是按节点键值排序的数据结构。
二叉树的某个节点，如果不是叶节点，则有左子树或右子树，是一个更小的树，因此可以递归地处理关于树的一些问题。

二叉树的插入

思路：将要插入节点的键值与根节点键值比较，如果小于根节点键值，则插入根节点的左子树，如果大于根节点的键值，则插入根节点的右子树，插入子树相当于插入一个更小的树，因此可以用递归方法实现，直到找到没有子树的节点，将新节点插到其下面。注意，新节点插入后，最终只会成为叶节点。

函数代码如下（测试插入、删除、打印功能的源码在最后面，此处只给出插入函数代码）：

void insertNode(TreeNodePtr *treePtr, int value)
{

	/* if treePtr is NULL */
	if (*treePtr == NULL) {

		*treePtr = malloc(sizeof(TreeNode));

		if (*treePtr != NULL) {
			(*treePtr)->data = value;
			(*treePtr)->leftPtr = NULL;
			(*treePtr)->rightPtr = NULL;
		}
		else {
			printf("%d not inserted. No memory available.\n", value);
		} 

	} 
	else { 

		   /* insert node in left subtree */
		if (value < (*treePtr)->data) {
			insertNode(&((*treePtr)->leftPtr), value);
		} 
		else {

			/* insert node in right subtree */
			if (value >(*treePtr)->data) {
				insertNode(&((*treePtr)->rightPtr), value);
			} 
			else { 
				printf("dup");
			}
		} 

	} 

}

##二叉树的查找

思路：与插入类似，从根节点开始，将查找的键值与根节点键值比较，若相等，则返回指向该节点的指针，若查找的键值比它大，则从根节点的右子树开始查找，若查找的键值比它小，则从根节点的左子树开始查找。可以用递归方法实现，类似于插入。这里我用迭代实现，能用迭代还是用迭代，因为递归开销比较大。

函数代码如下：

TreeNode *binaryTreeSereach(TreeNode * const treePtr, int value)
{
	TreeNode *tempPtr = treePtr;
	
	while (tempPtr != NULL && tempPtr->data != value)
	{
		if (value > tempPtr->data)
			tempPtr = tempPtr->rightPtr;
		else
			tempPtr = tempPtr->leftPtr;
	}

	return tempPtr;
}

##二叉树的删除

相比于二叉树的插入和查找，删除一个节点要复杂一些，原因是要保证二叉树的排序性质。二叉树删除有如下三种情况：

1. 删除节点是叶节点，即没有子节点，或者说左右子节点都是NULL。这种情况下，只需要把删除节点的父节点中对应的指针指向NULL即可。然后释放掉删除节点的空间。

2. 删除节点有一个子节点（左子节点或右子节点），这种情况下，把删除节点的父节点中对应的指针指向删除节点的子节点即可。然后释放掉删除节点的空间

3. 删除节点有两个子节点，这种情况下，必须要找到一个替代删除节点的替代节点，并且保证二叉树的排序性。根据二叉树的排序性，可知替代节点的键值必须最接近删除节点键值。比删除节点键值小的所有键值中最大那个，或者是比删除节点键值大的所有键值中最小的那个，是符合要求的。这两个键值所在的节点分别在删除节点的左子树中最右边的节点，删除节点右子树中最左边的节点。以从左子树中找最大键值节点为例，算法如下：

找到删除节点以及它的父节点
在删除节点的左子树中，向下向右遍历，找到替代节点以及它的父节点
删除节点的父节点中对应的指针指向替代节点
替代节点中的右子节点指针指向删除节点的右子树
如果替代节点的父节点不是删除节点，则将替代节点的左子节点指针指向删除节点的左子树，并且替代节点的父节点中对应的指针指向替代节点的左子节点
释放删除节点的空间
注意：第二步中找到的替代节点，可能会有左子树，但一定没有右子树。第五步要判断替代节点的父节点不是删除节点后，才将替代节点的左子节点指针指向删除节点的左子树，否则会出现替代节点左子节点指针指向自己的情况，从而丢失替代节点的左子树。

另外，还有一种实现相同效果的的方法，即将替代节点中的数据赋给删除节点，然后释放替代节点的空间。这种方法其实是删除了替代节点，并没有真正删除想要删除的节点。而且如果节点包括一个键值和很多其他的数据，则赋值语句会很多。在最后面的测试过程中，我也给出了这个函数的实现，void deleteNode2(TreeNode **treePtrP, int value)

代码如下：

void deleteNode(TreeNode **treePtrP, int value)
{
	TreeNode *deleteNodePtr = *treePtrP;
	TreeNode *parentNodeOfDeletePtr = NULL;
	TreeNode *substituteNodePtr;
	TreeNode *parentNodeOfSubstitutePtr;

	//find deleNode and its parentNode
	while (deleteNodePtr != NULL && value != deleteNodePtr->data)
	{
		parentNodeOfDeletePtr = deleteNodePtr;

		if (deleteNodePtr->data > value)
		{
			deleteNodePtr = deleteNodePtr->leftPtr;
		}
		else
		{
			deleteNodePtr = deleteNodePtr->rightPtr;
		}
	}

	//case that can't find such Node
	if (deleteNodePtr == NULL)
	{
		printf("no such Node, delete fail\n\n");
		return;

	}

	//delete a leafNode
	if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = NULL;
		}
		else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
		{
			parentNodeOfDeletePtr->leftPtr = NULL;
		}
		else
		{
			parentNodeOfDeletePtr->rightPtr = NULL;
		}

	}
	//delete a Node which has a left child Node
	else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = deleteNodePtr->leftPtr;
		}
		else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
			parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;
		else
			parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;

	}

	//delete a Node which has a right child Node
	else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = deleteNodePtr->rightPtr;
		}
		else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
			parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;
		else
			parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;

	}
	//delete a Node which has a left and a right child Node
	else
	{
		parentNodeOfSubstitutePtr = deleteNodePtr;
		substituteNodePtr = deleteNodePtr->leftPtr;

		//search down and right to find substituteNode and its parentNode
		while (substituteNodePtr->rightPtr != NULL)
		{
			parentNodeOfSubstitutePtr = substituteNodePtr;
			substituteNodePtr = substituteNodePtr->rightPtr;

		}

		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = substituteNodePtr;
		}
		else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
		{
			parentNodeOfDeletePtr->leftPtr = substituteNodePtr;
		}
		else
		{
			parentNodeOfDeletePtr->rightPtr = substituteNodePtr;
		}

		substituteNodePtr->rightPtr = deleteNodePtr->rightPtr;

		if (parentNodeOfSubstitutePtr != deleteNodePtr)
		{
			substituteNodePtr->leftPtr = deleteNodePtr->leftPtr;

			if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)
			{
				parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;
			}
			else
			{
				parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;
			}
		}
		
	}

	free(deleteNodePtr);
}

##二叉树的打印

从根节点开始，先输出右子树，再输出节点键值，再输出左子树。采用递归法
代码如下：

void outputTree(TreeNodePtr treePtr, int spaces)
{
	int loop;
	
	while (treePtr != NULL) {

		outputTree(treePtr->rightPtr, spaces + 4);

		for (loop = 1; loop <= spaces; loop++) {
			printf(" ");
		} 

		printf("%d\n", treePtr->data);
		
		outputTree(treePtr->leftPtr, spaces + 4);
		treePtr = NULL;
	} 
}

##测试结果截图
《c语言实现二叉排序树的插入、查找、删除、打印树》

《c语言实现二叉排序树的插入、查找、删除、打印树》

##测试插入、删除、打印树源码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

struct TreeNode {
	struct TreeNode *leftPtr;  /* pointer to left subtree */
	int data;                  /* node data */
	struct TreeNode *rightPtr; /* pointer to right subtree */
};

typedef struct TreeNode TreeNode;

void insertNode(TreeNode **treePtr, int value);
TreeNode * binaryTreeSereach(TreeNode * const treePtr, int value);
void deleteNode(TreeNode **treePtrP, int value);
void outputTree(TreeNode *treePtr, int spaces);
void deleteNode2(TreeNode **treePtrP, int value);

int main(void)
{
	int arr[] = { 45, 83, 28, 97, 71, 40, 18, 77, 99, 92, 72, 69, 44, 32, 19, 11 };
	int i;                      /* loop counter */
	int item;                   /* value to deal with */
	int totalSpaces = 0;        /* spaces preceding output */
	TreeNode *rootPtr = NULL; /* points to the tree root */

	srand(time(NULL)); /* randomize */
	printf("The numbers being placed in the tree are:\n\n");

	for (i = 0; i < sizeof(arr) / sizeof(int); i++) {
		item = arr[i];
		printf("%3d", item);
		insertNode(&rootPtr, item);
	}

	printf("\n\n\nnow the tree is:\n\n");

	if (rootPtr == NULL)
		printf("empty tree\n");
	else
		outputTree(rootPtr, totalSpaces);

	//random delete Nodes, then output the tree
	while (rootPtr != NULL)
	{
		item = rand() % 16;
		printf("\n\nafter delete %d:\n\n", arr[item]);
		deleteNode2(&rootPtr, arr[item]);

		if (rootPtr == NULL)
			printf("empty tree\n");
		else
			outputTree(rootPtr, totalSpaces);

	}
	
	return 0; 
}

void insertNode(TreeNode **treePtr, int value)
{

	/* if treePtr is NULL */
	if (*treePtr == NULL) {

		*treePtr = malloc(sizeof(TreeNode));

		if (*treePtr != NULL) {
			(*treePtr)->data = value;
			(*treePtr)->leftPtr = NULL;
			(*treePtr)->rightPtr = NULL;
		}
		else {
			printf("%d not inserted. No memory available.\n", value);
		}

	}
	else {

		/* insert node in left subtree */
		if (value < (*treePtr)->data) {
			insertNode(&((*treePtr)->leftPtr), value);
		}
		else {

			/* insert node in right subtree */
			if (value >(*treePtr)->data) {
				insertNode(&((*treePtr)->rightPtr), value);
			}
			else {
				printf("dup");
			}
		}

	}

}

TreeNode *binaryTreeSereach(TreeNode * const treePtr, int value)
{
	TreeNode *tempPtr = treePtr;

	while (tempPtr != NULL && tempPtr->data != value)
	{
		if (value > tempPtr->data)
			tempPtr = tempPtr->rightPtr;
		else
			tempPtr = tempPtr->leftPtr;
	}

	return tempPtr;
}

void deleteNode(TreeNode **treePtrP, int value)
{
	TreeNode *deleteNodePtr = *treePtrP;
	TreeNode *parentNodeOfDeletePtr = NULL;
	TreeNode *substituteNodePtr;
	TreeNode *parentNodeOfSubstitutePtr;

	//find deleNode and its parentNode
	while (deleteNodePtr != NULL && value != deleteNodePtr->data)
	{
		parentNodeOfDeletePtr = deleteNodePtr;

		if (deleteNodePtr->data > value)
		{
			deleteNodePtr = deleteNodePtr->leftPtr;
		}
		else
		{
			deleteNodePtr = deleteNodePtr->rightPtr;
		}
	}

	//case that can't find such Node
	if (deleteNodePtr == NULL)
	{
		printf("no such Node, delete fail\n\n");
		return;

	}

	//delete a leafNode
	if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = NULL;
		}
		else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
		{
			parentNodeOfDeletePtr->leftPtr = NULL;
		}
		else
		{
			parentNodeOfDeletePtr->rightPtr = NULL;
		}

	}
	//delete a Node which has a left child Node
	else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = deleteNodePtr->leftPtr;
		}
		else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
			parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;
		else
			parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;

	}

	//delete a Node which has a right child Node
	else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = deleteNodePtr->rightPtr;
		}
		else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
			parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;
		else
			parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;

	}
	//delete a Node which has a left and a right child Node
	else
	{
		parentNodeOfSubstitutePtr = deleteNodePtr;
		substituteNodePtr = deleteNodePtr->leftPtr;

		//search down and right to find substituteNode and its parentNode
		while (substituteNodePtr->rightPtr != NULL)
		{
			parentNodeOfSubstitutePtr = substituteNodePtr;
			substituteNodePtr = substituteNodePtr->rightPtr;

		}

		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = substituteNodePtr;
		}
		else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
		{
			parentNodeOfDeletePtr->leftPtr = substituteNodePtr;
		}
		else
		{
			parentNodeOfDeletePtr->rightPtr = substituteNodePtr;
		}

		substituteNodePtr->rightPtr = deleteNodePtr->rightPtr;

		if (parentNodeOfSubstitutePtr != deleteNodePtr)
		{
			substituteNodePtr->leftPtr = deleteNodePtr->leftPtr;

			if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)
			{
				parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;
			}
			else
			{
				parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;
			}
		}
		
	}

	free(deleteNodePtr);
}

void outputTree(TreeNode *treePtr, int spaces)
{
	int loop;

	while (treePtr != NULL) {

		outputTree(treePtr->rightPtr, spaces + 4);

		for (loop = 1; loop <= spaces; loop++) {
			printf(" ");
		}

		printf("%d\n", treePtr->data);

		outputTree(treePtr->leftPtr, spaces + 4);
		treePtr = NULL;
	}
}

void deleteNode2(TreeNode **treePtrP, int value)
{
	TreeNode *deleteNodePtr = *treePtrP;
	TreeNode *parentNodeOfDeletePtr = NULL;
	TreeNode *substituteNodePtr;
	TreeNode *parentNodeOfSubstitutePtr;

	//find deleNode and its parentNode
	while (deleteNodePtr != NULL && value != deleteNodePtr->data)
	{
		parentNodeOfDeletePtr = deleteNodePtr;

		if (deleteNodePtr->data > value)
		{
			deleteNodePtr = deleteNodePtr->leftPtr;
		}
		else
		{
			deleteNodePtr = deleteNodePtr->rightPtr;
		}
	}

	//case that can't find such Node
	if (deleteNodePtr == NULL)
	{
		printf("no such Node, delete fail\n\n");
		return;

	}
	
	// delete a leafNode
	if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr == NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = NULL;
		}
		else if (parentNodeOfDeletePtr->leftPtr == deleteNodePtr)
		{
			parentNodeOfDeletePtr->leftPtr = NULL;
		}
		else
		{
			parentNodeOfDeletePtr->rightPtr = NULL;
		}

	}
	//delete a Node which has a left child Node
	else if (deleteNodePtr->leftPtr != NULL && deleteNodePtr->rightPtr == NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = deleteNodePtr->leftPtr;
		}
		else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
			parentNodeOfDeletePtr->rightPtr = deleteNodePtr->leftPtr;
		else
			parentNodeOfDeletePtr->leftPtr = deleteNodePtr->leftPtr;
	}

	//delete a Node which has a right child Node
	else if (deleteNodePtr->leftPtr == NULL && deleteNodePtr->rightPtr != NULL)
	{
		//delete Node is root
		if (parentNodeOfDeletePtr == NULL)
		{
			*treePtrP = deleteNodePtr->rightPtr;
		}
		else if (parentNodeOfDeletePtr->rightPtr == deleteNodePtr)
			parentNodeOfDeletePtr->rightPtr = deleteNodePtr->rightPtr;
		else
			parentNodeOfDeletePtr->leftPtr = deleteNodePtr->rightPtr;
	}
	//delete a Node which has a left and a right child Node
	else
	{
		//find substituteNode and its parentNode
		parentNodeOfSubstitutePtr = deleteNodePtr;
		substituteNodePtr = deleteNodePtr->leftPtr;

		//search down and right
		while (substituteNodePtr->rightPtr != NULL)
		{
			parentNodeOfSubstitutePtr = substituteNodePtr;
			substituteNodePtr = substituteNodePtr->rightPtr;

		}

		if (parentNodeOfSubstitutePtr->leftPtr == substituteNodePtr)
		{
			parentNodeOfSubstitutePtr->leftPtr = substituteNodePtr->leftPtr;
		}
		else
		{
			parentNodeOfSubstitutePtr->rightPtr = substituteNodePtr->leftPtr;
		}

		deleteNodePtr->data = substituteNodePtr->data;
		deleteNodePtr = substituteNodePtr;
	}

	free(deleteNodePtr);
}

    原文作者：二叉查找树
    原文地址: https://blog.csdn.net/biglamp/article/details/77045193
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。