二叉搜索树——C语言描述——创建，查找，增加，删除结点

已于 2023-05-03 16:41:10 修改
阅读量306 收藏 2
点赞数 1
文章标签： c语言 数据结构 算法
于 2023-04-03 23:15:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59469991/article/details/129942256
版权
本文详细介绍了如何使用C语言实现二叉搜索树的基本操作，包括查找、增加和删除节点的代码实现，并提供了相应的测试用例来验证功能的正确性。通过递归法查找节点，动态增加和删除节点，确保了二叉搜索树的性质得以保持。
摘要由CSDN通过智能技术生成

二叉搜索树——C语言描述——创建，查找，增加，删除结点

文章目录

0 测试用例框架

https://blog.csdn.net/m0_59469991/article/details/127137119?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22127137119%22%2C%22source%22%3A%22m0_59469991%22%7D

1 定义

​ 树上每个左子树的结点均小于根结点，且根结点小于右子树的所有结点，中序遍历是从小到大序列。

构建二叉树链接：

https://blog.csdn.net/m0_59469991/article/details/127337105

2 查找

​ 递归法查找，查到时把该结点返回，没查到时返回上一个结点。

（1）代码

/*BSTSearch*/
bool BSTSearch(BINARY_TREE_NODE *BSTNode, BINARY_TREE_NODE *PreBSTNode, int Key, BINARY_TREE_NODE **RtNode) {
	if (BSTNode == NULL) {
		*RtNode = PreBSTNode;
		return false;
	}

	if (Key < BSTNode->Data) {
		BSTSearch(BSTNode->LeftChild, BSTNode, Key, RtNode);
	}
	else if (Key > BSTNode->Data) {
		BSTSearch(BSTNode->RightChild, BSTNode, Key, RtNode);
	}
	else {
		*RtNode = BSTNode;
		return true;
	}
}

（2）测试用例

void CmpBool(bool Mem01, bool Mem02) {
	TestNum++;
	if (Mem01 == Mem02) {
		PassNum++;
	}
	else {
		FaildNum++;
		printf("Incorrect!\n");
	}
}

