u013149325
u013149325

优先队列三大利器——二项堆、斐波那契堆、Pairing 堆

原文地址：http://dsqiu.iteye.com/blog/1714961

       这篇博文主要介绍二项堆、斐波那契堆、Pairing 堆，都知道只要这三个结构应用实现优先队列的，讲解还是比较详细，参考了很多资料，尤其是Pairing堆很少有讲解，但还是力所能及的写了，虽然可能正确很难保证，其次就是斐波那契堆我对于减小一个关键字的操作的级联剪枝不是很理解（不知道为什么要这么做，难道是为了追求好的时间复杂度）还望高人指点，具体细节在下文会有很多介绍。

 

下面对这三者进行对比

其中(*)Amortized time
(**)With trivial modification to store an additional pointer to the minimum element
(***)Where n is the size of the larger heap
优先队列三大利器——二项堆、斐波那契堆、Pairing 堆_第1张图片优先队列三大利器——二项堆、斐波那契堆、Pairing 堆_第2张图片优先队列三大利器——二项堆、斐波那契堆、Pairing 堆_第3张图片

 

二项堆（Binomial Heap）

二项堆（Binomial Heap）是二项树（Binomial Tree）的集合（collection），所以势必要先简要介绍下二项树。关于堆（最小堆）的相关知识，作者已经在堆排序有介绍可以点击查看，这里就不多枚举了。

二项树（Binomial Tree）

二项树（Binomial Tree）是一组多分支树的序列，二项树的递归定义：

  • 二项树的第0棵树只有一个结点；
  • 二项树的第K棵树的子结点由二项树的前面k-1棵组成的。

从以上定义，不难得到下面的结论：

 

  • 二项树的第K棵树有 2k个结点，高度是k；
  • 深度为 d 的结点共有个结点（从上图就可以看出结点是按二项分布的(1,3,3,1)）

二项堆由一组二项树所构成，这里的二项树需要满足下列条件：

1）H中的每个二项树遵循最小堆的性质。

2）对于任意非负整数k，在H中至多有一棵二项树的根具有度数k。

 

对于性质2，任意高度最多有一棵二项树，这样就可以用二项树的集合唯一地表示任意大小的二项堆，比如13个结点的二项堆H，13的二进制表示为（1101），故H包含了最小堆有序二项树B3， B2和B0， 他们分别有8， 4， 2， 1个结点，即共有13个结点。如下图（另外：二项堆中各二项树的根被组织成一个链表，称之为根表）

二项树的ADT

 

C代码   收藏代码
  1. typedef struct BinHeapNode BinNode;  
  2. typedef struct BinHeapNode * BinHeap;  
  3. typedef struct BinHeapNode * Position;  
  4.    
  5. //结点ADT  
  6. struct BinHeapNode {  
  7.     int key;  
  8.     int degree;  
  9.     Position parent;  
  10.     Position leftChild;  
  11.     Position sibling;  
  12. };  

 

二项dui的操作

1）创建二项堆 

 

C代码   收藏代码
  1. BinHeap MakeBinHeap() {  
  2.     BinHeap heap = NULL;  
  3.     heap = (BinHeap) malloc(sizeof(BinNode));  
  4.     if (heap == NULL) {  
  5.         puts("Out of the Space");  
  6.         exit(1);  
  7.     }  
  8.     memset(newHeap, 0, sizeof(BinNode));  
  9.     return heap;  
  10. }  

 

2）寻找最小关键字

由于每一个二项树都满足最小堆的性质，所以每个二项树的最小关键字一定在根结点，故只需遍历比较根表的情况就可以。

C代码   收藏代码
  1. //返回最小根节点的指针  
  2. BinHeap BinHeapMin(BinHeap heap) {  
  3.     Position y = NULL, x = heap;  
  4.     int min = INT_MAX;  
  5.    
  6.     while (x != NULL) {  
  7.         if (x->key < min) {  
  8.             min = x->key;  
  9.             y = x;  
  10.         }  
  11.         x = x->sibling;  
  12.     }  
  13.     return y;  
  14. }  

3）合并两个二项堆

合并两个二项堆有三个函数：

 

BINOMIAL-LINK，连接操作，即将两棵根节点度数相同的二项树Bk-1连接成一棵Bk。伪代码：

BINOMIAL-HEAP-MERGE ，将H1和H2的根表合并成一个按度数的单调递增次序排列的链表。

BINOMIAL-HEAP-UNION，反复连接根节点的度数相同的各二项树。伪代码：

合并操作分为两个阶段：

第一阶段：执行BINOMIAL-HEAP-MERGE，将两个堆H1和H2的根表合并成一个链表H，它按度数排序成单调递增次序。MERGE的时间复杂度O(logn)。n为H1和H2的结点总数。（对于每一个度数值，可能有两个根与其对应，所以第二阶段要把这些相同的根连起来）。

第二阶段：将相等度数的根连接起来，直到每个度数至多有一个根时为止。执行过程中，合并的堆H的根表中至多出现三个根具有相同的度数。（MERGE后H中至多出现两个根具有相同的度数，但是将两个相同度数的根的二项树连接后，可能与后面的至多两棵二项树出现相同的度数的根，因此至多出现三个根具有相同的度数）

 

第二阶段根据当前遍历到的根表中的结点x，分四种情况考虑:

Case1：degree[x] != degree[sibling[x]]。此时，不需要做任何变化，将指针向根表后移动即可。(下图示a)

Case2：degree[x] == degree[sibling[x]] == degree[sibling[sibling[x]]]。此时，仍不做变化，将指针后移。(下图示b)

Case3 & Case4：degree[x] = degree[sibling[x]] != degree[sibling[sibling[x]]] (下图示c和d)

Case3：key[x] <= key[sibling[x]]。此时，将sibling[x]连接到x上。

Case4：key[x] > key[sibling[x]]。此时，将x连接到sibling[x]上。

复杂度：O(logn)， 四个过程变化情况：

 

 

C代码   收藏代码
  1. //两个堆合并  
  2. BinHeap BinHeapUnion(BinHeap &H1, BinHeap &H2) {  
  3.     Position heap = NULL, pre_x = NULL, x = NULL, next_x = NULL;  
  4.     heap = BinHeapMerge(H1, H2);  
  5.     if (heap == NULL) {  
  6.         return heap;  
  7.     }  
  8.    
  9.     pre_x = NULL;  
  10.     x = heap;  
  11.     next_x = x->sibling;  
  12.    
  13.     while (next_x != NULL) {  
  14.         if ((x->degree != next_x->degree) ||//Cases 1 and 2  
  15.             ((next_x->sibling != NULL) && (next_x->degree == next_x->sibling->degree))) {  
  16.                 pre_x = x;  
  17.                 x = next_x;  
  18.         } else if (x->key <= next_x->key) {//Cases 3  
  19.             x->sibling = next_x->sibling;  
  20.             BinLink(next_x, x);  
  21.         } else {//Cases 4  
  22.             if (pre_x == NULL) {  
  23.                 heap = next_x;  
  24.             } else {  
  25.                 pre_x->sibling = next_x;  
  26.             }  
  27.             BinLink(x, next_x);  
  28.             x = next_x;  
  29.         }  
  30.         next_x = x->sibling;  
  31.     }  
  32.     return heap;  
  33. }  
  34.    
  35. //将H1, H2的根表合并成一个按度数的单调递增次序排列的链表  
  36. BinHeap BinHeapMerge(BinHeap &H1, BinHeap &H2) {  
  37.     //heap->堆的首地址，H3为指向新堆根结点  
  38.     BinHeap heap = NULL, firstHeap = NULL, secondHeap = NULL,  
  39.         pre_H3 = NULL, H3 = NULL;  
  40.    
  41.     if (H1 != NULL && H2 != NULL){  
  42.         firstHeap = H1;  
  43.         secondHeap = H2;  
  44.         //整个while，firstHeap, secondHeap, pre_H3, H3都在往后顺移  
  45.         while (firstHeap != NULL && secondHeap != NULL) {  
  46.             if (firstHeap->degree <= secondHeap->degree) {  
  47.                 H3 = firstHeap;  
  48.                 firstHeap = firstHeap->sibling;  
  49.             } else {  
  50.                 H3 = secondHeap;  
  51.                 secondHeap = secondHeap->sibling;  
  52.             }  
  53.    
  54.             if (pre_H3 == NULL) {  
  55.                 pre_H3 = H3;  
  56.                 heap = H3;  
  57.             } else {  
  58.                 pre_H3->sibling = H3;  
  59.                 pre_H3 = H3;  
  60.             }  
  61.             if (firstHeap != NULL) {  
  62.                 H3->sibling = firstHeap;  
  63.             } else {  
  64.                 H3->sibling = secondHeap;  
  65.             }  
  66.         }//while  
  67.     } else if (H1 != NULL) {  
  68.         heap = H1;  
  69.     } else {  
  70.         heap = H2;  
  71.     }  
  72.     H1 = H2 = NULL;  
  73.     return heap;  
  74. }  
  75.    
  76. //使H2成为H1的父节点  
  77. void BinLink(BinHeap &H1, BinHeap &H2) {  
  78.     H1->parent = H2;  
  79.     H1->sibling = H2->leftChild;  
  80.     H2->leftChild = H1;  
  81.     H2->degree++;  
  82. }  

4）插入一个结点

先创建只有该结点的二项堆，然后在与原来的二项堆合并。

C代码   收藏代码
  1. //用数组内的值建堆  
  2. BinHeap MakeBinHeapWithArray(int keys[], int n) {  
  3.     BinHeap heap = NULL, newHeap = NULL;  
  4.     for (int i = 0; i < n; i++) {  
  5.         newHeap = (BinHeap) malloc(sizeof(BinNode));  
  6.         if (newHeap == NULL) {  
  7.             puts("Out of the Space");  
  8.             exit(1);  
  9.         }  
  10.         memset(newHeap, 0, sizeof(BinNode));  
  11.         newHeap->key = keys[i];  
  12.         if (NULL == heap) {  
  13.             heap = newHeap;  
  14.         } else {  
  15.             heap = BinHeapUnion(heap, newHeap);  
  16.             newHeap = NULL;  
  17.         }  
  18.     }  
  19.     return heap;  
  20. }  

5）删除最小关键字的结点

从根表中找到最小关键字的结点，将以该结点为根的整棵二项树从堆取出，删除取出的二项树的根，将其剩下的子女倒序排列，组成了一个新的二项堆，再与之前的二项堆合并。  

 

