devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

浅学C++(5)数据结构与算法(特殊的二叉树)_c++特殊树

作者：Monodyee | 2024-03-16 02:10:05

赞

踩

c++特殊树
  1. 有序二叉树：
  2.         左子树的数据小于根，右子树的数据大于等于根，这种树称为有序二叉树、二叉搜索树、二叉排序树
  3.         tap：这种树的节点需要频繁的插入、删除，因此不适合顺序存储，插入、删除必须有序
  4.         有序二叉树中的中序遍历就是从小到大，所以有序二叉树也是一种排序算法，查找又天然是二分查找
  5.  
  6.  
  7.     线索二叉树：
  8.         规律：在N个节点的链式二叉树中必定有N+1个空指针域
  9.         有序的链式二叉树中有很多的空指针，可以让这些指针指向下一个、前一个节点，这样的话在遍历时就不需要使用递归，
  10.         而可以使用循环遍历，可以提高树的遍历速度。
  11.  
  12.         中序线索二叉树节点数据项：
  13.             数据
  14.             左子树指针
  15.             右子树指针
  16.             右子树指针标志位(假表示真的右子树，真表示右子树指向下一个节点)
  17.  
  18.         实现过程：
  19.             1，构建有序二叉树
  20.             2，创建线索
  21.             3，通过线索循环遍历二叉树
  22.  
  23.     选择树：(胜者树、败者树)
  24.         是一种完全二叉树，待比较的数据都存储在最后一层，根节点是根据左右子树其中一个生成，因此根节点是最大或者最小的
  25.         选择树的功能是快速的找出最大数或者最小值
  26.  
  27.     堆：
  28.         是一种完全二叉树 不适合链式存储
  29.         大顶堆(大根堆)：根节点比左右子树大
  30.         小顶堆(小根堆)：根节点比左右子树小
  31.         数据项：
  32.             存储数据的内存首地址
  33.             容量
  34.             数量
  35.         操作：创建、销毁、添加、删除、空堆、满堆
  36.         堆可以实现优先队列
  37.  
  38.  
  39.     平衡二叉树：(AVL树)
  40.         前提是有序的二叉树，它的左右子树的高度差不超过1，而且它的所有子树也满足这个条件
  41.         如果一个有序二叉树呈现接近单支状（类似链表），它的查找效率接近链表，因此只有达到平衡查找的效率才会最高
  42.         由于节点的值受限，因此只能通过调整达到有序，而不能进行值的修改
  43.         二叉树不平衡的基础原因：
  44.                  x                                  y
  45.                /   \                              /   \
  46.               y     t1                           z     x
  47.              / \            以y为轴向右旋转      / \   / \
  48.             z   t2                             t3 t4 t2 t1      
  49.            /     \
  50.          t3       t4
  51.  
  52.  
  53.                  x                                 y
  54.                /   \                             /   \
  55.               t1    y                           x     z
  56.                    / \      以y为轴向左旋转     / \   / \
  57.                   t2  z                       t1 t2 t3 t4       
  58.                      / \
  59.                    t3   t4
  60.  
  61.                  x                                  x                                z
  62.                /   \                              /   \                            /   \
  63.               y     t1                           z     t1                         y     x
  64.              / \            以z为轴向左旋转      / \            以z为轴向右旋转    / \   / \
  65.             t2  z                              y   t4                           t2 t3 t4 t1
  66.                / \                            / \
  67.               t3  t4                         t2  t3
  68.  
  69.                 x                                    x                               z
  70.               /   \                                /   \                           /   \
  71.              t1    y        以z为轴向右旋转        t1    z     以z为轴向左旋转      x     y
  72.                   / \                                  / \                       / \   / \ 
  73.                  z   t2                               t3  y                     t1 t3 t4 t2
  74.                 / \                                      / \
  75.                t3 t4                                    t4  t2
  76.  
  77.     红黑树：
  78.         也是一种自平衡的树，他不是根据子树的高度差来调整平衡的，而是给节点设置一种颜色，来达到平衡
  79.         红黑树的特性：
  80.             1，每个节点必须有颜色（红或黑）
  81.             2，根节点必须是黑色
  82.             3，红黑树的叶子节点（NULL）必须为黑色
  83.             4，如果一个节点是红色，则他的子节点必须为黑色，不能有连续的红色节点
  84.             5，从一个节点出发到该节点的子孙节点的所有路径上包含了相同数量的黑色节点
  85.                 保证大致上红黑树是平衡的（最长路径不超过最短路径的两倍）
  86.  
  87.         红黑树插入后的调整：
  88.             插入节点一定为红色
  89.                 1，如果父节点是黑色，则直接插入
  90.                 2，如果父节点是红色，需要调整
  91.                     叔叔不存在或者叔叔为黑色 进行 左旋或者右旋 祖父节点置红色 父节点置黑色
  92.  
  93.                     叔叔存在且为红色 祖父节点置红色 父节点和叔叔置黑色 把祖父节点当作当前节点，继续向上讨论调整
  94.  
  95.         优点：插入、删除的效率比AVL树高
  96.         缺点：没有AVL树平均，查找效率没有AVL树高，但也并不差
  97.  
  98.     哈夫曼树：
  99.         基本概念：
  100.         路径长度：从一个节点到另一个节点之间的路径条目数
  101.             根节点到第N层节点的路径长度为N-1
  102.         树的路径长度：从根节点出发到每个节点的路径长度之和
  103.         节点的权：若将树中节点赋予一个有某种意义的数值，该数值称为该节点的权
  104.         节点的带权路径长度：从根节点到该节点的路径长度与该节点的权的乘积
  105.         树的带权路径长度：所有的叶子节点的带权路径长度之和 WPL
  106.             WPL是衡量一颗带权二叉树的优劣的关键
  107.  
  108.         哈夫曼树的目的是为了生成一颗WPL最小的带权二叉树
  109.         构建哈夫曼树：
  110.             1，把n个带权节点存入一个集合F中，把每个节点左右子树置空
  111.             2，从F中选取权值最小的两个节点作为左右子树构建成一颗新的二叉树，且新的根节点的权为左右子树的权值之和
  112.             3，从F中删除刚刚选出来的两个节点，把新得到的根节点放入F中
  113.             4，重复2、3操作，直到F中只剩一棵树，既是哈夫曼树 
  114.  
  115.     哈夫曼编码：
  116.     目的：解决当年远距离通信(电报)的数据传输的最优解
  117.     待发送的文字：BADCA DFEED
  118.     方法1：转成二进制发送 A 000 B 001   共30个字符
  119.     方法2：
  120.         a、根据文字出现频率，构建哈夫曼树
  121.             假设频率： A27 B8 C15 D15 E30 F5
  122.         b、规定哈夫曼树的左分支为0，右分支为1，则从根节点到叶子节点经过的路径分支所组成的0、1序列为该对应字符的哈弗曼编码
  123.         哈夫曼编码：A01  B1001  C101  D00  E11  F1000
  124.         1001010010101001000111100    共25个字符
  125.     作用：数据压缩、文件压缩的其中一种方式