/*BSTSearch*/
void TestBSTSearch(void) {
	//    50
	//  10    70
	//   30  
	BINARY_TREE_NODE *BiTreeNodePtr = NULL;
	BINARY_TREE_NODE_DATA Data[] = { {50, 1, 1}, {10, 0, 1}, {30, 0, 0}, {70, 0, 0} };
	char IfExistNodeFlag = 1;

	/*Test01*/
	BINARY_TREE_NODE *BSTNode01 = NULL;
	int SearchKey01 = 30;
	bool SearchResult01;
	bool CmpResult01 = true;

	/*Test02*/
	BINARY_TREE_NODE *BSTNode02 = NULL;
	int SearchKey02 = 50;
	bool SearchResult02;
	bool CmpResult02 = true;

	/*Test03*/
	BINARY_TREE_NODE *BSTNode03 = NULL;
	int SearchKey03 = 100;
	bool SearchResult03;
	bool CmpResult03 = false;

	BuildBinaryTree(&BiTreeNodePtr, Data, IfExistNodeFlag);
	// printf("PreOrderTraversePrintBinaryTree\n");
	// PreOrderTraversePrintBinaryTree(BiTreeNodePtr);
	// printf("InOrderTraversePrintBinaryTree\n");
	// InOrderTraversePrintBinaryTree(BiTreeNodePtr);
	// printf("PostOrderTraversePrintBinaryTree\n");
	// PostOrderTraversePrintBinaryTree(BiTreeNodePtr);

	printf("-------Test start----------\n");
	InitNum();

	/*Test01*/
	printf("\n-------Test 01----------\n");
	SearchResult01 = BSTSearch(BiTreeNodePtr, BiTreeNodePtr, SearchKey01, &BSTNode01);
	CmpBool(CmpResult01, SearchResult01);

	/*Test02*/
	printf("-------Test 02----------\n");
	SearchResult02 = BSTSearch(BiTreeNodePtr, BiTreeNodePtr, SearchKey02, &BSTNode02);
	CmpBool(CmpResult02, SearchResult02);

	/*Test03*/
	printf("-------Test 03----------\n");
	SearchResult03 = BSTSearch(BiTreeNodePtr, BiTreeNodePtr, SearchKey03, &BSTNode03);
	CmpBool(CmpResult03, SearchResult03);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

打印结果

-------Test start----------

-------Test 01----------

-------Test 02----------

-------Test 03----------

-------Test result----------

Print test result;

TestNum = 3, PassNum = 3, FaildNum = 0

3 增加结点

（1）代码

①方法一：

​ 先查找key值对应的结点是否存在，不存在的话，就增加结点。注意树原来就是空的情况。

void AddBSTNode(BINARY_TREE_NODE **BSTNode, int Key) {
	BINARY_TREE_NODE *AddNode = NULL;
	BINARY_TREE_NODE *PreNode = NULL;

	if (BSTNode == NULL) {
		return;
	}

	if (!BSTSearch(*BSTNode, *BSTNode, Key, &PreNode)) {
		AddNode = (BINARY_TREE_NODE *)malloc(sizeof(BINARY_TREE_NODE));
		if (AddNode == NULL) {
			return;
		}
		AddNode->Data = Key;
		AddNode->LeftChild = NULL;
		AddNode->RightChild = NULL;

		if (PreNode == NULL) {
			*BSTNode = AddNode;
		} else if (Key < PreNode->Data) {
			PreNode->LeftChild = AddNode;
		} else {
			PreNode->RightChild = AddNode;
		}
	}
}

②方法二：

​ 直接构建。

代码：

void AddBSTNode02(BINARY_TREE_NODE **BSTNode, int Key) {
	if (*BSTNode == NULL) {
		*BSTNode = (BINARY_TREE_NODE *)malloc(sizeof(BINARY_TREE_NODE));
		if (*BSTNode == NULL) {
			return;
		}
		(*BSTNode)->Data = Key;
		(*BSTNode)->LeftChild = NULL;
		(*BSTNode)->RightChild = NULL;
	}
	else {
		if (Key < (*BSTNode)->Data) {
			AddBSTNode02(&((*BSTNode)->LeftChild), Key);
		}
		else if (Key > (*BSTNode)->Data) {
			AddBSTNode02(&((*BSTNode)->RightChild), Key);
		}
		else {
			return;
		}
	}
}

（2）测试用例

/*AddBSTNode*/
void TestAddBSTNode(void) {
	BINARY_TREE_NODE *BSTNode = NULL;
	BINARY_TREE_NODE *BSTNode11 = NULL;

	/*Test01*/
	//	20
	int Key01 = 20;
	int Num01 = 1;
	int CmpBSTNode01[] = {20};

	/*Test02*/
	//	    20
	//	10
	int Key02 = 10;
	int Num02 = 2;
	int CmpBSTNode02[] = { 20, 10 };

	/*Test03*/
	//	    20
	//	10		50
	int Key03 = 50;
	int Num03 = 3;
	int CmpBSTNode03[] = { 20, 10, 50 };

	/*Test04*/
	//  	    20
	//	  10		 50
	//			 30
	int Key04 = 30;
	int Num04 = 4;
	int CmpBSTNode04[] = { 20, 10, 50, 30 };

	/*Test05*/
	//  	    20
	//	   10		 50
	//	5		 30
	int Key05 = 5;
	int Num05 = 5;
	int CmpBSTNode05[] = { 20, 10, 5, 50, 30 };

	printf("-------Test start----------\n");
	InitNum();
	
	/*Test01*/
	printf("\n-------Test 01----------\n");
	AddBSTNode(&BSTNode, Key01);
	//printf("PreOrderTraversePrintBinaryTree\n");
	//PreOrderTraversePrintBinaryTree(BSTNode);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode01, BSTNode, Num01);

	/*Test02*/
	printf("\n-------Test 02----------\n");
	AddBSTNode(&BSTNode, Key02);
	//printf("PreOrderTraversePrintBinaryTree\n");
	//PreOrderTraversePrintBinaryTree(BSTNode);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode02, BSTNode, Num02);

	/*Test03*/
	printf("\n-------Test 03----------\n");
	AddBSTNode(&BSTNode, Key03);
	//printf("PreOrderTraversePrintBinaryTree\n");
	//PreOrderTraversePrintBinaryTree(BSTNode);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode03, BSTNode, Num03);

	/*Test04*/
	printf("\n-------Test 04----------\n");
	AddBSTNode(&BSTNode, Key04);
	//printf("PreOrderTraversePrintBinaryTree\n");
	//PreOrderTraversePrintBinaryTree(BSTNode);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode04, BSTNode, Num04);

	/*Test05*/
	printf("\n-------Test 05----------\n");
	AddBSTNode(&BSTNode, Key05);
	//printf("PreOrderTraversePrintBinaryTree\n");
	//PreOrderTraversePrintBinaryTree(BSTNode);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode05, BSTNode, Num05);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

结果：

-------Test start----------

-------Test 01----------

Compare

BiTreeNode->Data = 20

PreOrderTraverseCompareNum = 1, NodeNum = 1

-------Test 02----------

Compare

BiTreeNode->Data = 20

BiTreeNode->Data = 10

PreOrderTraverseCompareNum = 2, NodeNum = 2

-------Test 03----------

Compare

BiTreeNode->Data = 20

BiTreeNode->Data = 10

BiTreeNode->Data = 50

PreOrderTraverseCompareNum = 3, NodeNum = 3

-------Test 04----------

Compare

BiTreeNode->Data = 20

BiTreeNode->Data = 10

BiTreeNode->Data = 50

BiTreeNode->Data = 30

PreOrderTraverseCompareNum = 4, NodeNum = 4

-------Test 05----------

Compare

BiTreeNode->Data = 20

BiTreeNode->Data = 10

BiTreeNode->Data = 5

BiTreeNode->Data = 50

BiTreeNode->Data = 30

PreOrderTraverseCompareNum = 5, NodeNum = 5

-------Test result----------

Print test result;

TestNum = 5, PassNum = 5, FaildNum = 0

4 创建二叉排序树

​ 利用增加结点的函数进行创建。

代码：

void BuildBSTree(BINARY_TREE_NODE **BSTNode, int *Arr, int Num) {
	int i = 0;

	if ((BSTNode == NULL) || (Arr == NULL)) {
		return;
	}

	for (i = 0; i < Num; i++) {
		AddBSTNode(BSTNode, Arr[i]);
	}
}

测试用例：

/*TestBuildBSTree*/
void TestBuildBSTree(void) {
	/*Test01*/
	//		   30
	//	  20	    50
	// 10		 40
	int Arr01[] = { 30, 20, 50, 40, 10 };
	int Num01 = 5;
	BINARY_TREE_NODE *BSTNode01 = NULL;
	int CmpBSTNode01[] = {30, 20, 10, 50, 40};

	/*Test02*/
	//		   20
	//	  10	     50
	//			 30
	//				40	
	int Arr02[] = { 20, 50, 10, 30, 40 };
	int Num02 = 5;
	BINARY_TREE_NODE *BSTNode02 = NULL;
	int CmpBSTNode02[] = { 20, 10, 50, 30, 40 };

	/*Test03*/
	//		   30
	//	  10	    50
	//		20	 40
	//				
	int Arr03[] = { 30, 10, 50, 20, 40 };
	int Num03 = 5;
	BINARY_TREE_NODE *BSTNode03 = NULL;
	int CmpBSTNode03[] = { 30, 10, 20, 50, 40 };

	/*Test04*/
	//	  10
	//	     20
	//	        30
	//	           40
	//                50
	int Arr04[] = { 10, 20, 30, 40, 50 };
	int Num04 = 5;
	BINARY_TREE_NODE *BSTNode04 = NULL;
	int CmpBSTNode04[] = { 10, 20, 30, 40, 50 };

	printf("-------Test start----------\n");
	InitNum();

	/*Test01*/
	printf("\n-------Test 01----------\n");
	BuildBSTree(&BSTNode01, Arr01, Num01);
	printf("PreOrderTraversePrintBinaryTree\n");
	PreOrderTraversePrintBinaryTree(BSTNode01);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode01, BSTNode01, Num01);

	/*Test02*/
	printf("\n-------Test 02----------\n");
	BuildBSTree(&BSTNode02, Arr02, Num02);
	printf("PreOrderTraversePrintBinaryTree\n");
	PreOrderTraversePrintBinaryTree(BSTNode02);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode02, BSTNode02, Num02);

	/*Test03*/
	printf("\n-------Test 03----------\n");
	BuildBSTree(&BSTNode03, Arr03, Num03);
	printf("PreOrderTraversePrintBinaryTree\n");
	PreOrderTraversePrintBinaryTree(BSTNode03);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode03, BSTNode03, Num03);

	/*Test04*/
	printf("\n-------Test 04----------\n");
	BuildBSTree(&BSTNode04, Arr04, Num04);
	printf("PreOrderTraversePrintBinaryTree\n");
	PreOrderTraversePrintBinaryTree(BSTNode04);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode04, BSTNode04, Num04);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