Cpp代码   收藏代码
  1. //抽取有最小关键字的结点  
  2. BinHeap BinHeapExtractMin(BinHeap &heap) {  
  3.     BinHeap pre_y = NULL, y = NULL, x = heap;  
  4.     int min = INT_MAX;  
  5.     while (x != NULL) {  
  6.         if (x->key < min) {  
  7.             min = x->key;  
  8.             pre_y = y;  
  9.             y = x;  
  10.         }  
  11.         x = x->sibling;  
  12.     }  
  13.    
  14.     if (y == NULL) {  
  15.         return NULL;  
  16.     }  
  17.    
  18.     if (pre_y == NULL) {  
  19.         heap = heap->sibling;  
  20.     } else {  
  21.         pre_y->sibling = y->sibling;  
  22.     }  
  23.    
  24.     //将y的子结点指针reverse  
  25.     BinHeap H2 = NULL, p = NULL;  
  26.     x = y->leftChild;  
  27.     while (x != NULL) {  
  28.         p = x;  
  29.         x = x->sibling;  
  30.         p->sibling = H2;  
  31.         H2 = p;  
  32.         p->parent = NULL;  
  33.     }  
  34.    
  35.     heap = BinHeapUnion(heap, H2);  
  36.     return y;  
  37. }  

 

 6）减小关键字的值

减小关键字的值其实就是更新关键字的值，实现过程就是维护最小堆的过程。

 

C代码   收藏代码
  1. //减少关键字的值  
  2. void BinHeapDecreaseKey(BinHeap heap, BinHeap x, int key) {  
  3.     if(key > x->key) {  
  4.         puts("new key is greaer than current key");  
  5.         exit(1); //不为降键  
  6.     }  
  7.     x->key = key;  
  8.    
  9.     BinHeap z = NULL, y = NULL;  
  10.     y = x;  
  11.     z = x->parent;  
  12.     while(z != NULL && z->key > y->key) {  
  13.         swap(z->key, y->key);  
  14.         y = z;  
  15.         z = y->parent;  
  16.     }  
  17. }  

 

7）删除一个关键字

删除一个关键字转换为前面的过程——将该关键字修改为最小值（要维护最小堆的性质），然后变成删除最小关键字的过程。 

 

C代码   收藏代码
  1. //删除一个关键字  
  2. BinHeap BinHeapDelete(BinHeap &heap, int key) {  
  3.     BinHeap x = NULL;  
  4.     x = BinHeapFind(heap, key);  
  5.     if (x != NULL) {  
  6.         BinHeapDecreaseKey(heap, x, INT_MIN);  
  7.         return BinHeapExtractMin(heap);  
  8.     }  
  9.     return x;  
  10. }  
  11.    
  12. //找出一个关键字  
  13. BinHeap BinHeapFind(BinHeap &heap, int key) {  
  14.     Position p = NULL, x = NULL;  
  15.     p = heap;  
  16.     while (p != NULL) {  
  17.         if (p->key == key) {  
  18.             return p;  
  19.         } else {  
  20.             if((x =BinHeapFind(p->leftChild, key)) != NULL) {  
  21.                 return x;  
  22.             }  
  23.             p = p->sibling;  
  24.         }  
  25.     }  
  26.     return NULL;  
  27. }  
 

 

二项树的完整实现

 

C代码   收藏代码
  1. #include<iostream>  
  2. #include<cstdio>  
  3. #include<cstring>  
  4. #include<cstdlib>  
  5. #include<climits>  
  6. using namespace std;  
  7.    
  8. typedef struct BinHeapNode BinNode;  
  9. typedef struct BinHeapNode * BinHeap;  
  10. typedef struct BinHeapNode * Position;  
  11.    
  12. //结点ADT  
  13. struct BinHeapNode {  
  14.     int key;  
  15.     int degree;  
  16.     Position parent;  
  17.     Position leftChild;  
  18.     Position sibling;  
  19. };  
  20.    
  21. //用数组内的值建堆  
  22. BinHeap MakeBinHeapWithArray(int keys[], int n);  
  23.    
  24. //两个堆合并  
  25. BinHeap BinHeapUnion(BinHeap &H1, BinHeap &H2);  
  26.    
  27. //将H1, H2的根表合并成一个按度数的单调递增次序排列的链表  
  28. BinHeap BinHeapMerge(BinHeap &H1, BinHeap &H2);  
  29.    
  30. //使H2成为H1的父节点  
  31. void BinLink(BinHeap &H1, BinHeap &H2);  
  32.    
  33. //返回最小根节点的指针  
  34. BinHeap BinHeapMin(BinHeap heap);  
  35.    
  36. //减少关键字的值  
  37. void BinHeapDecreaseKey(BinHeap heap, BinHeap x, int key);  
  38.    
  39. //删除一个关键字  
  40. BinHeap BinHeapDelete(BinHeap &heap, int key);  
  41.    
  42. //找出一个关键字  
  43. BinHeap BinHeapFind(BinHeap &heap, int key);  
  44.    
  45. //打印输出堆结构  
  46. void PrintBinHeap(BinHeap heap);  
  47.    
  48. //销毁堆  
  49. void DestroyBinHeap(BinHeap &heap);  
  50.    
  51. //用数组内的值建堆  
  52. BinHeap MakeBinHeapWithArray(int keys[], int n) {  
  53.     BinHeap heap = NULL, newHeap = NULL;  
  54.     for (int i = 0; i < n; i++) {  
  55.         newHeap = (BinHeap) malloc(sizeof(BinNode));  
  56.         if (newHeap == NULL) {  
  57.             puts("Out of the Space");  
  58.             exit(1);  
  59.         }  
  60.         memset(newHeap, 0, sizeof(BinNode));  
  61.         newHeap->key = keys[i];  
  62.         if (NULL == heap) {  
  63.             heap = newHeap;  
  64.         } else {  
  65.             heap = BinHeapUnion(heap, newHeap);  
  66.             newHeap = NULL;  
  67.         }  
  68.     }  
  69.     return heap;  
  70. }  
  71.    
  72. //两个堆合并  
  73. BinHeap BinHeapUnion(BinHeap &H1, BinHeap &H2) {  
  74.     Position heap = NULL, pre_x = NULL, x = NULL, next_x = NULL;  
  75.     heap = BinHeapMerge(H1, H2);  
  76.     if (heap == NULL) {  
  77.         return heap;  
  78.     }  
  79.    
  80.     pre_x = NULL;  
  81.     x = heap;  
  82.     next_x = x->sibling;  
  83.    
  84.     while (next_x != NULL) {  
  85.         if ((x->degree != next_x->degree) ||//Cases 1 and 2  
  86.             ((next_x->sibling != NULL) && (next_x->degree == next_x->sibling->degree))) {  
  87.                 pre_x = x;  
  88.                 x = next_x;  
  89.         } else if (x->key <= next_x->key) {//Cases 3  
  90.             x->sibling = next_x->sibling;  
  91.             BinLink(next_x, x);  
  92.         } else {//Cases 4  
  93.             if (pre_x == NULL) {  
  94.                 heap = next_x;  
  95.             } else {  
  96.                 pre_x->sibling = next_x;  
  97.             }  
  98.             BinLink(x, next_x);  
  99.             x = next_x;  
  100.         }  
  101.         next_x = x->sibling;  
  102.     }  
  103.     return heap;  
  104. }  
  105.    
  106. //将H1, H2的根表合并成一个按度数的单调递增次序排列的链表  
  107. BinHeap BinHeapMerge(BinHeap &H1, BinHeap &H2) {  
  108.     //heap->堆的首地址，H3为指向新堆根结点  
  109.     BinHeap heap = NULL, firstHeap = NULL, secondHeap = NULL,  
  110.         pre_H3 = NULL, H3 = NULL;  
  111.    
  112.     if (H1 != NULL && H2 != NULL){  
  113.         firstHeap = H1;  
  114.         secondHeap = H2;  
  115.         //整个while，firstHeap, secondHeap, pre_H3, H3都在往后顺移  
  116.         while (firstHeap != NULL && secondHeap != NULL) {  
  117.             if (firstHeap->degree <= secondHeap->degree) {  
  118.                 H3 = firstHeap;  
  119.                 firstHeap = firstHeap->sibling;  
  120.             } else {  
  121.                 H3 = secondHeap;  
  122.                 secondHeap = secondHeap->sibling;  
  123.             }  
  124.    
  125.             if (pre_H3 == NULL) {  
  126.                 pre_H3 = H3;  
  127.                 heap = H3;  
  128.             } else {  
  129.                 pre_H3->sibling = H3;  
  130.                 pre_H3 = H3;  
  131.             }  
  132.             if (firstHeap != NULL) {  
  133.                 H3->sibling = firstHeap;  
  134.             } else {  
  135.                 H3->sibling = secondHeap;  
  136.             }  
  137.         }//while  
  138.     } else if (H1 != NULL) {  
  139.         heap = H1;  
  140.     } else {  
  141.         heap = H2;  
  142.     }  
  143.     H1 = H2 = NULL;  
  144.     return heap;  
  145. }  
  146.    
  147. //使H2成为H1的父节点  
  148. void BinLink(BinHeap &H1, BinHeap &H2) {  
  149.     H1->parent = H2;  
  150.     H1->sibling = H2->leftChild;  
  151.     H2->leftChild = H1;  
  152.     H2->degree++;  
  153. }  
  154.    
  155. //返回最小根节点的指针  
  156. BinHeap BinHeapMin(BinHeap heap) {  
  157.     Position y = NULL, x = heap;  
  158.     int min = INT_MAX;  
  159.    
  160.     while (x != NULL) {  
  161.         if (x->key < min) {  
  162.             min = x->key;  
  163.             y = x;  
  164.         }  
  165.         x = x->sibling;  
  166.     }  
  167.     return y;  
  168. }  
  169.    
  170. //抽取有最小关键字的结点  
  171. BinHeap BinHeapExtractMin(BinHeap &heap) {  
  172.     BinHeap pre_y = NULL, y = NULL, x = heap;  
  173.     int min = INT_MAX;  
  174.     while (x != NULL) {  
  175.         if (x->key < min) {  
  176.             min = x->key;  
  177.             pre_y = y;  
  178.             y = x;  
  179.         }  
  180.         x = x->sibling;  
  181.     }  
  182.    
  183.     if (y == NULL) {  
  184.         return NULL;  
  185.     }  
  186.    
  187.     if (pre_y == NULL) {  
  188.         heap = heap->sibling;  
  189.     } else {  
  190.         pre_y->sibling = y->sibling;  
  191.     }  
  192.    
  193.     //将y的子结点指针reverse  
  194.     BinHeap H2 = NULL, p = NULL;  
  195.     x = y->leftChild;  
  196.     while (x != NULL) {  
  197.         p = x;  
  198.         x = x->sibling;  
  199.         p->sibling = H2;  
  200.         H2 = p;  
  201.         p->parent = NULL;  
  202.     }  
  203.    
  204.     heap = BinHeapUnion(heap, H2);  
  205.     return y;  
  206. }  
  207.    
  208. //减少关键字的值  
  209. void BinHeapDecreaseKey(BinHeap heap, BinHeap x, int key) {  
  210.     if(key > x->key) {  
  211.         puts("new key is greaer than current key");  
  212.         exit(1); //不为降键  
  213.     }  
  214.     x->key = key;  
  215.    
  216.     BinHeap z = NULL, y = NULL;  
  217.     y = x;  
  218.     z = x->parent;  
  219.     while(z != NULL && z->key > y->key) {  
  220.         swap(z->key, y->key);  
  221.         y = z;  
  222.         z = y->parent;  
  223.     }  
  224. }  
  225.    
  226. //删除一个关键字  
  227. BinHeap BinHeapDelete(BinHeap &heap, int key) {  
  228.     BinHeap x = NULL;  
  229.     x = BinHeapFind(heap, key);  
  230.     if (x != NULL) {  
  231.         BinHeapDecreaseKey(heap, x, INT_MIN);  
  232.         return BinHeapExtractMin(heap);  
  233.     }  
  234.     return x;  
  235. }  
  236.    
  237. //找出一个关键字  
  238. BinHeap BinHeapFind(BinHeap &heap, int key) {  
  239.     Position p = NULL, x = NULL;  
  240.     p = heap;  
  241.     while (p != NULL) {  
  242.         if (p->key == key) {  
  243.             return p;  
  244.         } else {  
  245.             if((x =BinHeapFind(p->leftChild, key)) != NULL) {  
  246.                 return x;  
  247.             }  
  248.             p = p->sibling;  
  249.         }  
  250.     }  
  251.     return NULL;  
  252. }  
  253.    
  254. //打印输出堆结构  
  255. void PrintBinHeap(BinHeap heap) {  
  256.     if (NULL == heap) {  
  257.         return ;  
  258.     }  
  259.     Position p = heap;  
  260.    
  261.     while (p != NULL) {  
  262.         printf(" (");  
  263.         printf("%d", p->key);  
  264.         //显示其孩子  
  265.         if(NULL != p->leftChild) {  
  266.             PrintBinHeap(p->leftChild);  
  267.         }  
  268.         printf(") ");  
  269.    
  270.         p = p->sibling;  
  271.     }  
  272. }         
  273.    
  274. int kp1[8] = {12,  
  275.                7, 25,  
  276.               15, 28, 33, 41};  
  277.    
  278. int kp2[20] = {18,  
  279.                 3, 37,  
  280.                 6, 8, 29, 10, 44, 30, 23, 2, 48, 31, 17, 45, 32, 24, 50, 55};  
  281.    
  282. int kp4[23] = {37, 41,  
  283.                10, 28, 13, 77,  
  284.                1, 6, 16, 12, 25, 8, 14, 29, 26, 23, 18, 11, 17, 38, 42, 27};  
  285. int main() {  
  286.     BinHeap H1 = NULL;  
  287.     H1 = MakeBinHeapWithArray(kp1, 7);  
  288.     puts("第一个二叉堆H1:");  
  289.     PrintBinHeap(H1);  
  290.    
  291.     BinHeap H2 = NULL;  
  292.     H2 = MakeBinHeapWithArray(kp2, 19);  
  293.     puts("\n\n第二个二叉堆H2:");  
  294.     PrintBinHeap(H2);  
  295.    
  296.     BinHeap H3 = NULL;  
  297.     H3 = BinHeapUnion(H1, H2);  
  298.     puts("\n\n合并H1,H2后，得到H3:");  
  299.     PrintBinHeap(H3);  
  300.    
  301.     BinHeap H4 = NULL;  
  302.     H4 = MakeBinHeapWithArray(kp4, 22);  
  303.     puts("\n\n用于测试提取和删除的二叉堆H4:");  
  304.     PrintBinHeap(H4);  
  305.    
  306.     BinHeap extractNode = BinHeapExtractMin(H4);  
  307.     if (extractNode != NULL) {  
  308.         printf("\n\n抽取最小的值%d后：\n", extractNode->key);  
  309.         PrintBinHeap(H4);  
  310.     }  
  311.    
  312.     extractNode = BinHeapExtractMin(H4);  
  313.     if (extractNode != NULL) {  
  314.         printf("\n\n抽取最小的值%d后：\n", extractNode->key);  
  315.         PrintBinHeap(H4);  
  316.     }  
  317.    
  318.     extractNode = BinHeapExtractMin(H4);  
  319.     if (extractNode != NULL) {  
  320.         printf("\n\n抽取最小的值%d后：\n", extractNode->key);  
  321.         PrintBinHeap(H4);  
  322.     }  
  323.    
  324.     BinHeapDelete(H4, 12);  
  325.     puts("\n\n删除12后：");  
  326.     PrintBinHeap(H4);  
  327.     return 0;  
  328. }  

 

