ACM常用模板——伸展树

最新推荐文章于 2020-12-30 15:02:00 发布
最新推荐文章于 2020-12-30 15:02:00 发布
阅读量579 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kukajenny/article/details/49872131
版权 

  
  
  1. #include <stdio.h>

  2. #include <stdlib.h>
  3. typedef struct node *position;
  4. typedef int ElementTP;
  5. struct node {
  6.     int depth;
  7.     position parent;
  8.     ElementTP element;
  9.     position lchild;
  10.     position rchild;
  11. };
  12. /* pointer => root node of the tree */
  13. typedef struct node *TREE;
  14. position insert_value(TREE, ElementTP);
  15. int depth(TREE);
  17. static void insert_node_to_nonempty_tree(TREE, position);
  18. static void update_root_depth(TREE);
  19. static TREE recover_avl(TREE, position);
  20. static int depth_diff(TREE);
  21. static position insert_leaf(TREE, ElementTP);
  22. static void insert_node_to_nonempty_tree(TREE, position);
  23. static TREE left_single_rotate(TREE);
  24. static TREE left_double_rotate(TREE);
  25. static TREE right_single_rotate(TREE);
  26. static TREE right_double_rotate(TREE);
  28. int main(void)
  29. {
  30.     TREE tr;
  31.     position np;
  32.     ElementTP element;
  33.     tr = NULL;
  34.     tr = insert_value(tr, 18);
  35.     tr = insert_value(tr, 5);
  36.     printf("root: %d\n", tr->element);
  37.     printf("depth: %d\n", depth(tr));
  38.     tr = insert_value(tr, 2);
  39.     printf("root: %d\n", tr->element);
  40.     printf("depth: %d\n", depth(tr));
  41.     tr = insert_value(tr, 4);
  42.     printf("root: %d\n", tr->element);
  43.     printf("depth: %d\n", depth(tr));
  44.     printf("root->lchild: %d\n", tr->lchild->element);
  45.     tr = insert_value(tr, 3);
  46.     printf("root: %d\n", tr->element);
  47.     printf("depth: %d\n", depth(tr));
  48.     printf("root->lchild: %d\n", tr->lchild->element);
  49.     printf("root->lchild->lchild: %d\n", tr->lchild->lchild->element);
  50. }
  51. /*
  52.  * insert value
  53.  *
  54.  */
  55. position insert_value(TREE tr, ElementTP value)//插入叶子节点
  56. {
  57.     position New;
  59.     /* insert a value to a binary search tree */
  60.     New = insert_leaf(tr, value);
  61.     update_root_depth(New);
  62.     if (tr == NULL) {
  63.         tr = New;
  64.     }
  65.     else {
  66.         tr = recover_avl(tr, New);
  67.     }
  68.     return tr;
  69. }
  71. /*
  72.  * get the depth of the tree
  73.  * use this function to access depth
  74.  */
  75. int depth(TREE tr) {
  76.     if (tr == NULL) {
  77.         return 0;
  78.     }
  79.     else {
  80.         return tr->depth;
  81.     }
  82. }
  84. //========================================
  85. // static functions: for internal use
  87. /*
  88.  * traverse the path from new node to root node
  89.  * make one rotation, recover AVL and stop
  90.  */
  91. static TREE recover_avl(TREE tr, position np)
  92. {
  93.     int myDiff;
  94.     while (np != NULL) {
  95.         update_root_depth(np);
  96.         myDiff = depth_diff(np);
  97.     if (myDiff > 1 || myDiff < -1) {
  98.             if (myDiff > 1) {
  99.                 /* left rotate needed */
  100.                 if(depth_diff(np->rchild) > 0) {
  101.                     np = left_single_rotate(np);
  102.                 }
  103.                 else {
  104.                     np = left_double_rotate(np);
  105.                 }
  106.             }
  107.             if (myDiff < -1) {
  108.                 if(depth_diff(np->lchild) < 0) {
  109.                     np = right_single_rotate(np);
  110.                 }
  111.                 else {
  112.                     np = right_double_rotate(np);
  113.                 }
  114.             }
  115.             /* if rotation changes root node */
  116.             if (np->parent == NULL) tr = np;
  117.             break;
  118.         }
  119.         np = np->parent;
  120.     }
  122.     return tr;
  123. }
  125. /*
  126.  * difference of rchild->depth and lchild->depth
  127.  */
  128. static int depth_diff(TREE tr)
  129. {
  130.     if (tr == NULL) {
  131.         return 0;
  132.     }
  133.     else {
  134.         return depth(tr->rchild) - depth(tr->lchild);
  135.     }
  136. }
  139. /*
  140.  * left single rotation
  141.  * return the new root
  142.  */
  143. static TREE left_single_rotate(TREE tr)
  144. {
  145.     TREE newRoot, parent;
  146.     parent  = tr->parent;
  147.     newRoot = tr->rchild;
  148.     /* detach & attach */
  149.     if (newRoot->lchild != NULL) newRoot->lchild->parent = tr;
  150.     tr->rchild = newRoot->lchild;
  151.     update_root_depth(tr);
  153.     /* raise new root node */
  154.     newRoot->lchild = tr;
  155.     newRoot->parent = parent;
  156.     if (parent != NULL) {
  157.         if (parent->lchild == tr) {
  158.         parent->lchild = newRoot;
  159.     }
  160.     else {
  161.         parent->rchild = newRoot;
  162.     }
  163.     }
  164.     tr->parent = newRoot;
  165.     update_root_depth(newRoot);
  166.     return newRoot;
  167. }
  169. /*
  170.  * right single rotation
  171.  * return the new root
  172.  */
  173. static TREE right_single_rotate(TREE tr)
  174. {
  175.     TREE newRoot, parent;
  176.     parent  = tr->parent;
  177.     newRoot = tr->lchild;
  179.     /* detach & attach */
  180.     if (newRoot->rchild != NULL) newRoot->rchild->parent = tr;
  181.     tr->lchild = newRoot->rchild;
  182.     update_root_depth(tr);
  184.     /* raise new root node */
  185.     newRoot->rchild = tr;
  186.     newRoot->parent = parent;
  187.     if (parent != NULL) {
  188.         if (parent->lchild == tr) {
  189.         parent->lchild = newRoot;
  190.     }
  191.     else {
  192.         parent->rchild = newRoot;
  193.     }
  194.     }
  195.     tr->parent = newRoot;
  196.     update_root_depth(newRoot);
  197.     return newRoot;
  198. }
  200. /*
  201.  * left double rotation
  202.  * return
  203.  */
  204. static TREE left_double_rotate(TREE tr)
  205. {
  206.     right_single_rotate(tr->rchild);
  207.     return left_single_rotate(tr);
  208. }
  210. /*
  211.  * right double rotation
  212.  * return
  213.  */
  214. static TREE right_double_rotate(TREE tr)
  215. {
  216.     left_single_rotate(tr->lchild);
  217.     return right_single_rotate(tr);
  218. }
  220. /*
  221.  * update tr->depth
  222.  * assume lchild->depth and rchild->depth are correct
  223.  */
  224. static void update_root_depth(TREE tr)
  225. {
  226.     int maxChildDepth;
  227.     int depLChild, depRChild;
  228.     if (tr==NULL) return;
  229.     else {
  230.         depLChild = depth(tr->lchild);
  231.         depRChild = depth(tr->rchild);
  232.         maxChildDepth = depLChild > depRChild ? depLChild : depRChild;
  233.         tr->depth = maxChildDepth + 1;
  234.     }
  235. }
  237. /*
  238.  * insert a new value into the tree as a leaf
  239.  * return address of the new node
  240.  */
  241. static position insert_leaf(TREE tr, ElementTP value)
  242. {
  243.     position np;
  244.     /* prepare the node */
  245.     np = (position) malloc(sizeof(struct node));
  246.     np->element = value;
  247.     np->parent  = NULL;
  248.     np->lchild  = NULL;
  249.     np->rchild  = NULL;
  251.     if (tr != NULL) {
  252.         insert_node_to_nonempty_tree(tr, np);
  253.     }
  254.     return np;
  255. }
  257. /*
  258.  * insert a node to a non-empty tree
  259.  * called by insert_value()
  260.  */
  261. static void insert_node_to_nonempty_tree(TREE tr, position np)
  262. {
  263.     /* insert the node */
  264.     if(np->element <= tr->element) {
  265.         if (tr->lchild == NULL) {
  266.             /* then tr->lchild is the proper place */
  267.             tr->lchild = np;
  268.             np->parent = tr;
  269.             return;
  270.         }
  271.         else {
  272.             insert_node_to_nonempty_tree(tr->lchild, np);
  273.         }
  274.     }
  275.     else if(np->element > tr->element) {
  276.         if (tr->rchild == NULL) {
  277.             tr->rchild = np;
  278.             np->parent = tr;
  279.             return;
  280.         }
  281.         else {
  282.             insert_node_to_nonempty_tree(tr->rchild, np);
  283.         }
  284.     }
  285. }