结果：

-------Test start----------

-------Test 01----------

PreOrderTraversePrintBinaryTree

BiTreeNode->Data = 30

BiTreeNode->Data = 20

BiTreeNode->Data = 10

BiTreeNode->Data = 50

BiTreeNode->Data = 40

Compare

BiTreeNode->Data = 30

BiTreeNode->Data = 20

BiTreeNode->Data = 10

BiTreeNode->Data = 50

BiTreeNode->Data = 40

PreOrderTraverseCompareNum = 5, NodeNum = 5

-------Test 02----------

PreOrderTraversePrintBinaryTree

BiTreeNode->Data = 20

BiTreeNode->Data = 10

BiTreeNode->Data = 50

BiTreeNode->Data = 30

BiTreeNode->Data = 40

Compare

BiTreeNode->Data = 20

BiTreeNode->Data = 10

BiTreeNode->Data = 50

BiTreeNode->Data = 30

BiTreeNode->Data = 40

PreOrderTraverseCompareNum = 5, NodeNum = 5

-------Test 03----------

PreOrderTraversePrintBinaryTree

BiTreeNode->Data = 30

BiTreeNode->Data = 10

BiTreeNode->Data = 20

BiTreeNode->Data = 50

BiTreeNode->Data = 40

Compare

BiTreeNode->Data = 30

