关于AVL树的简单介绍能够參考：数据结构与算法——AVL树简单介绍

关于二叉搜索树（也称为二叉查找树）能够參考：数据结构与算法——二叉查找树类的C++实现

AVL-tree是一个"加上了额外平衡条件"的二叉搜索树，其平衡条件的建立是为了确保整棵树的深度为O(logN)。要求不论什么节点的左右子树高度相差最多1。

该AVL树结点的数据结构:

  1. struct AvlNode{
  2.     Comparable element;
  3.     AvlNode * left;
  4.     AvlNode * right;
  5.     int height;
  6.     AvlNode(const Comparable & e, AvlNode * lt, AvlNode * rt, int h = 0):element(e), left(lt), right(rt), height(h){}
  7. };

该结点数据结构事实上是一个结点类。


该AVL树的主要成员函数：

  1. void makeEmpty();//清空该树
  2. bool isEmpty() const;//推断该树是否为空
  3. void lessOrderPrintTree();//从小到大输出该AVL平衡树
  4. void biggerOrderPrintTree();//从大到小输出该AVL平衡树
  5. void insert(const Comparable & x);//插入值为x的结点
  6. Comparable findMin() const;//找到最小值
  7. Comparable findMax() const;//找到最大值

主要成员函数介绍：

  1. /****************************************************************
  2. *   函数名称：void insert(const Comparable & x, AvlNode * t)
  3. *   功能描写叙述: 在结点t的后面插入值为x的结点
  4. *   參数列表: x为要插入结点的值
  5. *             t为当前的结点
  6. *   返回结果：void
  7. *****************************************************************/
  8. template<typename Comparable>
  9. void AvlTree<Comparable>::insert(const Comparable & x, AvlNode * & t)
  10. {
  11.     if(t == NULL)//当前结点为空
  12.         t = new AvlNode(x, NULL, NULL);
  13.     else if(x < t->element){
  14.         insert(x, t->left);
  15.         if(height(t->left) - height(t->right) == 2){
  16.             if(x < t->left->element)//单旋转。左左插入
  17.                 rotateWithLeftChild(t);
  18.             else
  19.                 doubleWithLeftChild(t);//双旋转。左右插入
  20.         }
  21.     }
  22.     else if(x > t->element){
  23.         insert(x, t->right);
  24.         if(height(t->right) - height(t->left) == 2){
  25.             if(x > t->right->element)//单旋转，右右插入
  26.                 rotateWithRightChild(t);
  27.             else
  28.                 doubleWithRightChild(t);//双旋转，右左插入
  29.         }
  30.     }
  31.     //假设x的值和当前结点的值同样，则忽略。
  32.  
  33. 也能够向之前二叉查找树一样给每一个结点再加一个num成员变量。
  34.  
  35. t->height = max(height(t->left), height(t->right)) + 1;//更新结点t的高度
  36. }
  1. /****************************************************************
  2. *   函数名称：rotateWithLeftChild(AvlNode *t)
  3. *   功能描写叙述: 将当前结点进行单旋转。用于左左插入的时候
  4. *   參数列表: t是指向当前结点的指针
  5. *   返回结果：无
  6. *****************************************************************/
  7. template<typename Comparable>
  8. void AvlTree<Comparable>::rotateWithLeftChild(AvlNode * & k2)
  9. {
  10.     cout << "左单旋转" << endl;
  11.     AvlNode * k1 = k2->left;
  12.     k2->left = k1->right;
  13.     k1->right = k2;
  14.  
  15.     k2->height = max(height(k2->left), height(k2->right)) + 1;
  16.     k1->height = max(height(k1->left), k2->height) + 1;
  17.  
  18.     k2 = k1;
  19. }
  20. /****************************************************************
  21. *   函数名称：rotateWithRightChild(AvlNode *t)
  22. *   功能描写叙述: 将当前结点进行单旋转。用于左右插入的时候
  23. *   參数列表: t是指向当前结点的指针
  24. *   返回结果：无
  25. *****************************************************************/
  26. template<typename Comparable>
  27. void AvlTree<Comparable>::rotateWithRightChild(AvlNode * & k1)
  28. {
  29.     cout << "右单旋转" << endl;
  30.     AvlNode * k2 = k1->right;
  31.     k1->right = k2->left;
  32.     k2->left = k1;
  33.  
  34.     k1->height = max(height(k1->left), height(k1->right)) + 1;
  35.     k2->height = max(height(k2->right), k1->height) + 1;
  36.  
  37.     k1 = k2;
  38. }
  39.  
  40. /****************************************************************
  41. *   函数名称：doubleWithLeftChild(AvlNode *t)
  42. *   功能描写叙述: 将当前结点进行双旋转，用于左右插入的时候
  43. *   參数列表: t是指向当前结点的指针
  44. *   返回结果：无
  45. *****************************************************************/
  46. template<typename Comparable>
  47. void AvlTree<Comparable>::doubleWithLeftChild(AvlNode * & k3)
  48. {
  49.     cout << "**********************" << endl;
  50.     cout << "左双旋转: " << endl;
  51.     rotateWithRightChild(k3->left);
  52.     rotateWithLeftChild(k3);
  53.     cout << "**********************" << endl;
  54. }
  55.  
  56. /****************************************************************
  57. *   函数名称：doubleWithRightChild(AvlNode *t)
  58. *   功能描写叙述: 将当前结点进行双旋转。用于右左插入的时候
  59. *   參数列表: t是指向当前结点的指针
  60. *   返回结果：无
  61. *****************************************************************/
  62. template<typename Comparable>
  63. void AvlTree<Comparable>::doubleWithRightChild(AvlNode * & k1)
  64. {
  65.     cout << "**********************" << endl;
  66.     cout << "右双旋转: " << endl;
  67.     rotateWithLeftChild(k1->right);
  68.     rotateWithRightChild(k1);
  69.     cout << "**********************" << endl;
  70. }