另外的实现参考参考②。

上述的操作的时间复杂度都是O(lgn)。 

 

斐波那契堆（Fibonacci Heap）

斐波那契堆是一种松散的二项堆，与二项堆的主要区别在于构成斐波那契堆得树可以不是二项树，并且这些树的根排列是无须的（二项堆的根结点排序是按照结点个数排序的，不是按照根结点的大小）。斐波那契堆得优势在于它对建堆、插入、抽取最小关键字、联合等操作能在O(1)的时间内完成（不涉及删除元素的操作仅需要O（1））。这是对二项堆效率的巨大改善。但由于斐波那契堆得常数因子以及程序设计上的复杂度，使它不如通常的二叉堆合适。因此，它的价值仅存在于理论意义上。斐波那契堆的另一个特点就是合并操作只发生在抽取一个结点之后，也就是说斐波那契堆的维护总是会延后的（个人根据代码理解的）。

斐波那契堆结点ADT

结点含有以下域：

1） 父节点p[x]

2） 指向任一子女的指针child[x]——结点x的子女被链接成一个环形双链表，称为x的子女表

3） 左兄弟left[x]

4） 右兄弟right[x]——当left[x] = right[x] = x时，说明x是独子。

5） 子女的个数degree[x]

6） 布尔值域mark[x]——标记是否失去了一个孩子

 

C代码   收藏代码
  1. //斐波那契结点ADT  
  2. struct FibonacciHeapNode {  
  3.     int key;       //结点  
  4.     int degree;    //度  
  5.     FibonacciHeapNode * left;  //左兄弟  
  6.     FibonacciHeapNode * right; //右兄弟  
  7.     FibonacciHeapNode * parent; //父结点  
  8.     FibonacciHeapNode * child;  //第一个孩子结点  
  9.     bool marked;           //是否被删除第1个孩子  
  10. };  
  11. typedef FibonacciHeapNode FibNode;  

 

斐波那契堆ADT

对于一个给定的斐波那契堆H，可以通过指向包含最小关键字的树根的指针min[H]来访问，这个结点被称为斐波那契堆中的最小结点。如果一个斐波那契堆H是空的，则min[H] = NIL. 在一个斐波那契堆中，所有树的根都通过left和right指针链接成一个环形的双链表，称为堆的根表。于是，指针min[H]就指向根表中具有最小关键字的结点（就是查找最小结点的操作，下文就没有再介绍了）。

C代码   收藏代码
  1. //斐波那契堆ADT  
  2. struct FibonacciHeap {  
  3.     int keyNum;   //堆中结点个数  
  4.     FibonacciHeapNode * min;//最小堆，根结点  
  5.     int maxNumOfDegree;   //最大度  
  6.     FibonacciHeapNode * * cons;//指向最大度的内存区域  
  7. };  
  8.    
  9. typedef FibonacciHeap FibHeap;  

斐波那契堆操作

1.创建斐波那契堆

创建一个空的斐波那契堆，过程MAKE-FIB-HEAP 分配并返回一个斐波那契堆对象H； 

 

C代码   收藏代码
  1. //初始化一个空的Fibonacci Heap  
  2. FibHeap * FibHeapMake() {  
  3.     FibHeap * heap = NULL;  
  4.     heap = (FibHeap *) malloc(sizeof(FibHeap));  
  5.     if (NULL == heap) {  
  6.         puts("Out of Space!!");  
  7.         exit(1);  
  8.     }  
  9.     memset(heap, 0, sizeof(FibHeap));  
  10.     return heap;  
  11. }  
  12.    
  13. //初始化结点x  
  14. FibNode * FibHeapNodeMake() {  
  15.     FibNode * x = NULL;  
  16.     x = (FibNode *) malloc(sizeof(FibNode));  
  17.     if (NULL == x) {  
  18.         puts("Out of Space!!");  
  19.         exit(1);  
  20.     }  
  21.     memset(x, 0, sizeof(FibNode));  
  22.     x->left = x->right = x;  
  23.     return x;  
  24. }  

 

2.插入一个结点

要出人一个结点x，对结点的各域初始化，赋值，然后构造自身的环形双向链表后，将x加入H的根表中。 也就是说，结点x 成为一棵单结点的最小堆有序树，同时就是斐波那契堆中一棵无序树而且在根表最小结点的左边。

     如图是将关键字为21的结点插入斐波那契堆。该结点自成一棵最小堆有序树，从而被加入到根表中，成为根的左兄弟。 

 

 

C代码   收藏代码
  1. //堆结点x插入fibonacci heap中  
  2. void FibHeapInsert(FibHeap * heap, FibNode * x) {  
  3.     if (0 == heap->keyNum) {  
  4.         heap->min = x;  
  5.     } else {  
  6.         FibNodeAdd(x, heap->min);  
  7.         x->parent = NULL;  
  8.         if (x->key < heap->min->key) {  
  9.             heap->min = x;  
  10.         }  
  11.     }  
  12.     heap->keyNum++;  
  13. }  
  14.    
  15. //将数组内的值插入Fibonacci Heap  
  16. void FibHeapInsertKeys(FibHeap * heap, int keys[], int keyNum) {  
  17.     for (int i = 0; i < keyNum; i++) {  
  18.         FibHeapInsertKey(heap, keys[i]);  
  19.     }  
  20. }  
  21.    
  22. //将值插入Fibonacci Heap  
  23. static void FibHeapInsertKey(FibHeap * heap, int key) {  
  24.     FibNode * x = NULL;  
  25.     x = FibHeapNodeMake();  
  26.     x->key = key;  
  27.     FibHeapInsert(heap, x);  
  28. }  

 

3.合并两个堆

不同于二项堆，这个操作在斐波那契堆里非常简单。仅仅简单地将H1和H2的两根表串联，然后确定一个新的最小结点。

4.抽取（删除）最小结点

抽取最小结点的操作是斐波那契堆最复杂的操作，就是过程比较多，下面一步一步介绍。

1）将要抽取最小结点的子树都直接串联在根表中，如图（b）

2）然后就是合并所有degree相等的树，直到没有相等的degree的树。

