平衡二叉树

或者是一颗空树，或者它的左右子树都是平衡二叉树，且左子树和右子树的深度之差不超过1 。

BF（Balance Factor）

我们将二叉树上节点的左子树深度减去右子树深度的值成为平衡因子。那么平衡二叉树上所有节点的平衡因子只可能是-1,0,1.只要二叉树上有一个节点的平衡引子的绝对值大于1，则该二叉树就是不平衡的。

距离插入节点最近的，且平衡因子的绝对值大于1的节点为根的子树，我们成为最小不平衡子树。最小不平衡子树的树根是我们操作平衡转换的参照点，调整最小不平衡子树，然后就可以达到平衡的效果。

首先要明白，如果需要调整平衡二叉树，那么这颗二叉树肯定是刚刚开始不平衡的，我们只需要调整因为插入新节点导致的最小不平衡子树的结构即可。

树的节点结构，相比于二叉查找树，增加一bf，用来存储平衡因子。

[cpp] view plain copy
  1. /* 二叉树的二叉链表节点结构定义 */
  2. typedef struct BiTNode
  3. {
  4. int data;
  5. int bf;                         /* 相对于二叉查找树，增加了平衡因子bf */
  6. struct BiTNode *lchild, *rchild;
  7. } BiTNode, *BiTree;

两个基本操作，左旋和右旋。

右旋图示：

代码如下：

[cpp] view plain copy
  1. /* 对以p为根的二叉排序树作右旋处理 */
  2. /* 处理之后p指向新的树根节点，即旋转处理之前的左子树的根节点 */
  3. void R_Rotate( BiTree *p )
  4. {
  5. /*
  6. L->rchild (节点2的右孩子) 为NULL          L->rchild != NULL
  7. 例 :    3                                例 ：  9              6
  8. /                                       / \            / \
  9. 2    =>    2                            6  10   =>     5   9
  10. /          / \                          / \            /   / \
  11. 1          1   3                        5   7          4   7  10
  12. /
  13. 4
  14. */
  15. BiTree L;
  16. L = (*p)->lchild;
  17. (*p)->lchild = L->rchild; /* 容易忽视，将*p的左子树的右子树作为*p的左子树（如果 L->rchild 不为空） */
  18. L->rchild = (*p);
  19. *p = L;
  20. }

左旋图示：

代码如下：

[cpp] view plain copy
  1. /* 对以p为根的二叉排序树作左旋处理 */
  2. /* 处理之后 p 指向新的树根节点，即旋转处理之前的右子树的根节点  */
  3. void L_Rotate( BiTree *p)
  4. {
  5. /*
  6. R->lchild (节点2的左孩子) 为NULL          R->lchild != NULL
  7. 例 :   1                                例 ：   9                15
  8. \                                      / \              /  \
  9. 2    =>    2                         6  15     =>     9    17
  10. \        / \                           / \          / \   /
  11. 3      1   3                        10   17       6  10 16
  12. /
  13. 16
  14. */
  15. BiTree R;
  16. R = (*p)->rchild;
  17. (*p)->rchild = R->lchild;     /* 将 P 的右孩子的左孩子转接到 p 的右孩子上，上述的将 10 接至 9 的右孩子上 */
  18. R->lchild = *p;
  19. *p = R;
  20. }

两个复杂调整：

  1. 右子树插入新节点，导致不平衡，但是不能够通过简单的左旋、右旋解决。

    由于插入节点 8 导致出现了最小不平衡子树（树根为 6 ），于是现将以 9 为根的树右旋处理，达到图15效果，然后，在将以 6 为根的树左旋处理，最后二叉树重新平衡，达到图16的效果。

代码如下：

[cpp] view plain copy
  1. /* 右平衡处理 */
  2. /* 对以指针T所指节点为根的二叉树作右平衡旋转处理，与左平衡相对 */
  3. /* 本算法结束时，指针T指向新的根节点 */
  4. /* 参照左平衡处理的图示分析 */
  5. void RightBalance( BiTree *T )
  6. {
  7. BiTree R, Rl;
  8. R = (*T)->rchild;
  9. switch( R->bf )
  10. {
  11. case RH:
  12. (*T)->bf = R->bf = EH;
  13. L_Rotate(T);
  14. break;
  15. case LH:
  16. Rl = R->lchild;
  17. switch( Rl->bf )
  18. {
  19. case LH:
  20. (*T)->bf = EH;
  21. R->bf = RH;
  22. break;
  23. case EH:
  24. (*T)->bf = R->bf = EH;
  25. case RH:
  26. (*T)->bf = LH;
  27. R->bf = EH;
  28. break;
  29. }
  30. Rl->bf = EH;
  31. R_Rotate( &(*T)->rchild );
  32. L_Rotate( T );
  33. }
  34. }