线索二叉树的实现

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4.  
  5. //线索二叉树
  6. typedef struct TreeNode
  7. {
  8. 	int data;
  9. 	struct TreeNode* left;
  10. 	struct TreeNode* right;
  11. 	bool rflag;//为真时右子树是线索
  12. }TreeNode;
  13.  
  14. TreeNode* create_tree_node(int data)
  15. {
  16. 	TreeNode* node = malloc(sizeof(TreeNode));
  17. 	node->data = data;
  18. 	node->left = NULL;
  19. 	node->right = NULL;
  20. 	node->rflag = false;
  21. 	return node;
  22. }
  23.  
  24. void _insert_tree(TreeNode** root,TreeNode* node)
  25. {
  26. 	if(NULL == *root)
  27. 	{
  28. 		*root = node;
  29. 		return;
  30. 	}
  31. 	if((*root)->data > node->data)
  32. 		_insert_tree(&(*root)->left,node);
  33. 	else
  34. 		_insert_tree(&(*root)->right,node);
  35. }
  36. void insert_tree(TreeNode** root,int data)
  37. {
  38. 	_insert_tree(root,create_tree_node(data));
  39. }
  40.  
  41. void ldr_show(TreeNode* root)
  42. {
  43. 	if(NULL == root) return;
  44. 	ldr_show(root->left);
  45. 	printf("%d ",root->data);
  46. 	ldr_show(root->right);
  47. }
  48.  
  49. TreeNode* prev = NULL;//表示当前root的上一个节点
  50.  
  51. //中序遍历 创建线索
  52. void make_clue(TreeNode* root)
  53. {
  54. 	if(NULL == root) return;
  55. 	make_clue(root->left);
  56. 	if(NULL != prev && NULL == prev->right)
  57. 	{
  58. 		prev->right = root;
  59. 		prev->rflag = true;
  60. 	}
  61. 	prev = root;
  62. 	make_clue(root->right);
  63. }
  64.  
  65. void clue_show_tree(TreeNode* root)
  66. {
  67. 	while(root)
  68. 	{
  69. 		while(root->left) root = root->left;
  70. 		printf("%d ",root->data);
  71. 		while(root->rflag)
  72. 		{
  73. 			root = root->right;
  74. 			printf("%d ",root->data);
  75. 		}
  76. 		root = root->right;
  77. 	}
  78. }