输出如下：

root: 18
depth: 2

root: 5
depth: 2

root: 5
depth: 3
root->lchild: 2

depth: 3
root->lchild: 3
root->lchild->lchild: 2

模板二：

   
   
  1. #ifndef HEAD_H_
  2. #define HEAD_H_
  4. #include <stdio.h>
  5. #include <stdlib.h>
  7. typedef int ElementType;
  8. typedef struct AvlNode              // AVL树的节点
  9. {
  10. 	ElementType data;
  11. 	struct AvlNode *left;           // 左孩子
  12. 	struct AvlNode *right;          // 右孩子
  13. 	int Height;
  14. }*Position,*AvlTree;
  16. AvlTree MakeEmpty(AvlTree T);
  17. Position Find(ElementType x,AvlTree T);
  18. Position FindMin(AvlTree T);
  19. Position FindMax(AvlTree T);
  20. AvlTree  Insert(ElementType x,AvlTree T);
  21. AvlTree  Delete(ElementType x,AvlTree T);
  22. ElementType Retrieve(Position P);
  23. void Display(AvlTree T);
  25. #endif /* HEAD_H_ */
  26. /*
  27.  *   初始化AVL树
  28.  */
  29. AvlTree MakeEmpty(AvlTree T)
  30. {
  31. 	if( T != NULL)
  32. 	{
  33. 		MakeEmpty(T->left);
  34. 		MakeEmpty(T->right);
  35. 		free(T);
  36. 	}
  37. 	return NULL;
  38. }
  40. /*
  41.  * 查找 可以像普通二叉查找树一样的进行，所以耗费O(log n)时间，因为AVL树总是保持平衡的。
  42.  * 不需要特殊的准备，树的结构不会由于查找而改变。（这是与伸展树查找相对立的，它会因为查找而变更树结构。）
  43.  */
  44. Position Find(ElementType x,AvlTree T)
  45. {
  46. 	if(T == NULL)
  47. 		return NULL;
  48. 	if(x < T->data)
  49. 		return Find(x,T->left);
  50. 	else if(x > T->data)
  51. 		return Find(x,T->right);
  52. 	else
  53. 		return  T;
  54. }
  55. /*
  56.  *   FindMax，FindMin 查找最大和最小值，
  57.  */
  58. Position FindMin(AvlTree T)
  59. {
  60. 	if(T == NULL)
  61. 		return NULL;
  62. 	if( T->left == NULL)
  63. 		return T;
  64. 	else
  65. 		return FindMin(T->left);
  66. }
  67. Position FindMax(AvlTree T)
  68. {
  69. 	if(T != NULL)
  70. 		while(T->right != NULL)
  71. 			T=T->right;
  72. 	return T;
  73. }
  74. /*
  75.  *  返回节点的高度
  76.  */
  77. static int Height(Position P)
  78. {
  79. 	if(P == NULL)
  80. 		return -1;
  81. 	else
  82. 		return P->Height;
  83. }
  84. static int Max(int h1,int h2)
  85. {
  86. 	return h1 > h2 ?h1:h2;
  87. }
  88. /*
  89.  *  此函数用于k2只有一个左孩子的单旋转，
  90.  *  在K2和它的左孩子之间旋转，
  91.  *  更新高度，返回新的根节点
  92.  */
  93. static Position SingleRotateWithLeft(Position k2)     // LL旋转
  94. {
  95. 	Position k1;
  96. 	k1=k2->left;
  97. 	k2->left=k1->right;
  98. 	k1->right=k2;
  99. 	// 因为比较的是左右孩子的高度，所以求父节点的高度要加1
  100. 	k2->Height=Max(Height(k2->left),Height(k2->right)) + 1;
  101. 	k1->Height=Max(Height(k1->left),Height(k2->right)) + 1;
  102. 	return k1;
  103. }
  104. /*
  105.  *  此函数用于k1只有一个右孩子的单旋转，
  106.  *  在K1和它的右孩子之间旋转，
  107.  *  更新高度，返回新的根节点
  108.  */
  109. static Position SingleRotateWithRight(Position k1)  // RR旋转
  110. {
  111. 	Position k2;
  112. 	k2=k1->right;
  113. 	k1->right=k2->left;
  114. 	k2->left=k1;
  115. 	 /*结点的位置变了, 要更新结点的高度值*/
  116. 	k1->Height=Max(Height(k1->left),Height(k1->right)) + 1;
  117. 	k2->Height=Max(Height(k2->left),Height(k2->right)) + 1;
  118. 	return k2;
  119. }
  120. /*
  121.  * 此函数用于当 如果 k3有一个左孩子，以及
  122.  * 它的左孩子又有右孩子，执行这个双旋转
  123.  * 更新高度，返回新的根节点
  124.  */
  125. static Position DoubleRotateLeft(Position k3)    // LR旋转
  126. {
  127. 	//在 k3 的左孩子，执行右侧单旋转
  128. 	k3->left=SingleRotateWithRight(k3->left);
  129. 	// 再对 k3 进行 左侧单旋转
  130. 	return SingleRotateWithLeft(k3);
  131. }
  132. /*
  133.  * 此函数用于当 如果 k4有一个右孩子，以及
  134.  * 它的右孩子又有左孩子，执行这个双旋转
  135.  * 更新高度，返回新的根节点
  136.  */
  137. static Position DoubleRotateRight(Position k4)    // RL旋转
  138. {
  139. 	//在 k4 的右孩子，执行左侧单旋转
  140. 	k4->right = SingleRotateWithLeft(k4->right);
  141. 	// 再对 k4 进行 右侧单旋转
  142. 	return SingleRotateWithRight(k4);
  143. }
  144. /*
  145.  *  向AVL树插入可以通过如同它是未平衡的二叉查找树一样把给定的值插入树中，
  146.  *  接着自底向上向根节点折回，于在插入期间成为不平衡的所有节点上进行旋转来完成。
  147.  *  因为折回到根节点的路途上最多有1.5乘log n个节点，而每次AVL旋转都耗费恒定的时间，
  148.  *  插入处理在整体上耗费O(log n) 时间。
  149.  */
  150. AvlTree  Insert(ElementType x,AvlTree T)
  151. {
  152. 	//如果T不存在，则创建一个节点树
  153. 	if(T == NULL)
  154. 	{
  155. 		T = (AvlTree)malloc(sizeof(struct AvlNode));
  156. 		{
  157. 			T->data = x;
  158. 			T->Height = 0;
  159. 			T->left = T->right = NULL;
  160. 		}
  161. 	}
  162. 	// 如果要插入的元素小于当前元素
  163. 	else if(x < T->data)
  164. 	{
  165. 		//递归插入
  166. 		T->left=Insert(x,T->left);
  167. 		//插入元素之后，若 T 的左子树比右子树高度 之差是 2，即不满足 AVL平衡特性，需要调整
  168. 		if(Height(T->left) - Height(T->right) == 2)
  169. 		{
  170. 			//把x插入到了T->left的左侧，只需 左侧单旋转
  171. 			if(x < T->left->data)
  172. 				T = SingleRotateWithLeft(T);       // LL旋转
  173. 			else
  174. 				// x 插入到了T->left的右侧，需要左侧双旋转
  175. 				T =  DoubleRotateLeft(T);          // LR旋转
  176. 		}
  177. 	}
  178. 	// 如果要插入的元素大于当前元素
  179. 	else if(x > T->data)
  180. 	{
  181. 		T->right=Insert(x,T->right);
  182. 		if(Height(T->right) - Height(T->left) == 2)
  183. 		{
  184. 			if(x > T->right->data)
  185. 				T = SingleRotateWithRight(T);     //RR 旋转
  186. 			else
  187. 				T =  DoubleRotateRight(T);        //RL旋转
  188. 		}
  189. 	}
  190. 	T->Height=Max(Height(T->left),Height(T->right)) + 1;
  191. 	return T;
  192. }
  193. /*
  194.  *  对单个节点进行的AVL调整
  195.  */
  196. AvlTree Rotate(AvlTree T)
  197. {
  199. 	if(Height(T->left) - Height(T->right) == 2)
  200. 	{
  201. 		if(Height(T->left->left) >= Height(T->left->right))
  202. 			T = SingleRotateWithLeft(T);  // LL旋转
  203. 		else
  204. 			T =  DoubleRotateLeft(T);     // LR旋转
  205. 	}
  206. 	if(Height(T->right) - Height(T->left) == 2)
  207. 	{
  208. 		if(Height(T->right->right) >= Height(T->right->left))
  209. 			T = SingleRotateWithRight(T);  // RR旋转
  210. 		else
  211. 			T =  DoubleRotateRight(T);     // RL旋转
  212. 	}
  213. 	return T;
  214. }
  215. /*
  216.  * 首先定位要删除的节点，然后用该节点的右孩子的最左孩子替换该节点，
  217.  * 并重新调整以该节点为根的子树为AVL树，具体调整方法跟插入数据类似
  218.  * 删除处理在整体上耗费O(log n) 时间。
  219.  */
  220. AvlTree  Delete(ElementType x,AvlTree T)
  221. {
  222. 	if(T == NULL)
  223. 		return NULL;
  224. 	if(T->data == x)           // 要删除的 x 等于当前节点元素
  225. 	{
  226. 		if(T->right == NULL )  // 若所要删除的节点 T 的右孩子为空,则直接删除
  227. 		{
  228. 			AvlTree tmp = T;
  229. 			T = T->left;
  230. 			free(tmp);
  231. 		}
  232. 		else                 /* 否则找到 T->right 的最左儿子代替 T */
  233. 		{
  234. 			AvlTree tmp = T->right;
  235. 			while(tmp->left)
  236. 				tmp=tmp->left;
  237. 			T->data = tmp->data;
  238. 			/* 对于替代后的T 即其字节点进行调整*/
  239. 			T->right = Delete(T->data,T->right);
  240. 			T->Height = Max(Height(T->left),Height(T->right))+1;
  241. 		}
  242. 		return T;
  243. 	}
  244. 	else if(x > T->data)                       // 要删除的 x 大于当前节点元素，在T的右子树中查找删除
  245. 	{
  246. 		T->right=Delete(x,T->right);
  247. 	}
  248. 	else                                       // 要删除的 x 小于当前节点元素，在T的左子树中查找删除
  249. 	{
  250. 		T->left=Delete(x,T->left);
  251. 	}
  252. 	/*
  253. 	 *   当删除元素后调整平衡
  254. 	 */
  255. 	T->Height=Max(Height(T->left),Height(T->right)) + 1;
  256. 	if(T->left != NULL)
  257. 		T->left = Rotate(T->left);
  258. 	if(T->right != NULL)
  259. 		T->right = Rotate(T->right);
  260. 	if(T)
  261. 		T=Rotate(T);
  262. 	return T;
  263. }
  264. /*
  265.  * 返回当前位置的元素
  266.  */
  267. ElementType Retrieve(Position P)
  268. {
  269. 	return P->data;
  270. }
  271. /*
  272.  * 遍历输出
  273.  */
  274. void Display(AvlTree T)
  275. {
  276. 	static int n=0;
  277. 	if(NULL != T)
  278. 	{
  279. 		Display(T->left);
  280. 		printf("[%d] ndata=%d \n",++n,T->data);
  281. 		Display(T->right);
  282. 	}
  283. }
  284. #define N 15
  285. int main(void) {
  286.     AvlTree T=NULL;
  287.     int i;
  288.     int j = 0;
  289.     T = MakeEmpty( NULL );
  290.     for( i = 0; i < N; i++, j = ( j + 7 ) % 50 )
  291.     {
  292.     	printf("j=%d \n",j);
  293.         T = Insert( j, T );
  294.     }
  295.     puts("插入 4 \n");
  296.     T = Insert( 4, T );
  297.     Display(T);
  298.    for( i = 0; i < N; i += 2 )
  299.    {
  300. 	   printf("delelte: %d \n",i);
  301.         T = Delete( i, T );//删除元素为i的节点
  302.    }
  303.    printf("detele:\n");
  304.    printf("height=%d \n",T->Height);
  305.    Display(T);
  307.     printf( "Min is %d, Max is %d\n", Retrieve( FindMin( T ) ),
  308.                Retrieve( FindMax( T ) ) );
  309. 	return 0;
  310. }