2. 另一种复杂情况是在左子树上插入了新节点，导致不平衡，于是先左旋、再右旋。详见代码。

代码如下：

[cpp] view plain copy
  1. /* 左平衡旋转处理的函数代码 */
  2. /* 对以指针T所指节点为根的二叉树作左平衡旋转处理 */
  3. /* 本算法结束时，指针T指向新的根节点 */
  4. /* 注意：函数被调用，传入一个需要调整平衡性的子树T。由于LeftBalance函数被调用时候 */
  5. /* 其实是已经确认当前子树是不平衡状态，且左子树高度大于右子树高度。 */
  6. /* 换句话说，此时T的根节点应该是平衡因子BF的值大于 1 的数 */
  7. void LeftBalance( BiTree *T )
  8. {
  9. BiTree L, Lr;
  10. L = (*T)->lchild;    /* L指向T的左子树根节点 */
  11. switch( L->bf )
  12. {
  13. /* 检查T的左子树的平衡度，并做相应的平衡处理 */
  14. case LH:    /* 新节点插入在T的左孩子的左子树上，要作单向右旋处理 */
  15. /*
  16. 8(*T)                  5                   8                            5
  17. / \                    / \                 / \                         /  \
  18. (L)5   9                  4   8      or       5   9                       4    8
  19. / \     =>(直接右旋)   /   / \             / \         =>(直接右旋)      \  / \
  20. 4   6                  3   6   9           4   6                           3 6  9
  21. /                                            \
  22. 3(新插入)                                      3(新插入)
  23. */
  24. (*T)->bf = L->bf = EH;
  25. R_Rotate( T );
  26. break;
  27. case RH:    /* 新节点插入在T的左孩子的右子树上，要做双旋处理 */
  28. Lr = L->rchild;
  29. switch( Lr->bf )
  30. {
  31. case LH:
  32. /*
  33. 8                                     8                                     7
  34. / \                                   / \                                  /  \
  35. 5   9                                 7   9                                5    8
  36. / \        =>(先以5为根，单向左旋)    /          =>(以8为根，单向右旋)     / \    \
  37. 4   7                                 5                                    4   6    9
  38. /                                 / \
  39. 6                                 4   6
  40. */
  41. (*T)->bf = RH;
  42. L->bf = EH;
  43. break;
  44. case EH:
  45. (*T)->bf = L->bf = EH;
  46. break;
  47. case RH:
  48. /*
  49. 8                                     8                                     6
  50. / \                                   / \                                   / \
  51. 5   9                                 6   9                                 5   8
  52. / \        =>(先以5为跟，单向左旋)    / \         =>(以8为跟，单向右旋)     /   / \
  53. 4   6                                 5   7                                 4   7   9
  54. \                               /
  55. 7                             4
  56. */
  57. (*T)->bf = EH;
  58. L->bf = LH;
  59. break;
  60. }
  61. Lr->bf = EH;
  62. L_Rotate( &(*T)->lchild );
  63. R_Rotate( T );
  64. }
  65. }

插入：（Insert_AVL）

插入函数结合了上面的做右平衡处理的方法，现在平衡二叉树中查找是否已经存在该元素，如果已经存在，那么不插入，否则，插入新节点，再通过对应的处理，使二叉树保持平衡状态，更新每个结点的平衡因子。