关于右单旋转的一个图例：



结合图形看该旋转函数：

  1. template<typename Comparable>
  2. void AvlTree<Comparable>::rotateWithRightChild(AvlNode * & k1)
  3. {
  4.     cout << "右单旋转" << endl;
  5.     AvlNode * k2 = k1->right;
  6.     k1->right = k2->left;
  7.     k2->left = k1;
  8.  
  9.     k1->height = max(height(k1->left), height(k1->right)) + 1;
  10.     k2->height = max(height(k2->right), k1->height) + 1;
  11.     k1 = k2;
  12. }

左单旋转是相同的道理。


关于右双旋转的一个图例：



结合图形看该旋转函数：

  1. template<typename Comparable>
  2. void AvlTree<Comparable>::doubleWithRightChild(AvlNode * & k1)
  3. {
  4.     cout << "**********************" << endl;
  5.     cout << "右双旋转: " << endl;
  6.     rotateWithLeftChild(k1->right);
  7.     rotateWithRightChild(k1);
  8.     cout << "**********************" << endl;
  9. }

该函数中的凝视是为了測试该函数是否运行了。


以下给出一个完整的实測：

依次向树中插入结点: 1, 2, 3, 4, 5, 6, 7, 16, 15。
先用图示来表现一下详细的实现过程，然后用程序来验证一下。在main函数的tree2树就是用该数据序列生成的AVL树，能够看信息打印是否经过了对应的旋转。



  1.     AvlTree<int> tree2;
  2.  
  3.     cout << "构造AVL树trre2: " << endl;
  4.     for(int i = 1; i < 8; ++i)
  5.         tree2.insert(i);
  6.     tree2.insert(16);
  7.     tree2.insert(15);
  8.  
  9.     tree2.lessOrderPrintTree();
  10.     tree2.biggerOrderPrintTree();

输出为：

构造AVL树trre2: 

右单旋转

右单旋转

右单旋转

右单旋转

**********************

右双旋转: 

左单旋转

右单旋转

**********************

从小到大输出：1 2 3 4 5 6 7 15 16 

从大到小输出：16 15 7 6 5 4 3 2 1