堆的实现

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4.  
  5. //大顶堆
  6.  
  7. #define TYPE int
  8.  
  9. #define SWAP(a,b) {typeof(a) t=(a);(a)=(b);(b)=t;}
  10.  
  11. typedef struct Heap
  12. {
  13. 	TYPE* arr;
  14. 	size_t cal;
  15. 	size_t cnt;
  16. }Heap;
  17.  
  18. Heap* create_heap(size_t cal)
  19. {
  20. 	Heap* heap = malloc(sizeof(Heap));
  21. 	heap->arr = malloc(sizeof(TYPE)*cal);
  22. 	heap->cal = cal;
  23. 	heap->cnt = 0;
  24. 	return heap;
  25. }
  26.  
  27. //满堆
  28. bool full_heap(Heap* heap)
  29. {
  30. 	return heap->cnt >= heap->cal;	
  31. }
  32. //空堆
  33. bool empty_heap(Heap* heap)
  34. {
  35. 	return 0 == heap->cnt;	
  36. }
  37. //添加
  38. bool add_heap(Heap* heap,TYPE data)
  39. {
  40. 	if(full_heap(heap)) return false;
  41. 	heap->arr[heap->cnt++] = data;
  42. 	
  43. 	//添加的位置进行调整 形成大顶堆
  44. 	int i = heap->cnt;
  45. 	while(i>1)
  46. 	{
  47. 		if(data > heap->arr[i/2-1])
  48. 		{
  49. 			SWAP(heap->arr[i-1],heap->arr[i/2-1]);
  50. 			i = i/2;
  51. 		}
  52. 		else return true;
  53. 	}
  54. }
  55. //删除 只删除堆顶
  56. bool del_heap(Heap* heap)
  57. {
  58. 	if(empty_heap(heap)) return false;
  59. 	//交换堆顶和末尾 并删除
  60. 	SWAP(heap->arr[0],heap->arr[heap->cnt-1]);
  61. 	heap->cnt--;
  62. 	int i = 1;//编号
  63. 	while(i <= heap->cnt)
  64. 	{
  65. 		//有右子树
  66. 		if(2*i+1 <= heap->cnt)
  67. 		{
  68. 			if(heap->arr[2*i] > heap->arr[2*i-1] && heap->arr[i-1] < heap->arr[2*i])
  69. 			{
  70. 				SWAP(heap->arr[i*2],heap->arr[i-1]);
  71. 				i = i*2+1;
  72. 			}
  73. 			else if(heap->arr[i-1] < heap->arr[2*i-1])
  74. 			{
  75. 				SWAP(heap->arr[i*2-1],heap->arr[i-1]);
  76. 				i = i*2;	
  77. 			}
  78. 			else break;
  79. 		}
  80. 		//左
  81. 		else if(2*i <= heap->cnt)
  82. 		{
  83. 			if(heap->arr[i-1] < heap->arr[2*i-1])
  84. 			{
  85. 				SWAP(heap->arr[i*2-1],heap->arr[i-1]); 
  86. 				i = i*2;	
  87. 			}
  88. 			else break;
  89. 		}
  90. 		else break;
  91. 	}
  92. 	return true;
  93. }
  94. //遍历
  95. void show_heap(Heap* heap)
  96. {
  97. 	for(int i=0;i<heap->cnt;i++)
  98. 	{
  99. 		printf("%d ",heap->arr[i]);	
  100. 	}
  101. 	printf("\n");
  102. }
  103. //查看堆顶
  104. TYPE top_heap(Heap* heap)
  105. {
  106. 	return heap->arr[0];	
  107. }
  108.  
  109. //堆排序
  110. void sort_heap(int* arr,int len)
  111. {
  112. 	//把数组调整成堆结构
  113. 	for(int i=1;i<=len;i++)
  114. 	{
  115. 		int j=i;
  116. 		while(j>1)
  117. 		{
  118. 			if(arr[j-1]>arr[j/2-1])
  119. 			{
  120. 				SWAP(arr[j-1],arr[j/2-1]);
  121. 				j = j/2;
  122. 			}
  123. 			else break;
  124. 		}
  125. 	}
  126. 	//删除堆顶 直到堆为空
  127. 	while(len >1)
  128. 	{
  129. 		//交换堆顶 末尾
  130. 		SWAP(arr[0],arr[len-1]);
  131. 		len--;
  132. 		//从上往下
  133. 		int i = 1;
  134. 		while(i <= len)
  135. 		{
  136. 			if(i*2+1 <= len)
  137. 			{
  138. 				if(arr[i*2] > arr[2*i-1] && arr[i*2] > arr[i-1])
  139. 				{
  140. 					SWAP(arr[i*2],arr[i-1]);
  141. 					i = i*2+1;
  142. 				}
  143. 				else if(arr[2*i-1] > arr[i-1])
  144. 				{
  145. 					SWAP(arr[i*2-1],arr[i-1]);	
  146. 					i = i*2;
  147. 				}
  148. 				else break;
  149. 			}
  150. 			else if(i*2 <= len)
  151. 			{
  152. 				if(arr[2*i-1] > arr[i-1])
  153. 				{	
  154. 					SWAP(arr[i*2-1],arr[i-1]); 
  155. 					i = i*2;	
  156. 				}
  157. 				else break;
  158. 			}
  159. 			else break;
  160. 		}
  161. 	}
  162. }
  163.  
  164. //递归依赖  从top坐标到end坐标从上往下调整成堆结构
  165. void _sort_heap_recursion(int* arr,int top,int end)
  166. {
  167. 	if(top >= end) return;
  168. 	int max = top+1; //假设 max 是左右根中最大值的编号
  169. 	int l = max*2;
  170. 	int r = max*2+1;
  171. 	if(l-1 <= end && arr[l-1] > arr[max-1])
  172. 	{
  173. 		//有左子树 且左子树的值大于max的值 更新max
  174. 		max = l;
  175. 	}
  176. 	if(r-l <= end && arr[r-1] > arr[max-1])
  177. 	{
  178. 		//有左子树 且左子树的值大于max的值 更新max
  179. 		max = r;
  180. 	}
  181. 	if(max-1 != top)
  182. 	{
  183. 		//max是最大的 交换根与max
  184. 		SWAP(arr[top],arr[max-1]);	
  185. 		_sort_heap_recursion(arr,max-1,end);
  186. 	}
  187. }
  188.  
  189. //递归实现堆排序
  190. void sort_heap_recursion(int* arr,int len)
  191. {
  192. 	//把数组调整成堆结构
  193. 	for(int i=1;i<=len;i++)
  194. 	{
  195. 		int j=i;
  196. 		while(j>1)
  197. 		{
  198. 			if(arr[j-1]>arr[j/2-1])
  199. 			{
  200. 				SWAP(arr[j-1],arr[j/2-1]);
  201. 				j = j/2;
  202. 			}
  203. 			else break;
  204. 		}
  205. 	}
  206. 	for(int i=len-1;i>0;i--)
  207. 	{
  208. 		SWAP(arr[0],arr[i]);
  209. 		_sort_heap_recursion(arr,0,i-1);
  210. 	}
  211. }