BiTreeNode->Data = 10

BiTreeNode->Data = 20

BiTreeNode->Data = 50

BiTreeNode->Data = 40

PreOrderTraverseCompareNum = 5, NodeNum = 5

-------Test 04----------

PreOrderTraversePrintBinaryTree

BiTreeNode->Data = 10

BiTreeNode->Data = 20

BiTreeNode->Data = 30

BiTreeNode->Data = 40

BiTreeNode->Data = 50

Compare

BiTreeNode->Data = 10

BiTreeNode->Data = 20

BiTreeNode->Data = 30

BiTreeNode->Data = 40

BiTreeNode->Data = 50

PreOrderTraverseCompareNum = 5, NodeNum = 5

-------Test result----------

Print test result;

TestNum = 4, PassNum = 4, FaildNum = 0

5 删除结点

​ 先查找Key值对应的结点，然后进行删除操作，注意DelBSTNode函数入参结点为双重指针，因为要修改结点的地址。

​ 删除结点有三种情况：

① 结点只有左子树为空，只需将右子树替换原来根结点的位置。

② 结点只有右子树为空，只需将右子树替换原来根结点的位置。

③ 结点的左右子树均不为空，先找到该结点的直接前驱结点（即中序遍历该结点的前驱结点），操作方法为先找该结点的左孩子，然后再找到最右的孩子，并记录最右孩子的前驱结点。将待删除结点的数据等于最右孩子结点数据，并将最右孩子的左子树移到最右孩子前驱结点的右子树位置。

（1）代码