以下是该AVL树类的源码：


  1. /*************************************************************************
  2. 	> File Name: AvlTree.cpp
  3. 	> Author:
  4. 	> Mail:
  5. 	> Created Time: 2016年04月08日 星期五 10时14分48秒
  6.  ************************************************************************/
  7.  
  8. #include <iostream>
  9. #include <algorithm>
  10. #include <vector>
  11. using namespace std;
  12.  
  13. template<typename Comparable>
  14. class AvlTree{
  15.     public:
  16.         AvlTree(){ root = NULL; }
  17.         ~AvlTree();
  18.  
  19.         void makeEmpty();//清空该树
  20.         bool isEmpty() const;//推断该树是否为空
  21.         void lessOrderPrintTree();//从小到大输出该AVL平衡树
  22.         void biggerOrderPrintTree();//从大到小输出该AVL平衡树
  23.         void insert(const Comparable & x);//插入值为x的结点
  24.         Comparable findMin() const;//找到最小值
  25.         Comparable findMax() const;//找到最大值
  26.  
  27.     private:
  28.         struct AvlNode{
  29.             Comparable element;
  30.             AvlNode * left;
  31.             AvlNode * right;
  32.             int height;
  33.             AvlNode(const Comparable & e, AvlNode * lt, AvlNode * rt, int h = 0):element(e), left(lt), right(rt), height(h){}
  34.         };
  35.         AvlNode * root;
  36.  
  37.     private:
  38.         void makeEmpty(AvlNode * t);
  39.         void lessOrderPrintTree(AvlNode * t);
  40.         void biggerOrderPrintTree(AvlNode * t);
  41.         int height(AvlNode * t) const;//获得当前结点t的高度
  42.         void insert(const Comparable & x, AvlNode * & t);//在t处。插入值为x的结点
  43.         void rotateWithLeftChild(AvlNode * & k2);//单旋转，左左插入的情况
  44.         void rotateWithRightChild(AvlNode * & k1);//单旋转，右右插入的情况
  45.         void doubleWithLeftChild(AvlNode * & k3);//双旋转。左右插入的情况
  46.         void doubleWithRightChild(AvlNode * & k1);//双旋转。右左插入的情况
  47.         Comparable findMin(AvlNode * t) const;//找到最小值
  48.         Comparable findMax(AvlNode * t) const;//找到最大值
  49. };
  50.  
  51. /****************************************************************
  52. *   函数名称：findMax()
  53. *   功能描写叙述: 找到该树的最大值
  54. *   參数列表: 无
  55. *   返回结果：无
  56. *****************************************************************/
  57. template<typename Comparable>
  58. Comparable AvlTree<Comparable>::findMax() const
  59. {
  60.     if(!isEmpty())
  61.         return findMax(root);
  62. }
  63.  
  64. /****************************************************************
  65. *   函数名称：findMax(AvlNode * t)
  66. *   功能描写叙述: 找到该树的最大值
  67. *   參数列表: t表示当前结点
  68. *   返回结果：无
  69. *****************************************************************/
  70. template<typename Comparable>
  71. Comparable AvlTree<Comparable>::findMax(AvlNode * t) const
  72. {
  73.     if(t->right== NULL)
  74.         return t->element;
  75.     else
  76.         return findMax(t->right);
  77.  
  78. }
  79.  
  80. /****************************************************************
  81. *   函数名称：findMin()
  82. *   功能描写叙述: 找到该树的最小值
  83. *   參数列表: 无
  84. *   返回结果：无
  85. *****************************************************************/
  86. template<typename Comparable>
  87. Comparable AvlTree<Comparable>::findMin() const
  88. {
  89.     if(!isEmpty())
  90.         return findMin(root);
  91. }
  92.  
  93. /****************************************************************
  94. *   函数名称：findMin(AvlNode * t)
  95. *   功能描写叙述: 找到该树的最小值
  96. *   參数列表: t表示当前结点
  97. *   返回结果：无
  98. *****************************************************************/
  99. template<typename Comparable>
  100. Comparable AvlTree<Comparable>::findMin(AvlNode * t) const
  101. {
  102.     if(t->left == NULL)
  103.         return t->element;
  104.     else
  105.         return findMin(t->left);
  106.  
  107. }
  108. /****************************************************************
  109. *   函数名称：~AvlTree()
  110. *   功能描写叙述: 析构函数，释放结点内存空间
  111. *   參数列表: 无
  112. *   返回结果：无
  113. *****************************************************************/
  114. template<typename Comparable>
  115. AvlTree<Comparable>::~AvlTree()
  116. {
  117.     makeEmpty();
  118. }
  119. /****************************************************************
  120. *   函数名称：void insert(const Comparable & x)
  121. *   功能描写叙述: 插入值为x的结点
  122. *   參数列表: x为要插入结点的值
  123. *   返回结果：void
  124. *****************************************************************/
  125. template<typename Comparable>
  126. void AvlTree<Comparable>::insert(const Comparable & x)
  127. {
  128.     insert(x, root);
  129. }
  130.  
  131. /****************************************************************
  132. *   函数名称：void insert(const Comparable & x, AvlNode * t)
  133. *   功能描写叙述: 在结点t的后面插入值为x的结点
  134. *   參数列表: x为要插入结点的值
  135. *             t为当前的结点
  136. *   返回结果：void
  137. *****************************************************************/
  138. template<typename Comparable>
  139. void AvlTree<Comparable>::insert(const Comparable & x, AvlNode * & t)
  140. {
  141.     if(t == NULL)//当前结点为空
  142.         t = new AvlNode(x, NULL, NULL);
  143.     else if(x < t->element){
  144.         insert(x, t->left);
  145.         if(height(t->left) - height(t->right) == 2){
  146.             if(x < t->left->element)//单旋转。左左插入
  147.                 rotateWithLeftChild(t);
  148.             else
  149.                 doubleWithLeftChild(t);//双旋转，左右插入
  150.         }
  151.     }
  152.     else if(x > t->element){
  153.         insert(x, t->right);
  154.         if(height(t->right) - height(t->left) == 2){
  155.             if(x > t->right->element)//单旋转，右右插入
  156.                 rotateWithRightChild(t);
  157.             else
  158.                 doubleWithRightChild(t);//双旋转，右左插入
  159.         }
  160.     }
  161.     //假设x的值和当前结点的值同样，则忽略。也能够向之前二叉查找树一样给每一个结点再加一个num成员变量。
  162.     t->height = max(height(t->left), height(t->right)) + 1;//更新结点t的高度
  163. }
  164.  
  165. /****************************************************************
  166. *   函数名称：rotateWithLeftChild(AvlNode *t)
  167. *   功能描写叙述: 将当前结点进行单旋转。用于左左插入的时候
  168. *   參数列表: t是指向当前结点的指针
  169. *   返回结果：无
  170. *****************************************************************/
  171. template<typename Comparable>
  172. void AvlTree<Comparable>::rotateWithLeftChild(AvlNode * & k2)
  173. {
  174.     cout << "左单旋转" << endl;
  175.     AvlNode * k1 = k2->left;
  176.     k2->left = k1->right;
  177.     k1->right = k2;
  178.  
  179.     k2->height = max(height(k2->left), height(k2->right)) + 1;
  180.     k1->height = max(height(k1->left), k2->height) + 1;
  181.  
  182.     k2 = k1;
  183. }
  184. /****************************************************************
  185. *   函数名称：rotateWithRightChild(AvlNode *t)
  186. *   功能描写叙述: 将当前结点进行单旋转，用于左右插入的时候
  187. *   參数列表: t是指向当前结点的指针
  188. *   返回结果：无
  189. *****************************************************************/
  190. template<typename Comparable>
  191. void AvlTree<Comparable>::rotateWithRightChild(AvlNode * & k1)
  192. {
  193.     cout << "右单旋转" << endl;
  194.     AvlNode * k2 = k1->right;
  195.     k1->right = k2->left;
  196.     k2->left = k1;
  197.  
  198.     k1->height = max(height(k1->left), height(k1->right)) + 1;
  199.     k2->height = max(height(k2->right), k1->height) + 1;
  200.  
  201.     k1 = k2;
  202. }
  203.  
  204. /****************************************************************
  205. *   函数名称：doubleWithLeftChild(AvlNode *t)
  206. *   功能描写叙述: 将当前结点进行双旋转，用于左右插入的时候
  207. *   參数列表: t是指向当前结点的指针
  208. *   返回结果：无
  209. *****************************************************************/
  210. template<typename Comparable>
  211. void AvlTree<Comparable>::doubleWithLeftChild(AvlNode * & k3)
  212. {
  213.     cout << "**********************" << endl;
  214.     cout << "左双旋转: " << endl;
  215.     rotateWithRightChild(k3->left);
  216.     rotateWithLeftChild(k3);
  217.     cout << "**********************" << endl;
  218. }
  219.  
  220. /****************************************************************
  221. *   函数名称：doubleWithRightChild(AvlNode *t)
  222. *   功能描写叙述: 将当前结点进行双旋转，用于右左插入的时候
  223. *   參数列表: t是指向当前结点的指针
  224. *   返回结果：无
  225. *****************************************************************/
  226. template<typename Comparable>
  227. void AvlTree<Comparable>::doubleWithRightChild(AvlNode * & k1)
  228. {
  229.     cout << "**********************" << endl;
  230.     cout << "右双旋转: " << endl;
  231.     rotateWithLeftChild(k1->right);
  232.     rotateWithRightChild(k1);
  233.     cout << "**********************" << endl;
  234. }
  235.  
  236. /****************************************************************
  237. *   函数名称：int height(AvlNode *t) const
  238. *   功能描写叙述: 获得当前结点t的高度
  239. *   參数列表: t是指向当前结点的指针
  240. *   返回结果：无
  241. *****************************************************************/
  242. template<typename Comparable>
  243. int AvlTree<Comparable>::height(AvlNode * t) const
  244. {
  245.     return (t == NULL) ? -1 : t->height;
  246. }
  247.  
  248. /****************************************************************
  249. *   函数名称：biggerOrderPrintTree()
  250. *   功能描写叙述: 依照从大到小的顺序输出该树结点
  251. *   參数列表: 无
  252. *   返回结果：无
  253. *****************************************************************/
  254. template<typename Comparable>
  255. void AvlTree<Comparable>::biggerOrderPrintTree()
  256. {
  257.     cout << "从大到小输出：";
  258.     biggerOrderPrintTree(root);
  259.     cout << endl;
  260. }
  261. /****************************************************************
  262. *   函数名称：biggerOrderPrintTree(AvlNode * t)
  263. *   功能描写叙述: 依照从大到小的顺序输出该树结点
  264. *   參数列表: 无
  265. *   返回结果：无
  266. *****************************************************************/
  267. template<typename Comparable>
  268. void AvlTree<Comparable>::biggerOrderPrintTree(AvlNode * t)
  269. {
  270.     if(t != NULL){
  271.         biggerOrderPrintTree(t->right);
  272.         cout << t->element << " ";
  273.         biggerOrderPrintTree(t->left);
  274.     }
  275. }
  276.  
  277. /****************************************************************
  278. *   函数名称：lessOrderPrintTree()
  279. *   功能描写叙述: 依照从小到大的顺序输出该树结点
  280. *   參数列表: 无
  281. *   返回结果：无
  282. *****************************************************************/
  283. template<typename Comparable>
  284. void AvlTree<Comparable>::lessOrderPrintTree()
  285. {
  286.     cout << "从小到大输出：";
  287.     lessOrderPrintTree(root);
  288.     cout << endl;
  289. }
  290.  
  291. /****************************************************************
  292. *   函数名称：lessOrderPrintTree()
  293. *   功能描写叙述: 依照从小到大的顺序输出该树结点
  294. *   參数列表: 无
  295. *   返回结果：无
  296. *****************************************************************/
  297. template<typename Comparable>
  298. void AvlTree<Comparable>::lessOrderPrintTree(AvlNode * t)
  299. {
  300.     if(t != NULL){
  301.         lessOrderPrintTree(t->left);
  302.         cout << t->element << " ";
  303.         lessOrderPrintTree(t->right);
  304.     }
  305. }
  306.  
  307. /****************************************************************
  308. *   函数名称：makeEmpty()
  309. *   功能描写叙述: 将该AVL平衡树清空
  310. *   參数列表: 无
  311. *   返回结果：无
  312. *****************************************************************/
  313. template<typename Comparable>
  314. void AvlTree<Comparable>::makeEmpty()
  315. {
  316.    makeEmpty(root);
  317. }
  318.  
  319. /****************************************************************
  320. *   函数名称：makeEmpty(struct AvlNode * t)
  321. *   功能描写叙述: 释放t指针指向的结点
  322. *   參数列表: t 当前结点的指针
  323. *   返回结果：无
  324. *****************************************************************/
  325. template<typename Comparable>
  326. void AvlTree<Comparable>::makeEmpty(AvlNode * t)
  327. {
  328.     if(t != NULL){
  329.         makeEmpty(t->left);
  330.         makeEmpty(t->right);
  331.         delete t;
  332.     }
  333. }
  334.  
  335. /****************************************************************
  336. *   函数名称：isEmpty()
  337. *   功能描写叙述: 推断该树是否为空
  338. *   參数列表: 无
  339. *   返回结果：假设为空则返回true;否则返回false;
  340. *****************************************************************/
  341. template<typename Comparable>
  342. bool AvlTree<Comparable>::isEmpty() const
  343. {
  344.     return (root == NULL) ? true : false;
  345. }
  346.  
  347. //測试主函数
  348. int main()
  349. {
  350.     vector<int> v;
  351.     AvlTree<int> tree;
  352.  
  353.     for(int i = 0; i < 10; i++)
  354.         v.push_back(rand() % 10);
  355.  
  356.     cout << "v: ";
  357.     for(int i = 0; i < 10; ++i)
  358.         cout << v[i] << " ";
  359.     cout << endl;
  360.  
  361.     cout << "构造AVL树trre1: " << endl;
  362.  
  363.     for(int i = 0; i < 10; ++i)
  364.         tree.insert(v[i]);
  365.     tree.insert(13);
  366.     tree.insert(12);
  367.     tree.insert(11);
  368.  
  369.     tree.lessOrderPrintTree();
  370.     tree.biggerOrderPrintTree();
  371.  
  372.     AvlTree<int> tree2;
  373.  
  374.     cout << "构造AVL树trre2: " << endl;
  375.     for(int i = 1; i < 8; ++i)
  376.         tree2.insert(i);
  377.     tree2.insert(16);
  378.     tree2.insert(15);
  379.  
  380.     tree2.lessOrderPrintTree();
  381.     tree2.biggerOrderPrintTree();
  382.  
  383.     int min = tree2.findMin();
  384.     cout << "min = " << min << endl;
  385.     int max = tree2.findMax();
  386.     cout << "max = " << max << endl;
  387.  
  388.     return 0;
  389. }