[cpp] view plain copy
  1. /* 若在平衡的二叉排序树T中不存在和e有相同关键字的节点，则插入一个 */
  2. /* 数据元素为e的新节点并返回1，否则返回0 。若因插入而使二叉排序树 */
  3. /* 失去平衡，则作平衡旋转处理，布尔变量taller反应T是否长高 */
  4. int Insert_AVL( BiTree *T, int e, int *taller)
  5. {
  6. if( !(*T) )
  7. {
  8. /* 递归调用Insert_AVL函数，如果进入if语句，说明原二叉排序树中不存在与e相等的结点 */
  9. /* 故而，插入新结点，树“长高”，置taller为TRUE */
  10. *T = ( BiTree )malloc( sizeof(BiTNode) );
  11. ( *T )->data = e;
  12. ( *T )->lchild = ( *T )->rchild = NULL;
  13. ( *T )->bf = EH;
  14. *taller = TRUE;
  15. }
  16. else
  17. {
  18. if( e == (*T)->data )
  19. {
  20. /* 书中已存在与e相等的节点，不需要再次插入 */
  21. *taller = FALSE;
  22. return FALSE;
  23. }
  24. else if( e < (*T)->data )
  25. {
  26. /* 应该继续在T的左子树中进行搜索 */
  27. if( !Insert_AVL( &(*T)->lchild, e, taller) )
  28. /*  说明插入失败，已经存在与e相等的节点，无需再次插入 */
  29. return FALSE;
  30. if(*taller)
  31. {
  32. /* 已经插入到 T 的左子树，且左子树“长高” */
  33. switch( (*T)->bf )
  34. {
  35. case LH:
  36. /* 原本左子树比右子树高，则需要进行平衡处理 */
  37. LeftBalance(T);
  38. *taller = FALSE;
  39. break;
  40. case EH:
  41. /* 原本左右子树等高，现因左子树增高而树增高 */
  42. (*T)->bf = LH;
  43. *taller = TRUE;
  44. break;
  45. case RH:
  46. /* 原本右子树比左子树高，现左右子树等高 */
  47. (*T)->bf = EH;
  48. *taller = FALSE;
  49. break;
  50. }
  51. }
  52. }
  53. else
  54. {
  55. /* 应该继续在T的右子树中进行搜索 */
  56. if( !Insert_AVL( &(*T)->rchild, e, taller) )
  57. /*  说明插入失败，已经存在与e相等的节点，无需再次插入 */
  58. return FALSE;
  59. if(*taller)
  60. {
  61. /* 已经插入到 T 的右子树且右子树“长高” */
  62. switch( (*T)->bf )
  63. {
  64. /* 检查 T 的平衡度 */
  65. case LH:
  66. (*T)->bf = EH;
  67. *taller = FALSE;
  68. break;
  69. case EH:
  70. (*T)->bf = RH;
  71. *taller = TRUE;
  72. break;
  73. case RH:
  74. RightBalance(T);
  75. *taller = FALSE;
  76. break;
  77. }
  78. }
  79. }
  80. }
  81. return TRUE;
  82. }

完整代码：