（1）先定义一个数组A，数组A保存的根表子树中的头结点，A[i]=y表示树 y 的degree值是 i 。这样就可以得到数组A的长度就等于当前斐波那契堆中degree的最大值。

（2）当发现两个相等的degree的树，就执行合并操作。“发现”是这样得到的——向右遍历根表的结点，得到当前子树的degree的值，如果该degree值在A数组已经有元素则就是degree相等，就可以合并了。如图（e）（f）就是将degree等于 1的两个子树合并。

 

 

C代码   收藏代码
  1. //抽取最小结点  
  2. FibNode * FibHeapExtractMin(FibHeap * heap) {  
  3.     FibNode * x = NULL, * z = heap->min;  
  4.     if (z != NULL) {  
  5.    
  6.         //删除z的每一个孩子  
  7.         while (NULL != z->child) {  
  8.             x = z->child;  
  9.             FibNodeRemove(x);  
  10.             if (x->right == x) {  
  11.                 z->child = NULL;  
  12.             } else {  
  13.                 z->child = x->right;  
  14.             }  
  15.             FibNodeAdd(x, z);//add x to the root list heap  
  16.             x->parent = NULL;  
  17.         }  
  18.    
  19.         FibNodeRemove(z);  
  20.         if (z->right == z) {  
  21.             heap->min = NULL;  
  22.         } else {  
  23.             heap->min = z->right;  
  24.             FibHeapConsolidate(heap);  
  25.         }  
  26.         heap->keyNum--;  
  27.     }  
  28.     return z;  
  29. }  
  30.    
  31. //合并左右相同度数的二项树  
  32. void FibHeapConsolidate(FibHeap * heap) {  
  33.     int D, d;  
  34.     FibNode * w = heap->min, * x = NULL, * y = NULL;  
  35.     FibHeapConsMake(heap);//开辟哈希所用空间  
  36.     D = heap->maxNumOfDegree + 1;  
  37.     for (int i = 0; i < D; i++) {  
  38.         *(heap->cons + i) = NULL;  
  39.     }  
  40.    
  41.     //合并相同度的根节点，使每个度数的二项树唯一  
  42.     while (NULL != heap->min) {  
  43.         x = FibHeapMinRemove(heap);  
  44.         d = x->degree;  
  45.         while (NULL != *(heap->cons + d)) {  
  46.             y = *(heap->cons + d);  
  47.             if (x->key > y->key) {//根结点key最小  
  48.                 swap(x, y);  
  49.             }  
  50.             FibHeapLink(heap, y, x);  
  51.             *(heap->cons + d) = NULL;  
  52.             d++;  
  53.         }  
  54.         *(heap->cons + d) = x;  
  55.     }  
  56.     heap->min = NULL;//原有根表清除  
  57.    
  58.     //将heap->cons中结点都重新加到根表中，且找出最小根  
  59.     for (int i = 0; i < D; i++) {  
  60.         if (*(heap->cons + i) != NULL) {  
  61.             if (NULL == heap->min) {  
  62.                 heap->min = *(heap->cons + i);  
  63.             } else {  
  64.                 FibNodeAdd(*(heap->cons + i), heap->min);  
  65.                 if ((*(heap->cons + i))->key < heap->min->key) {  
  66.                     heap->min = *(heap->cons + i);  
  67.                 }//if(<)  
  68.             }//if-else(==)  
  69.         }//if(!=)  
  70.     }//for(i)  
  71. }  
  72.    
  73. //将x根结点链接到y根结点  
  74. void FibHeapLink(FibHeap * heap, FibNode * x, FibNode *y) {  
  75.     FibNodeRemove(x);  
  76.     if (NULL == y->child) {  
  77.         y->child = x;  
  78.     } else {  
  79.         FibNodeAdd(x, y->child);  
  80.     }  
  81.     x->parent = y;  
  82.     y->degree++;  
  83.     x->marked = false;  
  84. }  
  85.    
  86. //开辟FibHeapConsolidate函数哈希所用空间  
  87. static void FibHeapConsMake(FibHeap * heap) {  
  88.     int old = heap->maxNumOfDegree;  
  89.     heap->maxNumOfDegree = int(log(heap->keyNum * 1.0) / log(2.0)) + 1;  
  90.     if (old < heap->maxNumOfDegree) {  
  91.         //因为度为heap->maxNumOfDegree可能被合并,所以要maxNumOfDegree + 1  
  92.         heap->cons = (FibNode **) realloc(heap->cons,  
  93.             sizeof(FibHeap *) * (heap->maxNumOfDegree + 1));  
  94.         if (NULL == heap->cons) {  
  95.             puts("Out of Space!");  
  96.             exit(1);  
  97.         }  
  98.     }  
  99. }  
  100.    
  101. //将堆的最小结点移出，并指向其有兄弟  
  102. static FibNode *FibHeapMinRemove(FibHeap * heap) {  
  103.     FibNode *min = heap->min;  
  104.     if (heap->min == min->right) {  
  105.         heap->min = NULL;  
  106.     } else {  
  107.         FibNodeRemove(min);  
  108.         heap->min = min->right;  
  109.     }  
  110.     min->left = min->right = min;  
  111.     return min;  
  112. }  
 

 

5.减小一个关键字

减小一个关键字的字，会破坏最小堆的性质，所以要进行最小堆维护。因为斐波那契支持减小关键字和删除结点操作，所以斐波那契堆的子树就不一定是二项树了。

减小一个关键字主要进行两个步骤：

1）减小关键字，如果破坏最小堆性质，则将该结点a直接从原来的树移除直接串联在根表中，并将父结点p的mark属性设置成长true。

2）进行级联剪枝：如果当前父结点p的mark属性是true，且p的父结点pp的mark属性也是true，那么将p从pp移除加入到根表中

下图中，黑色的结点表示其mark属性为true，(a)(b)将关键字46减少为15，没有发生级联剪枝；（c,d,e）将35减小为5，发生了级联剪枝操作

C代码   收藏代码
  1. //减小一个关键字  
  2. void FibHeapDecrease(FibHeap * heap, FibNode * x, int key) {  
  3.     FibNode * y = x->parent;  
  4.     if (x->key < key) {  
  5.         puts("new key is greater than current key!");  
  6.         exit(1);  
  7.     }  
  8.     x->key = key;  
  9.    
  10.     if (NULL != y && x->key < y->key) {  
  11.         //破坏了最小堆性质，需要进行级联剪切操作  
  12.         FibHeapCut(heap, x, y);  
  13.         FibHeapCascadingCut(heap, y);  
  14.     }  
  15.     if (x->key < heap->min->key) {  
  16.         heap->min = x;  
  17.     }  
  18. }  
  19.    
  20. //切断x与父节点y之间的链接，使x成为一个根  
  21. static void FibHeapCut(FibHeap * heap, FibNode * x, FibNode * y) {  
  22.     FibNodeRemove(x);  
  23.     renewDegree(y, x->degree);  
  24.     if (x == x->right) {  
  25.         y->child = NULL;  
  26.     } else {  
  27.         y->child = x->right;  
  28.     }  
  29.     x->parent = NULL;  
  30.     x->left = x->right = x;  
  31.     x->marked = false;  
  32.     FibNodeAdd(x, heap->min);  
  33. }  
  34.    
  35. //级联剪切  
  36. static void FibHeapCascadingCut(FibHeap * heap, FibNode * y) {  
  37.     FibNode * z = y->parent;  
  38.     if (NULL != z) {  
  39.         if (y->marked == false) {  
  40.             y->marked = true;  
  41.         } else {  
  42.             FibHeapCut(heap, y, z);  
  43.             FibHeapCascadingCut(heap, z);  
  44.         }  
  45.     }  
  46. }  
  47.    
  48. //修改度数  
  49. void renewDegree(FibNode * parent, int degree) {  
  50.     parent->degree -= degree;  
  51.     if (parent-> parent != NULL) {  
  52.         renewDegree(parent->parent, degree);  
  53.     }  
  54. }  

 6.删除一个结点

删除结点X，首先将X的关键字值减小到比最小结点的值更小（调用减小一个关键字的过程），然后删除（抽取）最小结点就可以了。

C代码   收藏代码
  1. //删除结点  
  2. void FibHeapDelete(FibHeap * heap, FibNode * x) {  
  3.     FibHeapDecrease(heap, x, INT_MIN);  
  4.     FibHeapExtractMin(heap);  
  5. }  

 

斐波那契堆完整实现

 