void DelNode(BINARY_TREE_NODE **BSTNode) {
	BINARY_TREE_NODE *Tmp01 = NULL;
	BINARY_TREE_NODE *Tmp02 = NULL;

	if ((*BSTNode)->LeftChild == NULL) {
		Tmp01 = *BSTNode;
		*BSTNode = (*BSTNode)->RightChild;
		free(Tmp01);
		Tmp01 = NULL;
	} else if ((*BSTNode)->RightChild == NULL) {
		Tmp01 = *BSTNode;
		*BSTNode = (*BSTNode)->LeftChild;
		free(Tmp01);
		Tmp01 = NULL;
	} else {
		Tmp01 = *BSTNode;
		Tmp02 = (*BSTNode)->LeftChild;

		while (Tmp02->RightChild != NULL) {
			Tmp01 = Tmp02;
			Tmp02 = Tmp02->RightChild;
		}

		(*BSTNode)->Data = Tmp02->Data;

		if (Tmp01 != *BSTNode) {
			Tmp01->RightChild = Tmp02->LeftChild;
		}else {
			Tmp01->LeftChild = Tmp02->LeftChild;
		}

		free(Tmp02);
		Tmp02 = NULL;
	}
}

void DelBSTNode(BINARY_TREE_NODE **BSTNode, int Key) {
	if ((BSTNode == NULL) || (*BSTNode == NULL)) {
		return;
	}

	if (Key < (*BSTNode)->Data) {
		DelBSTNode(&((*BSTNode)->LeftChild), Key);
	} else if (Key > (*BSTNode)->Data) {
		DelBSTNode(&((*BSTNode)->RightChild), Key);
	} else {
		DelNode(BSTNode);
	}
}

（2）测试用例

/*TestDelBSTNode*/
void TestDelBSTNode(void) {
	//          50
	//    20           70
	// 10    30    60	  90
	BINARY_TREE_NODE *BiTreeNodePtr = NULL;
	BINARY_TREE_NODE_DATA Data[] = { {50, 1, 1}, {20, 1, 1}, {10, 0, 0}, {30, 0, 0}, {70, 1, 1}, {60, 0, 0}, {90, 0, 0} };
	char IfExistNodeFlag = 1;

	/*Test01*/
	//          50
	//    20           70
	//        30    60    90
	int Key01 = 10;
	int Num01 = 6;
	int CmpBSTNode01[] = { 50, 20, 30, 70, 60, 90 };

	/*Test02*/
	//          50
	//    30           70
	//              60    90
	int Key02 = 20;
	int Num02 = 5;
	int CmpBSTNode02[] = { 50, 30, 70, 60, 90 };

	/*Test03*/
	//          50
	//    30           60
	//						90
	int Key03 = 70;
	int Num03 = 4;
	int CmpBSTNode03[] = { 50, 30, 60, 90 };

	/*Test04*/
	//          30
	//                60
	//						90
	int Key04 = 50;
	int Num04 = 3;
	int CmpBSTNode04[] = { 30, 60, 90 };

	BuildBinaryTree(&BiTreeNodePtr, Data, IfExistNodeFlag);
	printf("PreOrderTraversePrintBinaryTree\n");
	PreOrderTraversePrintBinaryTree(BiTreeNodePtr);
	// printf("InOrderTraversePrintBinaryTree\n");
	// InOrderTraversePrintBinaryTree(BiTreeNodePtr);
	// printf("PostOrderTraversePrintBinaryTree\n");
	// PostOrderTraversePrintBinaryTree(BiTreeNodePtr);

	printf("-------Test start----------\n");
	InitNum();

	/*Test01*/
	printf("\n-------Test 01----------\n");
	DelBSTNode(&BiTreeNodePtr, Key01);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode01, BiTreeNodePtr, Num01);

	/*Test02*/
	printf("\n-------Test 02----------\n");
	DelBSTNode(&BiTreeNodePtr, Key02);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode02, BiTreeNodePtr, Num02);

	/*Test03*/
	printf("\n-------Test 03----------\n");
	DelBSTNode(&BiTreeNodePtr, Key03);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode03, BiTreeNodePtr, Num03);

	/*Test04*/
	printf("\n-------Test 04----------\n");
	DelBSTNode(&BiTreeNodePtr, Key04);
	printf("Compare\n");
	CmpPreOderBuildBinaryTree(CmpBSTNode04, BiTreeNodePtr, Num04);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

结果：

PreOrderTraversePrintBinaryTree

BiTreeNode->Data = 50

BiTreeNode->Data = 20

BiTreeNode->Data = 10

BiTreeNode->Data = 30