[cpp] view plain copy
  1. #include<stdio.h>
  2. #define LH +1   /* 左高 */
  3. #define EH 0    /* 等高 */
  4. #define RH -1   /* 右高 */
  5. #define TRUE 1
  6. #define FALSE 0
  7. /* 二叉树的二叉链表节点结构定义 */
  8. typedef struct BiTNode
  9. {
  10. int data;
  11. int bf;                         /* 相对于二叉查找树，增加了平衡因子bf */
  12. struct BiTNode *lchild, *rchild;
  13. } BiTNode, *BiTree;
  14. void order(BiTree t)//中序输出
  15. {
  16. if(t == NULL)
  17. return ;
  18. order(t->lchild);
  19. printf("%d ", t->data);
  20. order(t->rchild);
  21. }
  22. /* 对以p为根的二叉排序树作右旋处理 */
  23. /* 处理之后p指向新的树根节点，即旋转处理之前的左子树的根节点 */
  24. void R_Rotate( BiTree *p )
  25. {
  26. /*
  27. L->rchild (节点2的右孩子) 为NULL          L->rchild != NULL
  28. 例 :    3                                例 ：  9              6
  29. /                   / \            / \
  30. 2    =>    2                            6  10   =>     5   9
  31. /          / \                          / \            /   / \
  32. 1          1   3                        5   7          4   7  10
  33. /
  34. 4
  35. */
  36. BiTree L;
  37. L = (*p)->lchild;
  38. (*p)->lchild = L->rchild; /* 容易忽视，将*p的左子树的右子树作为*p的左子树（如果 L->rchild 不为空） */
  39. L->rchild = (*p);
  40. *p = L;
  41. }
  42. /* 对以p为根的二叉排序树作左旋处理 */
  43. /* 处理之后 p 指向新的树根节点，即旋转处理之前的右子树的根节点  */
  44. void L_Rotate( BiTree *p)
  45. {
  46. /*
  47. R->lchild (节点2的左孩子) 为NULL          R->lchild != NULL
  48. 例 :   1                                例 ：   9                15
  49. \                          / \              /  \
  50. 2    =>    2                         6  15     =>     9    17
  51. \        / \                           / \          / \   /
  52. 3      1   3                        10   17       6  10 16
  53. /
  54. 16
  55. */
  56. BiTree R;
  57. R = (*p)->rchild;
  58. (*p)->rchild = R->lchild;     /* 将 P 的右孩子的左孩子转接到 p 的右孩子上，上述的将 10 接至 9 的右孩子上 */
  59. R->lchild = *p;
  60. *p = R;
  61. }
  62. /* 左平衡旋转处理的函数代码 */
  63. /* 对以指针T所指节点为根的二叉树作左平衡旋转处理 */
  64. /* 本算法结束时，指针T指向新的根节点 */
  65. /* 注意：函数被调用，传入一个需要调整平衡性的子树T。由于LeftBalance函数被调用时候 */
  66. /* 其实是已经确认当前子树是不平衡状态，且左子树高度大于右子树高度。 */
  67. /* 换句话说，此时T的根节点应该是平衡因子BF的值大于 1 的数 */
  68. void LeftBalance( BiTree *T )
  69. {
  70. BiTree L, Lr;
  71. L = (*T)->lchild;    /* L指向T的左子树根节点 */
  72. switch( L->bf )
  73. {
  74. /* 检查T的左子树的平衡度，并做相应的平衡处理 */
  75. case LH:    /* 新节点插入在T的左孩子的左子树上，要作单向右旋处理 */
  76. /*
  77. 8(*T)                  5                   8                            5
  78. / \                    / \                 / \                         /  \
  79. (L)5   9                  4   8      or       5   9                       4    8
  80. / \     =>(直接右旋)   /   / \             / \         =>(直接右旋)      \  / \
  81. 4   6                  3   6   9           4   6                           3 6  9
  82. /                                            \
  83. 3(新插入)                                      3(新插入)
  84. */
  85. (*T)->bf = L->bf = EH;
  86. R_Rotate( T );
  87. break;
  88. case RH:    /* 新节点插入在T的左孩子的右子树上，要做双旋处理 */
  89. Lr = L->rchild;
  90. switch( Lr->bf )
  91. {
  92. case LH:
  93. /*
  94. 8                                     8                                     7
  95. / \                                   / \                                  /  \
  96. 5   9                                 7   9                                5    8
  97. / \        =>(先以5为根，单向左旋)    /          =>(以8为根，单向右旋)     / \    \
  98. 4   7                                 5                                    4   6    9
  99. /                                 / \
  100. 6                                 4   6
  101. */
  102. (*T)->bf = RH;
  103. L->bf = EH;
  104. break;
  105. case EH:
  106. (*T)->bf = L->bf = EH;
  107. break;
  108. case RH:
  109. /*
  110. 8                                     8                                     6
  111. / \                                   / \                                   / \
  112. 5   9                                 6   9                                 5   8
  113. / \        =>(先以5为跟，单向左旋)    / \         =>(以8为跟，单向右旋)     /   / \
  114. 4   6                                 5   7                                 4   7   9
  115. \                               /
  116. 7                             4
  117. */
  118. (*T)->bf = EH;
  119. L->bf = LH;
  120. break;
  121. }
  122. Lr->bf = EH;
  123. L_Rotate( &(*T)->lchild );
  124. R_Rotate( T );
  125. }
  126. }
  127. /* 右平衡处理 */
  128. /* 对以指针T所指节点为根的二叉树作右平衡旋转处理，与左平衡相对 */
  129. /* 本算法结束时，指针T指向新的根节点 */
  130. /* 参照左平衡处理的图示分析 */
  131. void RightBalance( BiTree *T )
  132. {
  133. BiTree R, Rl;
  134. R = (*T)->rchild;
  135. switch( R->bf )
  136. {
  137. case RH:
  138. (*T)->bf = R->bf = EH;
  139. L_Rotate(T);
  140. break;
  141. case LH:
  142. Rl = R->lchild;
  143. switch( Rl->bf )
  144. {
  145. case LH:
  146. (*T)->bf = EH;
  147. R->bf = RH;
  148. break;
  149. case EH:
  150. (*T)->bf = R->bf = EH;
  151. case RH:
  152. (*T)->bf = LH;
  153. R->bf = EH;
  154. break;
  155. }
  156. Rl->bf = EH;
  157. R_Rotate( &(*T)->rchild );
  158. L_Rotate( T );
  159. }
  160. }
  161. /* 若在平衡的二叉排序树T中不存在和e有相同关键字的节点，则插入一个 */
  162. /* 数据元素为e的新节点并返回1，否则返回0 。若因插入而使二叉排序树 */
  163. /* 失去平衡，则作平衡旋转处理，布尔变量taller反应T是否长高 */
  164. int Insert_AVL( BiTree *T, int e, int *taller)
  165. {
  166. if( !(*T) )
  167. {
  168. /* 递归调用Insert_AVL函数，如果进入if语句，说明原二叉排序树中不存在与e相等的结点 */
  169. /* 故而，插入新结点，树“长高”，置taller为TRUE */
  170. *T = ( BiTree )malloc( sizeof(BiTNode) );
  171. ( *T )->data = e;
  172. ( *T )->lchild = ( *T )->rchild = NULL;
  173. ( *T )->bf = EH;
  174. *taller = TRUE;
  175. }
  176. else
  177. {
  178. if( e == (*T)->data )
  179. {
  180. /* 书中已存在与e相等的节点，不需要再次插入 */
  181. *taller = FALSE;
  182. return FALSE;
  183. }
  184. else if( e < (*T)->data )
  185. {
  186. /* 应该继续在T的左子树中进行搜索 */
  187. if( !Insert_AVL( &(*T)->lchild, e, taller) )
  188. /*  说明插入失败，已经存在与e相等的节点，无需再次插入 */
  189. return FALSE;
  190. if(*taller)
  191. {
  192. /* 已经插入到 T 的左子树，且左子树“长高” */
  193. switch( (*T)->bf )
  194. {
  195. case LH:
  196. /* 原本左子树比右子树高，则需要进行平衡处理 */
  197. LeftBalance(T);
  198. *taller = FALSE;
  199. break;
  200. case EH:
  201. /* 原本左右子树等高，现因左子树增高而树增高 */
  202. (*T)->bf = LH;
  203. *taller = TRUE;
  204. break;
  205. case RH:
  206. /* 原本右子树比左子树高，现左右子树等高 */
  207. (*T)->bf = EH;
  208. *taller = FALSE;
  209. break;
  210. }
  211. }
  212. }
  213. else
  214. {
  215. /* 应该继续在T的右子树中进行搜索 */
  216. if( !Insert_AVL( &(*T)->rchild, e, taller) )
  217. /*  说明插入失败，已经存在与e相等的节点，无需再次插入 */
  218. return FALSE;
  219. if(*taller)
  220. {
  221. /* 已经插入到 T 的右子树且右子树“长高” */
  222. switch( (*T)->bf )
  223. {
  224. /* 检查 T 的平衡度 */
  225. case LH:
  226. (*T)->bf = EH;
  227. *taller = FALSE;
  228. break;
  229. case EH:
  230. (*T)->bf = RH;
  231. *taller = TRUE;
  232. break;
  233. case RH:
  234. RightBalance(T);
  235. *taller = FALSE;
  236. break;
  237. }
  238. }
  239. }
  240. }
  241. return TRUE;
  242. }
  243. void main()
  244. {
  245. int i;
  246. int a[] = {3,2,1,4,5,6,7,10,9,8};
  247. BiTree T = NULL;
  248. int taller;
  249. for( i = 0; i < 10; i++)
  250. Insert_AVL(&T, a[i], &taller);
  251. order(T);
  252. printf("\n");
  253. }