Cpp代码   收藏代码
  1. //说明：  
  2. //代码中Fibonacci Heap 用变量heap表示  
  3. //结点通常用x，y等表示  
  4. #include<iostream>  
  5. #include<cstdio>  
  6. #include<cstdlib>  
  7. #include<cmath>  
  8. #include<climits>  
  9. using namespace std;  
  10.    
  11. //斐波那契结点ADT  
  12. struct FibonacciHeapNode {  
  13.     int key;       //结点  
  14.     int degree;    //度  
  15.     FibonacciHeapNode * left;  //左兄弟  
  16.     FibonacciHeapNode * right; //右兄弟  
  17.     FibonacciHeapNode * parent; //父结点  
  18.     FibonacciHeapNode * child;  //第一个孩子结点  
  19.     bool marked;           //是否被删除第1个孩子  
  20. };  
  21.    
  22. typedef FibonacciHeapNode FibNode;  
  23.    
  24. //斐波那契堆ADT  
  25. struct FibonacciHeap {  
  26.     int keyNum;   //堆中结点个数  
  27.     FibonacciHeapNode * min;//最小堆，根结点  
  28.     int maxNumOfDegree;   //最大度  
  29.     FibonacciHeapNode * * cons;//指向最大度的内存区域  
  30. };  
  31.    
  32. typedef FibonacciHeap FibHeap;  
  33.    
  34. /*****************函数申明*************************/  
  35. //将x从双链表移除  
  36. inline void FibNodeRemove(FibNode * x);  
  37.    
  38. //将x堆结点加入y结点之前(循环链表中)  
  39. void FibNodeAdd(FibNode * x, FibNode * y);  
  40.    
  41. //初始化一个空的Fibonacci Heap  
  42. FibHeap * FibHeapMake() ;  
  43.    
  44. //初始化结点x  
  45. FibNode * FibHeapNodeMake();  
  46.    
  47. //堆结点x插入fibonacci heap中  
  48. void FibHeapInsert(FibHeap * heap, FibNode * x);  
  49.    
  50. //将数组内的值插入Fibonacci Heap  
  51. void FibHeapInsertKeys(FibHeap * heap, int keys[], int keyNum);  
  52.    
  53. //将值插入Fibonacci Heap  
  54. static void FibHeapInsertKey(FibHeap * heap, int key);  
  55.    
  56. //抽取最小结点  
  57. FibNode * FibHeapExtractMin(FibHeap * heap);  
  58.    
  59. //合并左右相同度数的二项树  
  60. void FibHeapConsolidate(FibHeap * heap);  
  61.    
  62. //将x根结点链接到y根结点  
  63. void FibHeapLink(FibHeap * heap, FibNode * x, FibNode *y);  
  64.    
  65. //开辟FibHeapConsolidate函数哈希所用空间  
  66. static void FibHeapConsMake(FibHeap * heap);  
  67.    
  68. //将堆的最小结点移出，并指向其有兄弟  
  69. static FibNode *FibHeapMinRemove(FibHeap * heap);  
  70.    
  71. //减小一个关键字  
  72. void FibHeapDecrease(FibHeap * heap, FibNode * x, int key);  
  73.    
  74. //切断x与父节点y之间的链接，使x成为一个根  
  75. static void FibHeapCut(FibHeap * heap, FibNode * x, FibNode * y);  
  76.    
  77. //级联剪切  
  78. static void FibHeapCascadingCut(FibHeap * heap, FibNode * y);  
  79.    
  80. //修改度数  
  81. void renewDegree(FibNode * parent, int degree);  
  82.    
  83. //删除结点  
  84. void FibHeapDelete(FibHeap * heap, FibNode * x);  
  85.    
  86. //堆内搜索关键字  
  87. FibNode * FibHeapSearch(FibHeap * heap, int key);  
  88.    
  89. //被FibHeapSearch调用  
  90. static FibNode * FibNodeSearch(FibNode * x, int key);  
  91.    
  92. //销毁堆  
  93. void FibHeapDestory(FibHeap * heap);  
  94.    
  95. //被FibHeapDestory调用  
  96. static void FibNodeDestory(FibNode * x);  
  97.    
  98. //输出打印堆  
  99. static void FibHeapPrint(FibHeap * heap);  
  100.    
  101. //被FibHeapPrint调用  
  102. static void FibNodePrint(FibNode * x);  
  103. /************************************************/  
  104.    
  105. //将x从双链表移除  
  106. inline void FibNodeRemove(FibNode * x) {  
  107.     x->left->right = x->right;  
  108.     x->right->left = x->left;  
  109. }  
  110.    
  111. /* 
  112. 将x堆结点加入y结点之前(循环链表中) 
  113.     a …… y 
  114.     a …… x …… y 
  115. */  
  116. inline void FibNodeAdd(FibNode * x, FibNode * y) {  
  117.     x->left = y->left;  
  118.     y->left->right = x;  
  119.     x->right = y;  
  120.     y->left = x;  
  121. }  
  122.    
  123. //初始化一个空的Fibonacci Heap  
  124. FibHeap * FibHeapMake() {  
  125.     FibHeap * heap = NULL;  
  126.     heap = (FibHeap *) malloc(sizeof(FibHeap));  
  127.     if (NULL == heap) {  
  128.         puts("Out of Space!!");  
  129.         exit(1);  
  130.     }  
  131.     memset(heap, 0, sizeof(FibHeap));  
  132.     return heap;  
  133. }  
  134.    
  135. //初始化结点x  
  136. FibNode * FibHeapNodeMake() {  
  137.     FibNode * x = NULL;  
  138.     x = (FibNode *) malloc(sizeof(FibNode));  
  139.     if (NULL == x) {  
  140.         puts("Out of Space!!");  
  141.         exit(1);  
  142.     }  
  143.     memset(x, 0, sizeof(FibNode));  
  144.     x->left = x->right = x;  
  145.     return x;  
  146. }  
  147.    
  148. //堆结点x插入fibonacci heap中  
  149. void FibHeapInsert(FibHeap * heap, FibNode * x) {  
  150.     if (0 == heap->keyNum) {  
  151.         heap->min = x;  
  152.     } else {  
  153.         FibNodeAdd(x, heap->min);  
  154.         x->parent = NULL;  
  155.         if (x->key < heap->min->key) {  
  156.             heap->min = x;  
  157.         }  
  158.     }  
  159.     heap->keyNum++;  
  160. }  
  161.    
  162. //将数组内的值插入Fibonacci Heap  
  163. void FibHeapInsertKeys(FibHeap * heap, int keys[], int keyNum) {  
  164.     for (int i = 0; i < keyNum; i++) {  
  165.         FibHeapInsertKey(heap, keys[i]);  
  166.     }  
  167. }  
  168.    
  169. //将值插入Fibonacci Heap  
  170. static void FibHeapInsertKey(FibHeap * heap, int key) {  
  171.     FibNode * x = NULL;  
  172.     x = FibHeapNodeMake();  
  173.     x->key = key;  
  174.     FibHeapInsert(heap, x);  
  175. }  
  176.    
  177. //抽取最小结点  
  178. FibNode * FibHeapExtractMin(FibHeap * heap) {  
  179.     FibNode * x = NULL, * z = heap->min;  
  180.     if (z != NULL) {  
  181.    
  182.         //删除z的每一个孩子  
  183.         while (NULL != z->child) {  
  184.             x = z->child;  
  185.             FibNodeRemove(x);  
  186.             if (x->right == x) {  
  187.                 z->child = NULL;  
  188.             } else {  
  189.                 z->child = x->right;  
  190.             }  
  191.             FibNodeAdd(x, z);//add x to the root list heap  
  192.             x->parent = NULL;  
  193.         }  
  194.    
  195.         FibNodeRemove(z);  
  196.         if (z->right == z) {  
  197.             heap->min = NULL;  
  198.         } else {  
  199.             heap->min = z->right;  
  200.             FibHeapConsolidate(heap);  
  201.         }  
  202.         heap->keyNum--;  
  203.     }  
  204.     return z;  
  205. }  
  206.    
  207. //合并左右相同度数的二项树  
  208. void FibHeapConsolidate(FibHeap * heap) {  
  209.     int D, d;  
  210.     FibNode * w = heap->min, * x = NULL, * y = NULL;  
  211.     FibHeapConsMake(heap);//开辟哈希所用空间  
  212.     D = heap->maxNumOfDegree + 1;  
  213.     for (int i = 0; i < D; i++) {  
  214.         *(heap->cons + i) = NULL;  
  215.     }  
  216.    
  217.     //合并相同度的根节点，使每个度数的二项树唯一  
  218.     while (NULL != heap->min) {  
  219.         x = FibHeapMinRemove(heap);  
  220.         d = x->degree;  
  221.         while (NULL != *(heap->cons + d)) {  
  222.             y = *(heap->cons + d);  
  223.             if (x->key > y->key) {//根结点key最小  
  224.                 swap(x, y);  
  225.             }  
  226.             FibHeapLink(heap, y, x);  
  227.             *(heap->cons + d) = NULL;  
  228.             d++;  
  229.         }  
  230.         *(heap->cons + d) = x;  
  231.     }  
  232.     heap->min = NULL;//原有根表清除  
  233.    
  234.     //将heap->cons中结点都重新加到根表中，且找出最小根  
  235.     for (int i = 0; i < D; i++) {  
  236.         if (*(heap->cons + i) != NULL) {  
  237.             if (NULL == heap->min) {  
  238.                 heap->min = *(heap->cons + i);  
  239.             } else {  
  240.                 FibNodeAdd(*(heap->cons + i), heap->min);  
  241.                 if ((*(heap->cons + i))->key < heap->min->key) {  
  242.                     heap->min = *(heap->cons + i);  
  243.                 }//if(<)  
  244.             }//if-else(==)  
  245.         }//if(!=)  
  246.     }//for(i)  
  247. }  
  248.    
  249. //将x根结点链接到y根结点  
  250. void FibHeapLink(FibHeap * heap, FibNode * x, FibNode *y) {  
  251.     FibNodeRemove(x);  
  252.     if (NULL == y->child) {  
  253.         y->child = x;  
  254.     } else {  
  255.         FibNodeAdd(x, y->child);  
  256.     }  
  257.     x->parent = y;  
  258.     y->degree++;  
  259.     x->marked = false;  
  260. }  
  261.    
  262. //开辟FibHeapConsolidate函数哈希所用空间  
  263. static void FibHeapConsMake(FibHeap * heap) {  
  264.     int old = heap->maxNumOfDegree;  
  265.     heap->maxNumOfDegree = int(log(heap->keyNum * 1.0) / log(2.0)) + 1;  
  266.     if (old < heap->maxNumOfDegree) {  
  267.         //因为度为heap->maxNumOfDegree可能被合并,所以要maxNumOfDegree + 1  
  268.         heap->cons = (FibNode **) realloc(heap->cons,  
  269.             sizeof(FibHeap *) * (heap->maxNumOfDegree + 1));  
  270.         if (NULL == heap->cons) {  
  271.             puts("Out of Space!");  
  272.             exit(1);  
  273.         }  
  274.     }  
  275. }  
  276.    
  277. //将堆的最小结点移出，并指向其有兄弟  
  278. static FibNode *FibHeapMinRemove(FibHeap * heap) {  
  279.     FibNode *min = heap->min;  
  280.     if (heap->min == min->right) {  
  281.         heap->min = NULL;  
  282.     } else {  
  283.         FibNodeRemove(min);  
  284.         heap->min = min->right;  
  285.     }  
  286.     min->left = min->right = min;  
  287.     return min;  
  288. }  
  289.    
  290. //减小一个关键字  
  291. void FibHeapDecrease(FibHeap * heap, FibNode * x, int key) {  
  292.     FibNode * y = x->parent;  
  293.     if (x->key < key) {  
  294.         puts("new key is greater than current key!");  
  295.         exit(1);  
  296.     }  
  297.     x->key = key;  
  298.    
  299.     if (NULL != y && x->key < y->key) {  
  300.         //破坏了最小堆性质，需要进行级联剪切操作  
  301.         FibHeapCut(heap, x, y);  
  302.         FibHeapCascadingCut(heap, y);  
  303.     }  
  304.     if (x->key < heap->min->key) {  
  305.         heap->min = x;  
  306.     }  
  307. }  
  308.    
  309. //切断x与父节点y之间的链接，使x成为一个根  
  310. static void FibHeapCut(FibHeap * heap, FibNode * x, FibNode * y) {  
  311.     FibNodeRemove(x);  
  312.     renewDegree(y, x->degree);  
  313.     if (x == x->right) {  
  314.         y->child = NULL;  
  315.     } else {  
  316.         y->child = x->right;  
  317.     }  
  318.     x->parent = NULL;  
  319.     x->left = x->right = x;  
  320.     x->marked = false;  
  321.     FibNodeAdd(x, heap->min);  
  322. }  
  323.    
  324. //级联剪切  
  325. static void FibHeapCascadingCut(FibHeap * heap, FibNode * y) {  
  326.     FibNode * z = y->parent;  
  327.     if (NULL != z) {  
  328.         if (y->marked == false) {  
  329.             y->marked = true;  
  330.         } else {  
  331.             FibHeapCut(heap, y, z);  
  332.             FibHeapCascadingCut(heap, z);  
  333.         }  
  334.     }  
  335. }  
  336.    
  337. //修改度数  
  338. void renewDegree(FibNode * parent, int degree) {  
  339.     parent->degree -= degree;  
  340.     if (parent-> parent != NULL) {  
  341.         renewDegree(parent->parent, degree);  
  342.     }  
  343. }  
  344.    
  345. //删除结点  
  346. void FibHeapDelete(FibHeap * heap, FibNode * x) {  
  347.     FibHeapDecrease(heap, x, INT_MIN);  
  348.     FibHeapExtractMin(heap);  
  349. }  
  350.    
  351. //堆内搜索关键字  
  352. FibNode * FibHeapSearch(FibHeap * heap, int key) {  
  353.     return FibNodeSearch(heap->min, key);  
  354. }  
  355.    
  356. //被FibHeapSearch调用  
  357. static FibNode * FibNodeSearch(FibNode * x, int key) {  
  358.     FibNode * w = x, * y = NULL;  
  359.     if (x != NULL) {  
  360.         do {  
  361.             if (w->key == key) {  
  362.                 y = w;  
  363.                 break;  
  364.             } else if (NULL != (y = FibNodeSearch(w->child, key))) {  
  365.                 break;  
  366.             }  
  367.             w = w->right;  
  368.         } while (w != x);  
  369.     }  
  370.     return y;  
  371. }  
  372.    
  373. //销毁堆  
  374. void FibHeapDestory(FibHeap * heap) {  
  375.     FibNodeDestory(heap->min);  
  376.     free(heap);  
  377.     heap = NULL;  
  378. }  
  379.    
  380. //被FibHeapDestory调用  
  381. static void FibNodeDestory(FibNode * x) {  
  382.     FibNode * p = x, *q = NULL;  
  383.     while (p != NULL) {  
  384.         FibNodeDestory(p->child);  
  385.         q = p;  
  386.         if (p -> left == x) {  
  387.             p = NULL;  
  388.         } else {  
  389.             p = p->left;  
  390.         }  
  391.         free(q->right);  
  392.     }  
  393. }  
  394.    
  395. //输出打印堆  
  396. static void FibHeapPrint(FibHeap * heap) {  
  397.     printf("The keyNum = %d\n", heap->keyNum);  
  398.     FibNodePrint(heap->min);  
  399.     puts("\n");  
  400. };  
  401.    
  402. //被FibHeapPrint调用  
  403. static void FibNodePrint(FibNode * x) {  
  404.     FibNode * p = NULL;  
  405.     if (NULL == x) {  
  406.         return ;  
  407.     }  
  408.     p = x;  
  409.     do {  
  410.         printf(" (");  
  411.         printf("%d", p->key);  
  412.         if (p->child != NULL) {  
  413.             FibNodePrint(p->child);  
  414.         }  
  415.         printf(") ");  
  416.         p = p->left;  
  417.     }while (x != p);  
  418. }  
  419.    
  420. int keys[10] = {1, 2, 3, 4, 5, 6, 7, 9, 10, 11};  
  421.    
  422. int main() {  
  423.     FibHeap * heap = NULL;  
  424.     FibNode * x = NULL;  
  425.     heap = FibHeapMake();  
  426.     FibHeapInsertKeys(heap, keys, 10);  
  427.     FibHeapPrint(heap);  
  428.    
  429.     x = FibHeapExtractMin(heap);  
  430.     printf("抽取最小值%d之后：\n", x->key);  
  431.     FibHeapPrint(heap);  
  432.    
  433.     x = FibHeapSearch(heap, 11);  
  434.     if (NULL != x) {  
  435.         printf("查找%d成功,", x->key);  
  436.         FibHeapDecrease(heap, x, 8);  
  437.         printf("减小到%d后：\n", x->key);  
  438.         FibHeapPrint(heap);  
  439.     }  
  440.    
  441.     x = FibHeapSearch(heap, 7);  
  442.     if (NULL != x) {  
  443.         printf("删除%d成功:\n", x->key);  
  444.         FibHeapDelete(heap, x);  
  445.         FibHeapPrint(heap);  
  446.     }  
  447.    
  448.     FibHeapDestory(heap);  
  449.     return 0;  
  450. }  

 