平衡二叉树的实现

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4.  
  5. typedef struct TreeNode
  6. {
  7. 	int data;
  8. 	struct TreeNode* left;
  9. 	struct TreeNode* right;
  10. }TreeNode;
  11.  
  12. TreeNode* create_tree_node(int data)
  13. {
  14. 	TreeNode* node = malloc(sizeof(TreeNode));
  15. 	node->data = data;
  16. 	node->left = NULL;
  17. 	node->right = NULL;
  18. 	return node;
  19. }
  20.  
  21. //  高度
  22. int high_tree(TreeNode* root)
  23. {
  24. 	if(NULL == root) return 0;
  25. 	int lh = high_tree(root->left);
  26. 	int rh = high_tree(root->right);
  27. 	return lh>rh ? lh+1 : rh+1;
  28. }
  29. //  计算左右子树高度差
  30. int diff_high(TreeNode* root)
  31. {
  32. 	return high_tree(root->left) - high_tree(root->right);	
  33. }
  34.  
  35. //  右旋
  36. TreeNode* right_rotate(TreeNode* x)
  37. {
  38. 	TreeNode* y = x->left;
  39. 	TreeNode* t2 = y->right;
  40.  
  41. 	y->right = x;
  42. 	x->left = t2;
  43. 	return y;
  44. }
  45.  
  46. //  左旋
  47. TreeNode* left_rotate(TreeNode* x)
  48. {
  49. 	TreeNode* y = x->right;
  50. 	TreeNode* t2 = y->left;
  51. 		
  52. 	y->left = x;
  53. 	x->right = t2;
  54. 	return y;
  55. }
  56.  
  57. //  自动调整成平衡 返回调整后的root
  58. TreeNode* auto_balance(TreeNode* x)
  59. {
  60. 	if(NULL == x) return NULL;
  61. 	int lh = high_tree(x->left);
  62. 	int rh = high_tree(x->right);
  63. 	//  左比右高
  64. 	if(lh-rh > 1)
  65. 	{
  66. 		if(diff_high(x->left) >= 0)
  67. 		{
  68. 			//  x->left 为轴 右旋	
  69. 			x = right_rotate(x);
  70. 		}
  71. 		else
  72. 		{
  73. 			//  左旋
  74. 			x->left = left_rotate(x);
  75. 			//  右旋
  76. 			x = right_rotate(x);
  77. 		}
  78. 	}
  79. 	//  右比左高
  80. 	if(rh-lh > 1)
  81. 	{
  82. 		if(diff_high(x->right) >= 0)
  83. 		{
  84. 			//  右旋
  85. 			x->right = right_rotate(x->right);
  86. 			//  左旋
  87. 			x = left_rotate(x);
  88. 		}
  89. 		else
  90. 		{
  91. 			//  左旋
  92. 			x = left_rotate(x);
  93. 		}
  94. 	}
  95. 	return x;
  96. }
  97. //  添加  通过返回值返回添加后的树的root
  98. //  返回值相当于root的指向
  99. TreeNode* insert_tree(TreeNode* root,int data)	
  100. {
  101. 	if(NULL == root)
  102. 		return create_tree_node(data);
  103. 	
  104. 	if(data < root->data)
  105. 		root->left = insert_tree(root->left,data);
  106. 	else
  107. 		root->right = insert_tree(root->right,data);
  108.  
  109. 	//  调整成平衡
  110. 	root = auto_balance(root);
  111. 	return root;
  112. }
  113. 	
  114. //  前序
  115. void dlr_show(TreeNode* root)
  116. {
  117. 	if(NULL == root) return;
  118. 	printf("%d ",root->data);
  119. 	dlr_show(root->left);
  120. 	dlr_show(root->right);
  121. }
  122.  
  123. //  中序
  124. void ldr_show(TreeNode* root)
  125. {
  126. 	if(NULL == root) return;
  127. 	ldr_show(root->left);
  128. 	printf("%d ",root->data);
  129. 	ldr_show(root->right);
  130. }
  131.  
  132. /*
  133. 	删除节点
  134. 	1、待删除的节点是叶子节点，直接删除，重新调整平衡
  135. 	2、待删除的节点左或右子树为空，则使用非空节点替换
  136. 	3、待删除的节点左右子树非空，根据左右子树高度，选择高的一边
  137. 		如果是左高则选择左子树中的最大值替换待删除节点的值
  138. 		然后删除左子树的最大值节点
  139. 		反之则选择右子树的最小值节点进行同样操作
  140. 	最后重新调整平衡
  141. */
  142.  
  143. //  找最小值
  144. TreeNode* min_data(TreeNode* root)
  145. {
  146. 	TreeNode* min = root;
  147. 	while(min->left) min = min->left;
  148. 	return min;
  149. }
  150. //  找最大值
  151. TreeNode* max_data(TreeNode* root)
  152. {
  153. 	TreeNode* max = root;
  154. 	while(max->right) max = max->right;
  155. 	return max;
  156. }
  157. TreeNode* del_tree(TreeNode* root,int data)
  158. {
  159. 	if(NULL == root) return NULL;
  160. 	if(data == root->data)
  161. 	{
  162. 		//  左右为空 直接删除
  163. 		if(NULL == root->left && NULL == root->right)
  164. 		{
  165. 			free(root);
  166. 			return NULL;
  167. 		}
  168. 		//  左子树非空
  169. 		if(NULL == root->right)
  170. 		{
  171. 			TreeNode* temp = root->left;
  172. 			free(root);
  173. 			return temp;
  174. 		}
  175. 		if(NULL == root->left)
  176. 		{
  177. 			TreeNode* temp = root->right;
  178. 			free(root);
  179. 			return temp;
  180. 		}
  181. 		//  左右子树非空
  182. 		int lh = high_tree(root->left);
  183. 		int rh = high_tree(root->right);
  184. 		if(lh >= rh)
  185. 		{
  186. 			//  左子树找最大值节点	
  187. 			TreeNode* node = max_data(root->left);
  188. 			//把最大值赋值给待删除节点
  189. 			root->data = node->data;
  190. 			//把左子树删除最大值节点
  191. 			root->left = del_tree(root->left,node->data);
  192. 		}
  193. 		else
  194. 		{
  195. 			TreeNode* node = min_data(root->right);
  196. 			//  右子树找最小值节点	
  197. 			root->data = node->data;
  198. 			root->right = del_tree(root->right,node->data);
  199. 		}
  200. 	}
  201. 	if(data < root->data)
  202. 		root->left = del_tree(root->left,data);
  203. 	else 
  204. 		root->right = del_tree(root->right,data);
  205.  
  206. 	root = auto_balance(root);
  207. 	return root;
  208. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/246274
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号