总结，待续……

原文：http://blog.csdn.net/wangyunyun00/article/details/23787189

转载于:https://www.cnblogs.com/Ph-one/p/7908752.html

平衡二叉树（AVL树）相关推荐

  1. Python数据结构11：树的实现，树的应用，前中后序遍历，二叉查找树BST，平衡二叉树AVL树，哈夫曼树和哈夫曼编码

    1.概念 树一种基本的"非线性"数据结构. 相关术语: 节点Node:组成树的基本部分.每个节点具有名称,或"键值",节点还可以保存额外数据项,数据项根据不同的 ...

  2. Java数据结构——平衡二叉树(AVL树)

    AVL树的引入 搜索二叉树有着极高的搜索效率,但是搜索二叉树会出现以下极端情况: 这样的二叉树搜索效率甚至比链表还低.在搜索二叉树基础上出现的平衡二叉树(AVL树)就解决了这样的问题.当平衡二叉树(A ...

  3. 平衡二叉树,AVL树之图解篇

    学习过了二叉查找树,想必大家有遇到一个问题.例如,将一个数组{1,2,3,4}依次插入树的时候,形成了图1的情况.有建立树与没建立树对于数据的增删查改已经没有了任何帮助,反而增添了维护的成本.而只有建 ...

  4. 一种基于平衡二叉树(AVL树)插入、查找和删除的简易图书管理系统

    目录 1. 需求分析 2. 项目核心设计 2.1 结点插入 2.2 结点删除 3 测试结果 4 总结分析 4.1 调试过程中的问题是如何解决的,以及对设计与实现的回顾讨论和分析 4.2 算法的时间和空 ...

  5. 平衡二叉树---AVL树的实现

    AVL树是最先发明的自平衡二叉查找算法,是平衡二叉树的一种.在AVL中任何节点的两个儿子子树的高度最大差别为1,所以它又被成为高度平衡树.查找.插入和删除在平均和最坏情况下都是O(log n).增加和 ...

  6. 平衡二叉树(AVL树)和红黑树区别

    1.二叉搜索树,平衡二叉树,红黑树的算法效率 操作 二叉查找树 平衡二叉树 红黑树 查找 O(n) O(logn) O(log2 n) 插入 O(n) O(logn) O(log2 n) 删除 O(n ...

  7. 数据结构-平衡二叉树(AVL树)

    目录 1,平衡二叉树的介绍 1.1,二叉排序树存在的问题 1.2,平衡二叉树 1.3,平衡二叉树的创建 1.4,平衡二叉树的查找 2,代码实现 2.1,平衡二叉树的节点类型 2.2,LL旋转(单右旋转 ...

  8. java数据结构与算法之平衡二叉树(AVL树)的设计与实现中的事实代码

    普通二叉查找树的问题   在开篇,我们提到过,普通二叉树(二叉查找树)在操作的时间复杂度上不一定遵循O(㏒n),也有可能是O(n),这是为什么呢?在上一篇中,我们明明插入都按照一定规则比较的呀,其实那 ...

  9. 数据结构——平衡二叉树(AVL树)之插入

    文章目录 前言 一.定义 二.基本操作 1.查找, 2.插入(如何调整) 如何调整 代码实现插入 前言 首先我们来思考一下一个普通二叉树保存数据,如果想查找一个数据,由于普通二叉树保存数据是随机的,要 ...

  10. 算法小讲堂之平衡二叉树|AVL树（超详细~）

    文章目录 一.前言 二.定义 三.原理 3.1 查找操作 3.2 最小(大)值结点 3.3 旋转操作 3.3.1 LL旋转 3.3.2 RR旋转 3.3.3 LR旋转 3.3.4 RL旋转 3.4 插 ...

最新文章

  1. js如何获得FCKeditor控件的值
  2. nginx openresty content_by_lua_file 404错误
  3. vue14 自定义过滤器
  4. windows和linux-JDK环境变量设置
  5. mock平台架构及实现
  6. Android Github 资源目录
  7. matlab 最小二乘法拟合_计量与论文串讲：最小二乘法
  8. c语言中二维数组的结构体,怎么才能把结构体里面的二维数组打印出来？
  9. ios文件连接服务器无法写入,iOS写入数据到文件中
  10. 打通应用隔阂，AR 如何助力互联网度过寒冬？
  11. Activiti6--入门学习--基础知识环境搭建部署
  12. 数据过多/DOM操作导致页面卡顿和请求突增导致页面崩溃
  13. L2-016 愿天下有情人都是失散多年的兄妹 (25 分) (DFS)
  14. 安全我知道　世界顶尖防火墙逐个看(转)
  15. 从原理到CMOS图像传感器玩家，一文读懂手机摄像头所有猫腻
  16. 电脑怎么用计算机打开指令,快速打开电脑上的计算器
  17. mysql传入Bean_ods数据导入mysql
  18. FANUC系统5136报警维修
  19. 关于“远程计算机或设备不接受连接”解决方法
  20. mysql 菜鸟教程

热门文章

  1. windows优化大师怎么用_win7系统提示未能连接一个windows服务如何解决【详解】
  2. ROSCORE 失败解决方法
  3. 嘉立创常用叠层结构阻抗计算
  4. JS前端AI应用集合重磅开源，PP-OCRv3 JS版模型速度提升87.5%
  5. 使用python的tkinter和turtle库函数制作七夕/情人节送对象的礼物
  6. Vue 图片上传功能
  7. 如何将PDF中的一部分页面另存为新的PDF文件
  8. 验票证明怎么打印_刚买来的针式 打印机怎么测验打印发票
  9. Android使用Intent发送短信SMS
  10. 一个老程序员的发展方向和个人规划