Pairing Heap

斐波那契堆主要有两个缺点：编程实现难度较大和实际效率没有理论的那么快（由于它的存储结构和四个指针）。Pairing Heap的提出就是弥补斐波那契堆的两个缺点——编程简单操作的时间复杂度和斐波那契堆一样。

Pairing Heap其实就是一个具有堆（最大堆或最小堆）性质的树，它的特性不是由它的结构决定的，而是由于它的操作（插入，合并，减小一个关键字等）决定的。

 

Pairing Heap的ADT

 

C代码   收藏代码
  1. typedef struct PairingHeapNode  
  2. {  
  3.     int                         key;  
  4.     struct  PairingHeapNode*    child;  
  5.     struct  PairingHeapNode*    sibling;  
  6.     struct  PairingHeapNode*    prev;  
  7.   
  8. }PairHeap;  

 

Pairing Heap 的操作

注意：图解过程是以最大堆来演示的，但是代码是以最小堆来写的，见谅！

1.合并两个子堆


优先队列三大利器——二项堆、斐波那契堆、Pairing 堆_第4张图片

C代码   收藏代码
  1. static PairHeap* merge_subheaps(PairHeap *p, PairHeap *q)  
  2. {  
  3.     if(q == NULL)  
  4.         return p;  
  5.     else if(p->key <= q->key)  
  6.     {  
  7.         q->prev = p;  
  8.         p->sibling = q->sibling;  
  9.         if(p->sibling != NULL)  
  10.             p->sibling->prev = p;  
  11.   
  12.         q->sibling = p->child;  
  13.         if(q->sibling != NULL)  
  14.             q->sibling->prev = q;  
  15.   
  16.         p->child = q;  
  17.         return p;  
  18.     }  
  19.     else  
  20.     {  
  21.         q->prev = p->prev;  
  22.         p->prev = q;  
  23.         p->sibling = q->child;  
  24.         if(p->sibling != NULL)  
  25.             p->sibling->prev = p;  
  26.   
  27.         q->child = p;  
  28.         return q;  
  29.     }  
  30. }  
 

 

2. 插入一个结点


优先队列三大利器——二项堆、斐波那契堆、Pairing 堆_第5张图片

C代码   收藏代码
  1. PairHeap* PairHeap_insert(PairHeap *p, int key)  
  2. {  
  3.     PairHeap *node;  
  4.   
  5.     node = (PairHeap*)malloc(sizeof(*node));  
  6.     if(node == NULL)  
  7.         return NULL;  
  8.   
  9.     node->key = key;  
  10.     node->child = node->sibling = node->prev = NULL;  
  11.   
  12.     if(p == NULL)  
  13.         return node;  
  14.     else  
  15.         return merge_subheaps(p, node);  
  16. }  

3.增加（减小）一个关键字


优先队列三大利器——二项堆、斐波那契堆、Pairing 堆_第6张图片

 


优先队列三大利器——二项堆、斐波那契堆、Pairing 堆_第7张图片

C代码   收藏代码
  1. PairHeap* PairHeap_DecreaseKey(PairHeap *p, PairHeap *pos, int d)  
  2. {  
  3.     if(d < 0)  
  4.         return p;  
  5.   
  6.     pos->key = pos->key - d;  
  7.     if(p == pos)  
  8.         return p;  
  9.   
  10.     if(pos->sibling != NULL)  
  11.         pos->sibling->prev = pos->prev;  
  12.   
  13.     if(pos->prev->child = pos)  
  14.         pos->prev->child = pos->sibling;  
  15.     else  
  16.         pos->prev->sibling = p->sibling;  
  17.   
  18.     p->sibling = NULL;  
  19.     return merge_subheaps(p, pos);  
  20. }   

5.删除最小结点


优先队列三大利器——二项堆、斐波那契堆、Pairing 堆_第8张图片

 

 

Pairing Heap完整实现

 

C代码   收藏代码
  1. #include <stdlib.h>  
  2.   
  3. typedef struct PairingHeapNode  
  4. {  
  5.     int                         key;  
  6.     struct  PairingHeapNode*    child;  
  7.     struct  PairingHeapNode*    sibling;  
  8.     struct  PairingHeapNode*    prev;  
  9.   
  10. }PairHeap;  
  11.   
  12. static PairHeap* merge_subheaps(PairHeap *p, PairHeap *q);  
  13. static PairHeap* combine_siblings(PairHeap *p);  
  14.   
  15. PairHeap* PairHeap_insert(PairHeap *p, int key)  
  16. {  
  17.     PairHeap *node;  
  18.   
  19.     node = (PairHeap*)malloc(sizeof(*node));  
  20.     if(node == NULL)  
  21.         return NULL;  
  22.   
  23.     node->key = key;  
  24.     node->child = node->sibling = node->prev = NULL;  
  25.   
  26.     if(p == NULL)  
  27.         return node;  
  28.     else  
  29.         return merge_subheaps(p, node);  
  30. }  
  31.   
  32. PairHeap* PairHeap_DecreaseKey(PairHeap *p, PairHeap *pos, int d)  
  33. {  
  34.     if(d < 0)  
  35.         return p;  
  36.   
  37.     pos->key = pos->key - d;  
  38.     if(p == pos)  
  39.         return p;  
  40.   
  41.     if(pos->sibling != NULL)  
  42.         pos->sibling->prev = pos->prev;  
  43.   
  44.     if(pos->prev->child = pos)  
  45.         pos->prev->child = pos->sibling;  
  46.     else  
  47.         pos->prev->sibling = p->sibling;  
  48.   
  49.     p->sibling = NULL;  
  50.     return merge_subheaps(p, pos);  
  51. }  
  52.   
  53. PairHeap* PairHeap_DeleteMin(int *key, PairHeap *p)  
  54. {  
  55.     PairHeap *new_root;  
  56.   
  57.     if(p == NULL)  
  58.         return NULL;  
  59.     else  
  60.     {  
  61.         *key = p->key;  
  62.         if(p->child != NULL)  
  63.             new_root = combine_siblings(p->child);  
  64.   
  65.         free(p);  
  66.     }  
  67.     return new_root;  
  68. }  
  69.   
  70. static PairHeap* combine_siblings(PairHeap *p)  
  71. {  
  72.     PairHeap *tree_array[1024];  
  73.     int i, count;  
  74.   
  75.     if(p->sibling == NULL)  
  76.         return p;  
  77.   
  78.     for(count = 0; p != NULL; count++)  
  79.     {  
  80.         tree_array[count] = p;  
  81.         p->prev->sibling = NULL;  
  82.         p = p->sibling;  
  83.     }  
  84.     tree_array[count] = NULL;  
  85.   
  86.     for(i = 1; i < count; i++)  
  87.         tree_array[i] = merge_subheaps(tree_array[i-1], tree_array[i]);  
  88.   
  89.     return tree_array[count-1];  
  90. }  
  91.   
  92. static PairHeap* merge_subheaps(PairHeap *p, PairHeap *q)  
  93. {  
  94.     if(q == NULL)  
  95.         return p;  
  96.     else if(p->key <= q->key)  
  97.     {  
  98.         q->prev = p;  
  99.         p->sibling = q->sibling;  
  100.         if(p->sibling != NULL)  
  101.             p->sibling->prev = p;  
  102.   
  103.         q->sibling = p->child;  
  104.         if(q->sibling != NULL)  
  105.             q->sibling->prev = q;  
  106.   
  107.         p->child = q;  
  108.         return p;  
  109.     }  
  110.     else  
  111.     {  
  112.         q->prev = p->prev;  
  113.         p->prev = q;  
  114.         p->sibling = q->child;  
  115.         if(p->sibling != NULL)  
  116.             p->sibling->prev = p;  
  117.   
  118.         q->child = p;  
  119.         return q;  
  120.     }  
  121. }  
 

 