输出：
j=0
j=7
j=14
j=21
j=28
j=35
j=42
j=49
j=6
j=13
j=20
j=27
j=34
j=41
j=48
插入 4

[1] ndata=0
[2] ndata=4
[3] ndata=6
[4] ndata=7
[5] ndata=13
[6] ndata=14
[7] ndata=20
[8] ndata=21
[9] ndata=27
[10] ndata=28
[11] ndata=34
[12] ndata=35
[13] ndata=41
[14] ndata=42
[15] ndata=48
[16] ndata=49
delelte: 0
delelte: 2
delelte: 4
delelte: 6
delelte: 8
delelte: 10
delelte: 12
delelte: 14
detele:
height=3
[17] ndata=7
[18] ndata=13
[19] ndata=20
[20] ndata=21
[21] ndata=27
[22] ndata=28
[23] ndata=34
[24] ndata=35
[25] ndata=41
[26] ndata=42
[27] ndata=48
[28] ndata=49
Min is 7, Max is 49
kukajenny
关注
Splay（伸展树）模板
01-10
Splay模板包括旋转，主函数Splay，插入，删除，最大值，最小值，查询k大，查询排名
ACM准备模板——堆排序模板
09-27
在ACM准备模板中，"ACM准备模板——堆排序模板.txt"可能包含了堆排序的完整代码示例，包括建堆、调整堆、插入和删除等关键函数的实现。学习并理解这个模板可以帮助参赛者快速地在比赛中实现堆排序，节省编程时间。 ...
AVL树
左手代码 右手诗
12-19 8467
AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树。 查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。        对二叉树的平衡调整过程，主要包含四种旋转操作：LL，LR，RR，RL 。  LR由当前节点左儿子的一次RR旋转和当前节点的一次LL旋转构成。同理，
伸展树模板
SUNSET
09-25 169
伸展树模板 #include &lt;iostream&gt; #include &lt;cstdio&gt; #define pr(x) std::cout &lt;&lt; #x &lt;&lt; " : " &lt;&lt; x &lt;&lt; std::endl class SplayTree{ public: struct Node{ int val;
acm常用模板.rar
03-01
"acm常用模板.rar"这个压缩包很可能包含了参加ACM比赛时常用的C++代码模板，这些模板可以帮助选手快速构建解决方案，提高解题效率。以下是对这些常用模板的详细解释： 1. **排序与查找模板**：ACM竞赛中，排序和...
ACM 程序设计：伸展树-p6.pdf
06-18
在ACM程序设计中，伸展树因其高效动态性能而在竞赛中广泛应用。二叉搜索树（BST）的基础特性是每个节点的左子树包含的所有元素都小于该节点，而右子树包含的所有元素都大于该节点。伸展树在保持这一特性的同时，通过...
ACM 程序设计：伸展树-p1.pdf
06-18
【伸展树（Splay Tree）】是一种自调整的二叉查找树，它通过特定的“伸展”操作来优化查找、插入和删除等操作的性能。伸展树不是一种新的数据结构，而是对普通二叉查找树的一种优化策略，旨在在最坏的情况下也能保持...
上海交大ACM模板_上海交大ACM模板_ACM模板_
09-29
上海交通大学ACM模板是针对计算机科学领域中算法竞赛和考研复试机试的重要参考资料，它集成了许多编程竞赛中常用的数据结构、算法以及解题策略。这个压缩包包含了一个名为"上海交大ACM模板.pdf"的文件，我们可以期待...
avl树
牛逼！
12-30 205
简述 二叉搜索树的最坏情况下搜索的时间复杂度可能达到O(n)，avl树在普通的二叉搜索树的基础上加入了自动平衡的特性，其左子树与右子树的高度差的绝对值不大于2，且左子树与右子树也是一棵avl树 旋转 avl树进行插入或者删除后，通过旋转来满足平衡性质 总共有4种情况需要旋转 LL: 左孩子的左子树进行了插入导致了不平衡，此时需要右旋 RR:右孩子的右子树进行了插入导致了不平衡，此时需要左旋 LR:左孩子的右子树进行了插入，此时需要先左旋再右旋 RL:右孩子的左子树进行了插入，此时需要先右旋再左旋 代码实
ACM算法模板：最小树形图详解
"最小树形图-云计算解码（第2版），ACM常用算法模板" 在给定的信息中，我们关注的是"最小树形图"这个主题，它通常指的是求解最小生成树的问题，这是一种经典的图论算法。在这个问题中，我们给定一个加权无向图，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值