数据结构与算法——AVL树类的C++实现的更多相关文章

  1. [数据结构与算法] : AVL树

    头文件 typedef int ElementType; #ifndef _AVLTREE_H_ #define _AVLTREE_H_ struct AvlNode; typedef struct ...

  2. 数据结构和算法(Golang实现)(28)查找算法-AVL树

    AVL树 二叉查找树的树高度影响了查找的效率,需要尽量减小树的高度,AVL树正是这样的树. 一.AVL树介绍 AVL树是一棵严格自平衡的二叉查找树,1962年,发明者Adelson-Velsky和La ...

  3. 数据结构(三)实现AVL树

    AVL树的定义 一种自平衡二叉查找树,中面向内存的数据结构. 二叉搜索树T为AVL树的满足条件为: T是空树 T若不是空树,则TL.TR都是AVL树,且|HL-HR| <= 1 (节点的左子树高 ...

  4. 【数据结构】平衡二叉树—AVL树

    (百度百科)在计算机科学中,AVL树是最先发明的自平衡二叉查找树.在AVL树中任何节点的两个子树的高度最大差别为一,所以它也被称为高度平衡树.查找.插入和删除在平均和最坏情况下都是O(log n).增 ...

  5. 数据结构与算法分析-AVL树

    1.AVL树是带有平衡条件的二叉查找树. 2.AVL树的每个节点高度最多相差1. 3.AVL树实现的难点在于插入或删除操作.由于插入和删除都有可能破坏AVL树高度最多相差1的特性,所以当特性被破坏时需 ...

  6. 数据结构——二叉查找树、AVL树

    二叉查找树:由于二叉查找树建树的过程即为插入的过程,所以其中序遍历一定为升序排列! 插入:直接插入,插入后一定为根节点 查找:直接查找 删除:叶子节点直接删除,有一个孩子的节点删除后将孩子节点接入到父 ...

  7. [算法] avl树实现

    大二的时候数据结构课死活没看懂的一个东东,看了2小时,敲了2小时,调了2小时... 平衡树某一节点的左右子树高度相差大于1的时候即需要调整,调整可分为四中情况 ll,rr,lr,rl其中lr,rl是由 ...

  8. 数据结构与算法—Trie树

    Trie,又经常叫前缀树,字典树等等.它有很多变种,如后缀树,Radix Tree/Trie,PATRICIA tree,以及bitwise版本的crit-bit tree.当然很多名字的意义其实有交 ...

  9. Android版数据结构与算法(六):树与二叉树

    版权声明:本文出自汪磊的博客,未经作者允许禁止转载. 之前的篇章主要讲解了数据结构中的线性结构,所谓线性结构就是数据与数据之间是一对一的关系,接下来我们就要进入非线性结构的世界了,主要是树与图,好了接 ...

随机推荐

  1. Python守护进程、进程互斥锁、进程间通信ICP（Queue队列）、生产者消费者模型

    知识点一:守护进程 守护进程:p1.daemon=True 守护进程其实就是一个“子进程“,守护=>伴随 守护进程会伴随主进程的代码运行完毕后而死掉 进程:当父进程需要将一个任务并发出去执行,需 ...

  2. C语言总结(1)

    1scanf( )和printf( )属于系统的函数,分别表示输入和输出. 2.所有C语言的程序只有一个main( )函数,从这里开始运行. 3.程序先执行main( ),调用scanf( ),最后输 ...

  3. 指定特殊的安装目录用configure进行配置

    linux - Make install, but not to default directories? - Stack Overflow I want to run 'make install' ...

  4. 【bzoj2561】最小生成树 网络流最小割

    题目描述 给定一个边带正权的连通无向图G=(V,E),其中N=|V|,M=|E|,N个点从1到N依次编号,给定三个正整数u,v,和L (u≠v),假设现在加入一条边权为L的边(u,v),那么需要删掉最 ...

  5. [BZOJ2678][Usaco2012 Open]Bookshelf

    P.S. 偶然间发现可以用 markdown... [BZOJ2678][Usaco2012 Open]Bookshelf 试题描述 When Farmer John isn't milking co ...

  6. Java--消除重复数字后的最大值

    描述: 一个长整型数字,消除重复的数字后,得到最大的一个数字. 如12341 ,消除重复的1,可得到1234或2341,取最大值2341. 42234,消除4 得到4223 或者 2234 ,再消除2 ...

  7. 【HDOJ5974】A Simple Math Problem（构造，解方程）

    题意:给定A与B,要求构造出一组X,Y,使得X+Y=A,lcm(X,Y)=B A<=2e4,B<=1e9 思路:A的范围较小,考虑以A为突破口 枚举A的约数k,复杂度O(sqrt(A)) ...

  8. Java手机游戏开发简明教程 (SunJava开发者认证程序员 郎锐)

    原文发布时间为:2008-07-30 -- 来源于本人的百度文章 [由搬家工具导入] Java手机游戏开发实例简明教程 (SunJava开发者认证程序员 郎锐)一、手机游戏编写基础1.手机游戏设计的基 ...

  9. 转 Python爬虫入门七之正则表达式

    静觅 » Python爬虫入门七之正则表达式 1.了解正则表达式 正则表达式是对字符串操作的一种逻辑公式,就是用事先定义好的一些特定字符.及这些特定字符的组合,组成一个“规则字符串”,这个“规则字符串 ...

  10. 标准C程序设计七---112

    Linux应用             编程深入            语言编程 标准C程序设计七---经典C11程序设计    以下内容为阅读:    <标准C程序设计>(第7版) 作者 ...