• 数据结构-----二叉排序树

    目录

    前言

    1.什么是二叉排序树

    2.如何构建二叉排序树

    3.二叉排序树的操作

    3.1定义节点储存方式

    3.2插入节点操作

    3.2创建二叉排序树

    3.4遍历输出（中序遍历）

    3.5数据查找操作

    3.6获取最大值和最小值

    3.7删除节点操作

    3.8销毁二叉排序树

    4.完整代码

    前言

            今天我们继续学习新的知识点----排序二叉树，在此之前我们学习了相关的排序算法，给你一个数组，然后对这个数组进行排序。那么同样的我们也可以去构建一个二叉排序树，在创建树的过程中进行排序，也能实现排序的效果，下面就一起来看看吧！

    1.什么是二叉排序树

            二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。 

    给定一个二叉树，如果满足以下条件，那就是二叉排序树

    • 若它的左子树不空，则左子树上所有结点的值均小于它根结点的值。
    • 若它的右子树不空，则右子树上所有结点的值均大于它根结点的值。
    • 它的左、右子树都满足为⼆叉排序树

    二叉排序树最大的好处就是查找效率高，相较于链表一个一个去查找，二叉排序树可以去根据数据的排序规律来进行查找

    二叉排序树图示：

    2.如何构建二叉排序树

    比如给定一个数组 [62,88,58,47,35,73,51,99,37,93] ，首先拿到第一个数字，以这个数字为根结点（标准），进行构建，如果比这个数字要大的就放到右子树，比这个要小的就放到左子树去，如下图所示：

     这里我们可以看出，这些节点是一个一个去进行插入的，那我们就可以去通过递归插入的方式来创建，依次往下遍历，找到合适的位置再进行插入操作。

    3.二叉排序树的操作

    3.1定义节点储存方式

    1. #include
    2. #include
    3.  
    4. //二叉排序树节点存储方式
    5. typedef int DataType;
    6. typedef struct binarytreenode {
    7. 	DataType data;	//数据域
    8. 	struct binarytreenode* left;	//左指针 
    9. 	struct binarytreenode* right;	//右指针
    10. }BTnode;

    3.2插入节点操作

    插入一个节点首先就要找到这个节点应该插入的位置，从跟节点开始，如果比跟节点小就往左，大就往右，直到叶子节点的位置进行插入操作。

    代码实现： 

    1. //插入数据
    2. void Insert_node(BTnode** root, DataType data) {
    3. 	if (*root == NULL) {
    4. 		*root = (BTnode*)malloc(sizeof(BTnode));
    5. 		if (!*root) {
    6. 			printf("ERROR\n");
    7. 			exit(-1);
    8. 		}
    9. 		(*root)->data = data;
    10. 		(*root)->left = NULL;
    11. 		(*root)->right = NULL;
    12. 	}
    13.  
    14. 	else if ((*root)->data <= data)
    15. 		Insert_node(&(*root)->right, data);
    16. 	else if ((*root)->data > data)
    17. 		Insert_node(&(*root)->left, data);
    18. }

    3.2创建二叉排序树

    创建二叉排序树，只需要一一插入节点，最后返回根节点即可。代码如下：

    1. //创建排序二叉树
    2. BTnode* Create_sortBtree(DataType* arr, int size) {
    3. 	if (!arr)
    4. 		return NULL;
    5. 	else {
    6. 		BTnode* T = NULL;
    7. 		for (int i = 0; i < size; i++) {
    8. 			Insert_node(&T, arr[i]);
    9. 		}
    10. 		return T;
    11. 	}
    12. }

    3.4遍历输出（中序遍历）

    1. //中序遍历排序二叉树
    2. void mid_travel(BTnode* T)
    3. {
    4. 	if (!T)
    5. 		return;
    6. 	mid_travel(T->left);
    7. 	printf("%d ", T->data);
    8. 	mid_travel(T->right);
    9. }

    3.5数据查找操作

    在二叉排序树上查找某一个值节点，然后返回这个节点的操作。这里可以通过递归和非递归两种方法去实现，代码如下：

    递归实现： 

    1. BTnode* Btree_search(BTnode* root, DataType target) {
    2. 	if (!root)
    3. 		return NULL;
    4. 	if (target == root->data) {
    5. 		return root;
    6. 	}
    7. 	return target > root->data ? Btree_search(root->right, target) : Btree_search(root->left, target);
    8. }

     非递归实现（迭代实现）：

    1. //非递归查找
    2. BTnode* Btree_search_fa(BTnode* T, DataType target) {
    3. 	BTnode* p = T;
    4. 	while (p) {
    5. 		if (p->data == target)
    6. 		{
    7. 			return p;
    8. 		}
    9. 		p = target > p->data ? p->right : p->left;
    10. 	}
    11. 	return NULL;
    12. }

    3.6获取最大值和最小值

    在一个排序二叉树里面获取最大值或者是最小值，说白了也就是找到最右边和最左边节点就行了，二叉排序树的两个最值就在最两边。代码如下：

    获取最大值

    1. //获取最大值
    2. int Btree_max(BTnode* T) {
    3. 	BTnode* cur = T;
    4. 	while (cur->right) {
    5. 		cur = cur->right;
    6. 	}
    7. 	return cur->data;
    8. }

     获取最小值

    1. //获取最小值
    2. int Btree_min(BTnode* T) {
    3. 	BTnode* cur = T;
    4. 	while (cur->left) {
    5. 		cur = cur->left;
    6. 	}
    7. 	return cur->data;
    8. }

    3.7删除节点操作

    删除节点操作，这就有可能会破坏到排序二叉树的结构，所以要分几种情况去处理。一、如果删除的是叶子节点的话，那么就可以直接去删除，因为叶子节点左右节点都为空，不会影响到二叉排序树的结构；二、如果要删除的节点只有一个左子树或者是有一个右子树的话，我们只需要找到这个节点的左节点或者是右节点，然后顶替掉这个要删除的节点即可；三、如果要删除的节点都有左右子树的话，这里我们就需要去遍历找到比这个节点大一位或者是小一位的节点来顶替这个节点。如下图所示：

    1.删除叶子节点 

     2.删除只有一个左（右）子树的节点

    3.删除有左右子树的节点 

    代码实现：

    1. //删除节点
    2. void Btree_del(BTnode* T, DataType l) {
    3. 	if (!T) {
    4. 		printf("fuck no\n");
    5. 		return;
    6. 	}
    7. 	//找到这个要删除节点的父节点
    8. 	BTnode* p = T, * f = NULL;
    9. 	while (p) {
    10. 		if (p->data == l)
    11. 		{
    12. 			break;
    13. 		}
    14. 		f = p;
    15. 		p = l > p->data ? p->right : p->left;
    16. 	}
    17. 	if (!p)
    18. 	{
    19. 		printf("没有这个节点\n");
    20. 		return;
    21. 	}
    22. 	BTnode* target = p;//此时的要删除目标节点
    23. 	BTnode* par = f; //此时要删除节点的父节点
    24.  
    25. 	//第一种情况 此节点只有一个子树的时候
    26. 	if (!target->left && target->right != NULL)
    27. 	{
    28. 		if (target->data > par->data) {
    29. 			par->right = target->right;
    30. 		}
    31. 		else {
    32. 			par->left = target->right;
    33. 		}
    34. 		free(target);//释放空间
    35. 		target = NULL;
    36. 	}
    37. 	else if (target->left != NULL && !target->right) {
    38. 		if (target->data > par->data) {
    39. 			par->right = target->left;
    40. 		}
    41. 		else {
    42. 			par->left = target->left;
    43. 		}
    44. 		free(target);
    45. 		target = NULL;
    46. 	}
    47. 	//第二种情况，如果删除的是叶节点，直接删除即可
    48. 	else if (!target->left && !target->right) {
    49. 		if (target->data > par->data) {
    50. 			par->right = NULL;
    51. 		}
    52. 		else {
    53. 			par->left = NULL;
    54. 		}
    55. 		free(target);
    56. 		target = NULL;
    57. 	}
    58. 	//第三种情况,如果左右子树都存在的话
    59. 	//可以用右子树的最小元素
    60. 	//或者左子树的最大元素来替代被删除的节点
    61. 	//我这里就直接去用左树的最大代替这个节点
    62. 	else
    63. 	{
    64. 		BTnode* Lchild = target->left;
    65. 		while (Lchild->right != NULL) {
    66. 			Lchild = Lchild->right;
    67. 		}
    68. 		if (target->data > par->data) {
    69. 			par->right = Lchild;
    70. 		}
    71. 		else {
    72. 			par->left = Lchild;
    73. 		}
    74. 		free(target);
    75. 		target = NULL;
    76. 	}
    77. 	printf("Deleting successfully\n");
    78. }

    3.8销毁二叉排序树

    1. //销毁
    2. void Destory_btree(BTnode* T) {
    3. 	if (!T)
    4. 		return;
    5. 	BTnode* cur = T;
    6. 	if (cur->left)
    7. 		Destory_btree(cur->left);
    8. 	if (cur->right)
    9. 		Destory_btree(cur->right);
    10. 	free(T);
    11. }

    4.完整代码

    1. #include
    2. #include
    3.  
    4. //二叉排序树节点存储方式
    5. typedef int DataType;
    6. typedef struct binarytreenode {
    7. 	DataType data;	//数据域
    8. 	struct binarytreenode* left;	//左指针 
    9. 	struct binarytreenode* right;	//右指针
    10. }BTnode;
    11.  
    12.  
    13. //插入数据
    14. void Insert_node(BTnode** root, DataType data) {
    15. 	if (*root == NULL) {
    16. 		*root = (BTnode*)malloc(sizeof(BTnode));
    17. 		if (!*root) {
    18. 			printf("ERROR\n");
    19. 			exit(-1);
    20. 		}
    21. 		(*root)->data = data;
    22. 		(*root)->left = NULL;
    23. 		(*root)->right = NULL;
    24. 	}
    25.  
    26. 	else if ((*root)->data <= data)
    27. 		Insert_node(&(*root)->right, data);
    28. 	else if ((*root)->data > data)
    29. 		Insert_node(&(*root)->left, data);
    30. }
    31.  
    32.  
    33. //创建排序二叉树
    34. BTnode* Create_sortBtree(DataType* arr, int size) {
    35. 	if (!arr)
    36. 		return NULL;
    37. 	else {
    38. 		BTnode* T = NULL;
    39. 		for (int i = 0; i < size; i++) {
    40. 			Insert_node(&T, arr[i]);
    41. 		}
    42. 		return T;
    43. 	}
    44. }
    45.  
    46. //中序遍历排序二叉树
    47. void mid_travel(BTnode* T)
    48. {
    49. 	if (!T)
    50. 		return;
    51. 	mid_travel(T->left);
    52. 	printf("%d ", T->data);
    53. 	mid_travel(T->right);
    54. }
    55.  
    56. //递归查找数据
    57. BTnode* Btree_search(BTnode* root, DataType target) {
    58. 	if (!root)
    59. 		return NULL;
    60. 	if (target == root->data) {
    61. 		return root;
    62. 	}
    63. 	return target > root->data ? Btree_search(root->right, target) : Btree_search(root->left, target);
    64. }
    65. //非递归查找
    66. BTnode* Btree_search_fa(BTnode* T, DataType target) {
    67. 	BTnode* p = T, * f = NULL;
    68. 	while (p) {
    69. 		if (p->data == target)
    70. 		{
    71. 			return f;
    72. 		}
    73. 		f = p;
    74. 		p = target > p->data ? p->right : p->left;
    75. 	}
    76. 	return NULL;
    77. }
    78.  
    79. //获取最大值
    80. int Btree_max(BTnode* T) {
    81. 	BTnode* cur = T;
    82. 	while (cur->right) {
    83. 		cur = cur->right;
    84. 	}
    85. 	return cur->data;
    86. }
    87. //获取最小值
    88. int Btree_min(BTnode* T) {
    89. 	BTnode* cur = T;
    90. 	while (cur->left) {
    91. 		cur = cur->left;
    92. 	}
    93. 	return cur->data;
    94. }
    95.  
    96.  
    97. //删除节点
    98. void Btree_del(BTnode* T, DataType l) {
    99. 	if (!T) {
    100. 		printf("fuck no\n");
    101. 		return;
    102. 	}
    103. 	//找到这个要删除节点的父节点
    104. 	BTnode* p = T, * f = NULL;
    105. 	while (p) {
    106. 		if (p->data == l)
    107. 		{
    108. 			break;
    109. 		}
    110. 		f = p;
    111. 		p = l > p->data ? p->right : p->left;
    112. 	}
    113. 	if (!p)
    114. 	{
    115. 		printf("没有这个节点\n");
    116. 		return;
    117. 	}
    118. 	BTnode* target = p;//此时的要删除目标节点
    119. 	BTnode* par = f; //此时要删除节点的父节点
    120.  
    121. 	//第一种情况 此节点只有一个子树的时候
    122. 	if (!target->left && target->right != NULL)
    123. 	{
    124. 		if (target->data > par->data) {
    125. 			par->right = target->right;
    126. 		}
    127. 		else {
    128. 			par->left = target->right;
    129. 		}
    130. 		free(target);//释放空间
    131. 		target = NULL;
    132. 	}
    133. 	else if (target->left != NULL && !target->right) {
    134. 		if (target->data > par->data) {
    135. 			par->right = target->left;
    136. 		}
    137. 		else {
    138. 			par->left = target->left;
    139. 		}
    140. 		free(target);
    141. 		target = NULL;
    142. 	}
    143. 	//第二种情况，如果删除的是叶节点，直接删除即可
    144. 	else if (!target->left && !target->right) {
    145. 		if (target->data > par->data) {
    146. 			par->right = NULL;
    147. 		}
    148. 		else {
    149. 			par->left = NULL;
    150. 		}
    151. 		free(target);
    152. 		target = NULL;
    153. 	}
    154. 	//第三种情况,如果左右子树都存在的话
    155. 	//可以用右子树的最小元素
    156. 	//或者左子树的最大元素来替代被删除的节点
    157. 	//我这里就直接去用左树的最大代替这个节点
    158. 	else
    159. 	{
    160. 		BTnode* Lchild = target->left;
    161. 		while (Lchild->right != NULL) {
    162. 			Lchild = Lchild->right;
    163. 		}
    164. 		if (target->data > par->data) {
    165. 			par->right = Lchild;
    166. 		}
    167. 		else {
    168. 			par->left = Lchild;
    169. 		}
    170. 		free(target);
    171. 		target = NULL;
    172. 	}
    173. 	printf("Deleting successfully\n");
    174. }
    175.  
    176. //销毁
    177. void Destory_btree(BTnode* T) {
    178. 	if (!T)
    179. 		return;
    180. 	BTnode* cur = T;
    181. 	if (cur->left)
    182. 		Destory_btree(cur->left);
    183. 	if (cur->right)
    184. 		Destory_btree(cur->right);
    185. 	free(T);
    186. }
    187.  
    188. int main()
    189. {
    190. 	int a[] = { 53,17,78,9,45,65,87,23 };
    191. 	//创建二叉排序树
    192. 	BTnode* T = Create_sortBtree(a, sizeof(a) / sizeof(int));
    193. 	mid_travel(T);//遍历输出
    194. 	puts("");
    195. 	//删除最大最小值
    196. 	printf("max:%d  min:%d\n", Btree_max(T), Btree_min(T));
    197. 	//查找
    198. 	BTnode* find = Btree_search(T, 23);
    199. 	printf("查找结果%d\n", find->data);
    200.  
    201. 	//删除节点
    202. 	Btree_del(T, 45);
    203. 	mid_travel(T);
    204. 	puts("");
    205. 	//销毁操作
    206. 	Destory_btree(T);
    207. }
    208. //输出结果：
    209. //9 17 23 45 53 65 78 87
    210. //max:87  min : 9
    211. //查找结果23
    212. //Deleting successfully
    213. //9 17 23 53 65 78 87
    214.  
    215.

    以上就是二叉排序树的全部内容了，我们下次见咯！祝各位国庆节快乐！

     分享一张壁纸：

  • 相关阅读:
    基于SSM+Vue的咖啡销售系统
    【Redis】2、Redis持久化和性能管理
    PostgreSQL 分组聚合查询中 filter 子句替换 case when
    【C++题解】1043. 行李托运价格
    postgrest API CURD数据库
    IP地址、网关、网络/主机号、子网掩码关系
    世界杯将至，体育类加密项目迎来春天？
    2024测试工程师必学系列之Jmeter(36)：jmeter对图片验证码的处理
    支持向量机核技巧：10个常用的核函数总结
    mybatis-plus
  • 原文地址：https://blog.csdn.net/m0_73633088/article/details/133443742