BiTreeNode->Data = 70

BiTreeNode->Data = 60

BiTreeNode->Data = 90

-------Test start----------

-------Test 01----------

Compare

BiTreeNode->Data = 50 , CmpNode[0] = 50

BiTreeNode->Data = 20 , CmpNode[1] = 20

BiTreeNode->Data = 30 , CmpNode[2] = 30

BiTreeNode->Data = 70 , CmpNode[3] = 70

BiTreeNode->Data = 60 , CmpNode[4] = 60

BiTreeNode->Data = 90 , CmpNode[5] = 90

PreOrderTraverseCompareNum = 6, NodeNum = 6

-------Test 02----------

Compare

BiTreeNode->Data = 50 , CmpNode[0] = 50

BiTreeNode->Data = 30 , CmpNode[1] = 30

BiTreeNode->Data = 70 , CmpNode[2] = 70

BiTreeNode->Data = 60 , CmpNode[3] = 60

BiTreeNode->Data = 90 , CmpNode[4] = 90

PreOrderTraverseCompareNum = 5, NodeNum = 5

-------Test 03----------

Compare

BiTreeNode->Data = 50 , CmpNode[0] = 50

BiTreeNode->Data = 30 , CmpNode[1] = 30

BiTreeNode->Data = 60 , CmpNode[2] = 60

BiTreeNode->Data = 90 , CmpNode[3] = 90

PreOrderTraverseCompareNum = 4, NodeNum = 4

-------Test 04----------

Compare

BiTreeNode->Data = 30 , CmpNode[0] = 30

BiTreeNode->Data = 60 , CmpNode[1] = 60

BiTreeNode->Data = 90 , CmpNode[2] = 90

PreOrderTraverseCompareNum = 3, NodeNum = 3

-------Test result----------

Print test result;

TestNum = 4, PassNum = 4, FaildNum = 0