小结

终于到小结了，这篇文章写得比较吃力，如斐波那契堆的“减小一个关键字”的操作我就对使用级联剪切还没有找到解释，还有还没有找到Pairing Heap的定义，唯独只有自己理解和揣测（比如pairing heap没有明确的定义，本人个人理解pairing heap的独特性一定在他的操作，即行为决定特征）但总归还是相对完整，希望能对你有说帮助。如果你有任何建议、批评或补充，还请你不吝提出，不甚感激。更多参考请移步互联网。

 

 

 

 

参考：

①酷~行天下： http://mindlee.net/2011/09/26/binomial-heaps/

②Björn B. Brandenburg： http://www.cs.unc.edu/~bbb/#binomial_heaps

③酷~行天下： http://mindlee.net/2011/09/29/fibonacci-heaps/

④Adoo's blog ： http://www.roading.org/algorithm/introductiontoalgorithm/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E5%A0%86fibonacci-heaps.html

⑤Golden_Shadow： http://blog.csdn.net/golden_shadow/article/details/6216921

⑥Sartaj Sahni： http://www.cise.ufl.edu/~sahni/dsaaj/enrich/c13/pairing.htm

⑦C++ template Fibonacci heap, with demonstration： http://ideone.com/9jYnv

⑧"The pairing heap: a new form of self-adjusting heap"： http://www.cs.cmu.edu/afs/cs.cmu.edu/user/sleator/www/papers/pairing-heaps.pdf

⑨Vikas Tandi ： http://programmingpraxis.com/2009/08/14/pairing-heaps/

⑩http://www.cise.ufl.edu/~sahni/cop5536/slides/lec156.pdf

⑩+1： 算法导论和维基百科