Meditatorss
关注
二叉查找树（查找、插入、删除）——C语言
小白的逆袭
08-08 717
二叉查找树 二叉查找树（BST：Binary Search Tree）是一种特殊的二叉树，它改善了二叉树节点查找的效率。二叉查找树有以下性质： （1）若左子树不空，则左子树上所有节点的值均小于它的根节点的值 （2）若右子树不空，则右子树上所有节点的值均大于它的根节点的值 （3）左、右子树也分别为二叉排序树 （4）没有键值相等的节点 二叉查找树节点的定义： 1 typedef ...
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1437
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
定义二叉搜索树类,封装查找、插入、删除操作
12-05
定义二叉搜索树类,封装查找、插入、删除操作
C语言数据结构二叉排序树的建立、插入、删除、查找操作（原理+完整代码）
m0_61440484的博客
01-14 2458
C语言数据结构二叉排序树的建立、插入、删除、查找操作（原理+完整可运行代码）
二叉树的建立与查找（C语言）
qq_73884528的博客
05-16 3102
我们建立的二叉树只能向下查找，不能返回上层，所以要达到层次遍历效果可以多次遍历二叉树，每次遍历取其中一层来实现。我们先通过getHeightTree()获取二叉树的总高度，然后在遍历二叉树时分别对每层元素进行了查找。此外，先序遍历，中序遍历，后序遍历也可以采用非递归思路编写，以后补充，再见！所建二叉树较小数插入左侧，较大数插入右侧。建立二叉树过程与之前一样，多了队列建立和相关操作的代码，运行效果如下。通过这段代码可以建立一个二叉树,如图所示。第二种层次遍历可以通过递归方式实现。2.二叉树层次遍历方法。
二叉树的构建与遍历（C语言）
Enthusiastic_boy的博客
12-11 4494
目录 一、二叉树的存储结构 二、二叉树的遍历 一、二叉树的存储结构 1.顺序存储： 顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空 间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺 序存储在物理上是一个数组，在逻辑上是一颗二叉树。 2.链式存储 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是 链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存
二叉树增删改查C语言实现
最新发布
qq_64021539的博客
06-16 360
【数据结构】对二叉树的创建及增删改查C语言
数据结构——二叉树搜索树（二叉搜索树的概念、实现、先序遍历、中序遍历、后序遍历）
qq_52301431的博客
08-24 800
二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树二叉搜索树是一颗二叉树, 可以为空；如果不为空，满足以下性质：- 非空左子树的所有键值小于其根结点的键值。- 非空右子树的所有键值大于其根结点的键值。- 左、右子树本身也都是二叉搜索树。二叉搜索树的特点:- 二叉搜索树的特点就是相对较小的值总是保存在左结点上, 相对较大的值总是保存在右结点上.- 那么利用这个特点, 我们可以做什么事情呢?- 查找效率非常高, 这也是二叉搜索树中, 搜索的来源.
【进阶数据结构】二叉搜索树&经典习题讲解
East-sunrise的博客
03-20 1023
二叉搜索树 —— 轻易找到你想要的
【数据结构】查找：动态查找表(二叉排序树/BST/二叉搜索树，平衡二叉树/AVL)
自律带来自由
08-20 3112
#笔记整理 动态查找表——基于树表的查找法 动态查找表的特点： 表结构本身在查找过程中动态生成，即对于给定值 key，若表中存在关键字等于 key 的记录，则查找成功，否则插入关键字等于 key 的记录。 动态查找表的主要运算 - 创建、销毁 - 查找、插入和删除 - 遍历 二叉排序树（二叉搜素树、二叉查找树）BST (Binary Sort Tree)/(Binary Search Tree)...
实现二叉树的增删改查基本操作的c++程序
07-29
很好很强大的程序，实现二叉树的增删改查等基本操作，操作简单，程序结构清晰
C语言实现二叉树的创建、插入、删除、遍历等操作
12-14
C语言实现二叉树的创建、插入、删除、遍历（先序、中序、后续、深度优先、广度优先）、计算度为0,1,2的节点个数。 包括排序二叉树的实现
c语言二叉树
10-30
简单的二叉树操作，能实现增删改等基本功能，对了解二叉树是很有帮助的
二叉排序树的增，删，和查找操作（C语言）
努力奔跑的TH的博客
07-23 1467
二叉排序查找树 来自《大话数据结构》中的解释： 二叉排序树（Binary Sort Tree），又称二叉查找树，它或者是一个树，或者具有以下性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于它根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它根节点的值； 它的左、右二叉树也分别为二叉排序树。 常用的二叉排序树抽象数据结构类型有：查找，插入，删除，遍历等操作。首先来构造一棵树： typedef struct BiNode { int data; //节点的数据域. struct
C语言实现 二叉排序树 的插入、删除、查找（详细图解）
热门推荐
jakercl的博客
01-26 1万+
1 二叉排序树： 如果它的左子树不为空，那么左子树上所有节点的值均小于它的根节点的值 如果它的右子树不为空，那么右子树上所有节点的值均大于它的根节点的值 根节点的左子树和右子树均是二叉排序树 （二叉排序树可能退化为链表，所以有平衡二叉树的概念） ...
c语言_二叉排序树增删
weixin_37885641的博客
06-24 249
一、tree.h #pragma once #include<stdio.h> #include<stdlib.h> typedef struct binary_sort_tree { int* data; void* left; void* right; char ptr; }bst; #define BST_SIZE sizeof(bst) bst* tre...
数据结构之二叉排序树的生成以及增删改查（Ｃ语言的实现）
any_ways的博客
06-02 4138
定义： 二叉排序树或是空树，或是满足如下性质的二叉树： １，若其左子树非空，则左子树上所有的结点的值均小于根结点的值； ２，若其右子树非空，则右子树上所有的结点的值均大于等于根结点的值； ３，其左右子树本身又各是一棵二叉排序树 例如： 这就是一棵二叉排序树，左子树小于根结点，右子树大于等于根结点，再比如下面： 这就不是一个二叉排序树了，因为左子树上面的４８大于根结点45 二叉排序树的特点： 中序遍历下面二叉排序树 得到的结果是：3　12　24　37　45　53　61　78　9
二叉搜索树的查找、添加和删除操作
码农小札
08-29 541
class Node{ int data; Node lChild; Node rChild; public Node(int data){ this.data=data; this.lChild=null; this.rChild=null; } } public class Tree { public static void main(String[] arg
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值