你可能感兴趣的:(堆,优先队列,二项堆,斐波那契堆,pairing)

  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面 一个射手座的程序媛 程序员华为od面试职场和发展
    最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 第六章 零食风波 香香的懒洋洋
    自从有了女儿，虎子和妞子矛盾越来越多。虎子觉得妞子太懒、太脏，女儿的尿布从来不清洗。妞子经常把给女儿用过的尿布堆在炕头一角，让它们自己慢慢干，干了在用；妞子的头发，一个月也不清洗一次，散发出阵阵难闻的气味；更别说冲凉、洗澡了。屋子里弥漫着各种怪味，虎子打心底里讨厌妞子的习惯，但他一点也不帮忙照顾孩子。虎子妈实在看不下去时候，就直接告诉妞子，孩子尿布要洗、个人卫生要注意。但妞子嘴上答应好好的，却迟迟
  • 组诗·三国群英颂（周瑜、马超、贾诩、赵云） 颍川荀清
    念奴娇·怀周郎矶头万仞、若关情，仍叹当年英物！一揽长江，龙流怒，化作孙吴阵壁。浪里船城，铁锁平川，袖挽千堆雪。烈胆豪情，斗牛惊认奇杰！但看戎马余生，纵横万里，正英姿勃发。宏图霸业弹指间，惟见涛生云灭。苍天轻狂，妒意猖作，帅将难华发。难忆郎顾，青史相伴别月。古体·西凉天将军大漠狂烟起，孑然佩青锋。神威震羌月，锦袍曜汉空。终囚蜀山险，瘴疠掩长虹。天地一孤啸，匹马又西风。水调歌头·文和乱武山水应将残，清
  • 【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】 XWWW668899 C++基本概念c++c语言开发语言青少年编程
    文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
  • 有心栽花花不发，无心插枝枝发芽 幽默静好
    今年的倒春寒来势凶猛，仿佛一夜之间，开得热热闹闹的迎春花，便像是使完了力气，结束了一年一度的花期。小区里的园丁是勤劳的，将那些开败了的枝条进行精心修剪，我散步路过，看见堆在地上的不少，便随手捡了几枝。记不得曾经在哪里看过，说迎春花很好种植，只要捡略粗的枝条，随便插在花盆里，按时浇浇水就能成活。我也想试一试。回家找了个小花盆，将捡来的枝条剪成几小节，将盆插满。放在了阳台的一个角落里。说实话，我没太在
  • APQP，ASPICE，敏捷，功能安全，预期安全，这些汽车行业的一堆标准 二大宝贝 安全架构
    前言APQP,ASPICE,敏捷，功能安全，预期安全，PMP，PRICE2汽车行业的有这样一堆标准。我是半路出家来到汽车行业做项目经理的，对几个标准的感觉是，看了文档和各种解析之后还是一头雾水，不知道到底说了个啥，别人问我还是一脸懵逼。APQP（TS16949的最重要工具），ASPICE（软件）这些是质量标准，是优化整个公司体系的，但这套体系对项目管理有要求；敏捷，PMP这些是项目管理的标准；项目
  • 今天是个好日子 singing阿梅
    图片发自App今日小年公历日子是20180208上午赶写一个材料，关于“四风”问题自查自纠报告，待一稿已成送交主任过目，他瞄一眼即大声反对！不顾我这厢受伤的小心脏，立马重写！吓！下午两个视频会议自从单位条件改善，会议多开了不少……贷款到期开始着急上火今日写作任务还欠奉写什么呢原本想继续写《我的2017》系列很多时候所谓意义都是总结和提炼出来的码一堆文字于他人无甚意义于己也待商榷、重估。另一方面，冥
  • 《谁动了我的奶酪》:人生没危机感，真的不行 金征
    这几天心里一直闷闷不乐，因为工作调动，很不开心。恰好这时看了斯宾塞.约翰逊的《谁动了我的奶酪》这本书心中释然了。《谁动了我的奶酪》书说讲了两只老鼠嗅嗅和匆匆以及两个小矮人哼哼和唧唧，他们共同在迷宫中寻找奶酪。当找到一大堆奶酪时，大家都很高兴。嗅嗅和匆匆虽然天天来这里吃奶酪，可他们没有忘记沿途看看观察，当奶酪减少时，他们立马寻找下一个有奶酪的地方。哼哼和唧唧则心安理得天天来此享受奶酪，奶酪减少也没发
  • JVM源码分析之堆外内存完全解读 HeapDump性能社区
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
  • 【Death Note】网吧战神之7天爆肝渗透测试死亡笔记_sqlmap在默认情况下除了使用 char() 函数防止出现单引号 2401_84561374 程序员笔记
    网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！特殊服务端口2181zookeeper服务未授权访问
  • 生活的复杂 孙栋的故事
    生活的复杂。2020.11.07忙完人生的一件大件，花费1个星期。工作堆了一大堆。提不起兴趣。有一些重复的事情。很多事情做到一半，暂时不能完结，要等到明天。最近，在交通上，来回4小时。早起很困顿。刷抖音控制不住。一个获得兰亭奖的书法家，是用嘴写的毛笔，他失去了双手。比一般人更加优秀。真是靠嘴养活了自己。他在寺院抄经书，做自己喜欢的事情，还有学习佛法。对书法，他是真正热爱的。很多事情，我们只看到结果
  • Rust 所有权 简介 东离与糖宝 rust后端rust开发语言
    文章目录发现宝藏1.所有权基本概念2.所有权规则3.变量作用域4.栈与堆4.1栈（Stack）4.2堆（Heap）5.String类型5.1String类型5.2String的内存分配5.3所有权与内存管理5.4String与切片6.变量与数据交互方式6.1移动（Move）6.2.克隆（Clone）7.所有权与函数7.1.传递参数7.2.返回值总结发现宝藏前些天发现了一个巨牛的人工智能学习网站，通
  • 不倒翁一样的孩子 初依的光
    曾加过一个户外群，在那个户外群里认识了一位小姐姐。她是位十分有爱心的人，每逢周末都会去“爱心之家”（孤儿院）陪那里的孩子玩。那时候周末呆家很无聊，而我也想去看看那里的孩子，于是与她约了一个时间，去超市买了一大堆东西准备那个周末去“爱心之家”看看那里的孩子。事先与院助小姐姐通过气，大包小包刚拎到门口时就看到院助小姐姐已经站在门口等待。将手里生活用品一一放到客厅，院助小姐姐单独留下我说在去二楼看孩子之
  • LCR 078. 合并 K 个升序链表 装B且挨揍の LeetCode链表算法数据结构经验分享笔记java
    https://leetcode.cn/problems/vvXgSW/description/https://leetcode.cn/problems/vvXgSW/description/解题思路方法一：每个链表维护一个索引，每次找到值最小的节点，索引加一。可以采用优先队列实现。/***Definitionforsingly-linkedlist.*publicclassListNode{*i
  • 没人能猜到“未来有前景的事”，除非，你就喜欢。 梦想森林DreamForest
    没人能猜到“未来有前景的事”，除非，你就喜欢。小时候买来一张张邮票放在集邮册的时候，我就喜欢上面的图案，以及有时候四联的整齐秩序感。做拼布的时候，我就喜欢五颜六色的布块儿的拼贴，喜欢一针一线的进进出出，喜欢费劲又费时的把一部分与另外部分的拼缝。买回一包色铅笔、一堆卡片纸，买回一盒蜡笔、一个速写本，买回一沓毛边纸、一盒水彩颜料……虽然偶尔只画上几张，也觉酣畅淋漓。大张旗鼓，置办回来一堆烘焙材料、各种
  • 算法笔试-编程练习-好题-04 Glen 997 大厂校招-编程集训算法大厂笔试动态规划堆盒子
    题目:堆盒子礼盒大小不同，我们玩堆盒子的游戏，怎么堆盒子使得堆出的高度最高，每个礼盒的大小由长、宽、高表示，堆盒子的时候要求下面的盒子长、宽、高都必须大于上面的盒子，不包含等于。高度为堆出的礼盒的所有高度的总和。输入描述输入的第一行是礼盒的个数N，接下来输入N行，每行表示每个礼盒的长、宽、高。礼盒的数量不超过1000个，每个盒子的长、宽、高取值范围为1~10。输出描述输出一行，输出能堆出盒子的最高
  • 2024年Presto【基础 01】简介+架构+数据源+数据模型(2)，2024年最新一线互联网公司面经总结 2401_84264536 架构
    学习路线：这个方向初期比较容易入门一些，掌握一些基本技术，拿起各种现成的工具就可以开黑了。不过，要想从脚本小子变成黑客大神，这个方向越往后，需要学习和掌握的东西就会越来越多以下是网络渗透需要学习的内容：网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化资料的朋友，可以点击这里获取一个人可以走的很快，但一群人才能走的更远！不
  • JVM 调优篇7 调优案例1-堆空间的优化解决 健康平安的活着 jvm调优jvm
    一jvm优化1.1优化实施步骤*1)减少使用全局变量和大对象；2)调整新生代的大小到最合适；3)设置老年代的大小为最合适；4)选择合适的GC收集器；1.2关于GC优化原则多数的Java应用不需要在服务器上进行GC优化；多数导致GC问题的Java应用，都不是因为我们参数设置错误，而是代码问题；在应用上线之前，先考虑将机器的JVM参数设置到最优（最适合）；减少创建对象的数量；减少使用全局变量和大对象；
  • C++[USACO06NOV] Fence Repair G合并果子 龙眠客
    [USACO06NOV]FenceRepairG合并果子题目描述在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1n−1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。因为还要花大力气把这些果子搬回
  • P3489 [POI2009] WIE-Hexer summ1ts 算法c++图论dijkstra状态压缩
    *原题链接*最短路+状态压缩不愧是POI的题，看题面知道要求加了一些限制的最短路，看数据范围很容易想到状态压缩。求解最短路就用堆优化dijkstra好了。至于状态压缩，我们对原数组再开一维，表示此时“剑的集合”，相应的数组也要多开一维。由于此时的最短路有状态的限制，所以我们要用三元组来维护，如果不想写结构体也可以pair,int>。输入时存储边上的“怪物集合”，以及一个村庄的“铁匠集合”，在来到新
  • 读《野草》有感 雨后晴天的女孩
    这段时间有点懒，看过的书都没有做读书笔记，也就没有写读后感。但今晚看鲁迅的散文诗集《野草》时，却做了很多的笔记（主要是抄好词好句），突然就有了一种想写的冲动，虽然不知道要写点什么，但是随便写写也好。鲁迅的题辞中说到:野草，根本不深，花叶不美，却有一股顽强的生命力，任何人都阻挡不了它的生长。是啊，《野草》这本书虽不厚，却可以让人联想到一大堆的东西。阅读完之后，我想找几个词来形容一下，却怎么也想不到，
  • 研究表明，最好的养生方式，并非用钱保命，而是戒掉这四点 舒山有鹿
    01网络上流传着这么一句话，人到中年不得已，保温杯里泡枸杞。人到了一定的年纪，就只想“养生”，也不想做太多的事儿了。对于人来说，性命才是最为重要的，而其余的一切，还是稍微差了一点。在你看来，我们该怎么养生呢？有些人觉得，养生就是用钱堆出来的。只要吃得好，把什么人参燕窝山珍海味吃一遍，相信就能长寿到老。有些人觉得，养生就是吃保健品吃出来的。只要有钱，就能买不同的保健品，让自己的身体越来越好，安康一辈
  • JAVA相关知识 M_灵均 javajvm开发语言
    JAVA基础知识说一下对象创建的过程？类加载检查：当Java虚拟机（JVM）遇到一个类的new指令时，它首先检查这个类是否已经被加载、链接和初始化。如果没有，JVM会通过类加载器（ClassLoader）加载这个类。分配内存：JVM为新对象分配内存。这个内存分配是在堆（Heap）上进行的，堆是JVM用来存储对象实例的地方。分配内存的大小在类加载时就已经确定，因为类的结构（包括字段和方法）已经确定。
  • P4779 【模板】单源最短路径(堆优化dijkstra) summ1ts 一些模版算法图论最短路dijkstra堆
    堆优化dijkstra，时间复杂度，我个人写习惯的模版。#includeusingnamespacestd;#definePIIpair#definefifirst#definesesecondconstintN=2e5+10;intread(){intx=0,f=1;charch=getchar();while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar()
  • 无题 白马卓玛
    云堆巨浪茫，雪坠玉穹凉。纤态移金步，裙飘彩带长。红梅高翘盼，闻喜鹊声香。风荡愁云去，春风得意扬。图片发自App
  • 华为开源镜像站体验：美好终将不期而遇 cuishuogai2817 操作系统javapython
    电脑因为前段时间有问题，昨天刚刚重装好系统，之前一大堆运行环境全部要重新弄……T_T今天碰上华为开源镜像站体验，那就测试和体验一把吧！先说说测试环境：网络：广东电信20M企业光纤系统：Windows764-bit&CentOS7.6(VMWare)华为开源镜像站地址：http://t.cn/EcBQJO4测试一：python3.6.6(win)首先是windows下的python3.6.6打开说明
  • CSP-J(/S) 2020爆炸记【游记】 JA_yichao 比赛and游记and总结游记cspCSP-J
    文章目录前言Day-xx训练Day-26初赛Day-18初赛成绩Day-5Day-1Day0Day1总结前言这次CSP−J(/S)CSP-J(/S)CSP−J(/S)的考试我的发挥非常差，该拿的分都没拿到.写一下自己的训练历程和心得感悟吧！Day-xx训练最近学了一大堆算法，在博客里我都有记录，有点应接不暇，但确实是长见识了，发现自己到现在都还没学入门（菜）Day-26初赛考前和gyx，cxy一直
  • [星球大战]阿纳金的背叛 comsci
          本来杰迪圣殿的长老是不同意让阿纳金接受训练的.........     但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会     所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院    
  • 看懂它，你就可以任性的玩耍了！ aijuans JavaScript
              javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。 function jClass(b
  • Java常用工具包 Jodd Kai_Ge javajodd
    Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小型框架。简单，却很强大！ 写道 Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb Jodd 被分成众多模块，按需选择，其中 工具类模块有： jodd-core    &nb
  • SpringMvc下载 120153216 springMVC
    @RequestMapping(value = WebUrlConstant.DOWNLOAD) public void download(HttpServletRequest request,HttpServletResponse response,String fileName) { OutputStream os = null; InputStream is = null;
  • Python 标准异常总结 2002wmj python
    Python标准异常总结 AssertionError 断言语句（assert）失败 AttributeError 尝试访问未知的对象属性 EOFError 用户输入文件末尾标志EOF（Ctrl+d） FloatingPointError 浮点计算错误 GeneratorExit generator.close()方法被调用的时候 ImportError 导入模块失
  • SQL函数返回临时表结构的数据用于查询 357029540 SQL Server
    这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
  • java 时间格式化 | 比较大小| 时区 个人笔记 7454103 javaeclipsetomcatcMyEclipse
    个人总结！ 不当之处多多包含！ 引用 1.0 如何设置 tomcat 的时区：          位置：(catalina.bat---JAVA_OPTS  下面加上)          set JAVA_OPT
  • 时间获取Clander的用法 adminjun Clander时间
    /**    * 得到几天前的时间    * @param d    * @param day    * @return    */   public static Date getDateBefore(Date d,int day){    Calend
  • JVM初探与设置 aijuans java
    JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
  • SQL中ON和WHERE的区别 avords
    SQL中ON和WHERE的区别   数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。   www.2cto.com   在使用left jion时，on和where条件的区别如下：  1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。 
  • 说说自信 houxinyou 工作生活
    自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗?     无论工作还
  • WEBLOGIC事务超时设置 bijian1013 weblogicjta事务超时
            系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误： 统计数据出错! 原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
  • 两年已过去，再看该如何快速融入新团队 bingyingao java互联网融入架构新团队
    偶得的空闲，翻到了两年前的帖子 该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。     时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
  • 【Spark七十七】Spark分析Nginx和Apache的access.log bit1129 apache
    Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式：   Nginx的access.log解析正则表达式   val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
  • Erlang patch bookjovi erlang
    Totally five patchs committed to erlang otp, just small patchs. IMO, erlang really is a interesting programming language, I really like its concurrency feature. but the functional programming style
  • log4j日志路径中加入日期 bro_feng javalog4j
    要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。 实现方式 log4j: <appender name="serviceLog" class="org.apache.log4j.RollingFileAppender"> <param name="Encoding" v
  • 读《研磨设计模式》-代码笔记-桥接模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html * 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
  • windows7下SVN和Eclipse插件安装 chenyu19891124 eclipse插件
    今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
  • [转帖]工作流引擎设计思路 comsci 设计模式工作应用服务器workflow企业应用
    作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下 ================================================================================= 自开博以来不断有朋友来探讨工作流引擎该如何
  • Linux 查看内存，CPU及硬盘大小的方法 daizj linuxcpu内存硬盘大小
    一、查看CPU信息的命令 [root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id" model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz model name :
  • linux 踢出在线用户 dongwei_6688 linux
    两个步骤： 1.用w命令找到要踢出的用户，比如下面：   [root@localhost ~]# w 18:16:55 up 39 days, 8:27, 3 users, load average: 0.03, 0.03, 0.00 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
  • 放手吧,就像不曾拥有过一样 dcj3sjt126com
    内容提要： 静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
  • php二进制安全的含义 dcj3sjt126com PHP
    PHP里，有string的概念。 string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。 byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。 特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
  • Linux下禁用T440s，X240的一体化触摸板(touchpad) gashero linuxThinkPad触摸板
    自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。   Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。   实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
  • graph_dfs hcx2013 Graph
    package edu.xidian.graph; class MyStack { private final int SIZE = 20; private int[] st; private int top; public MyStack() { st = new int[SIZE]; top = -1; } public void push(i
  • Spring4.1新特性——Spring核心部分及其他 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • 配置HiveServer2的安全策略之自定义用户名密码验证 liyonghui160com
        具体从网上看   http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication   LDAP Authentication using OpenLDAP Setting
  • 一位30多的程序员生涯经验总结 pda158 编程工作生活咨询
    1.客户在接触到产品之后，才会真正明白自己的需求。 　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。 　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。   3.
  • 分布式web服务架构的演变 自由的奴隶 linuxWeb应用服务器互联网
    最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
  • 初探Druid连接池之二——慢SQL日志记录 xingsan_zhang 日志连接池druid慢SQL
    由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。   1.applicationContext.xml中增加如下配置： <bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他