最大堆MaxHeap和最小堆MinHeap的实现(转)

       队列的特点是先进先出。通常都把队列比喻成排队买东西，大家都很守秩序，先排队的人就先买东西。

       但是优先队列有所不同，它不遵循先进先出的规则，而是根据队列中元素的优先权，优先权最大的先被取出。通常把优先队列比喻成现实生活中的打印。一个打印店里有很多打印机，每台机器的性能不一样，有的打印机打印很快，有的打印机打印速度很慢。当这些打印机陆陆续续打印完自己的任务时进入排队等候状态。如果我这个时候要打印一份文件，我选的不是第一个排队的打印机，而是性能最好，打印最快的打印机。

       优先队列的特点就是将存储的元素根据其优先权的高低，先取出优先权高的元素。所以，优先队列的实现方法有很多。

       如果优先权的范围是已知的，那么就可以尝试用一个二维数组来实现优先队列。每一行表示一个优先级别。例如用大小为a[10][10]的二维数组来实现一个优先队列，a[0]表示一个优先级别，里面存放优先级为0的元素，a[10]则存放优先级最高的元素。这样根据元素的优先级进行存储，取出元素的时候，根据优先级，先取出优先级最高的元素。

       上面的方法在优先权范围已知且比较集中可以估计的情况下可以适用，但是如果优先权的范围不清楚，或者间隔很大，就不再使用。实现优先队列也可以用一个链表队列加以实现。链表的节点数据包含两个部分，队列的数据项和该数据项的优先权。将元素存入链表，需要用时，遍历链表，查找优先权最大的数据项。

 

优先队列式分支界限法解装载问题中需要用到最大堆MazHeap，但是书上没有给出代码，所以只能我们自己写了，下面我贴出这两个数据结构的代码，以供参考。解决了这两个数据结构，那么优先队列式分支界限法就很好实现了。

最大堆MaxHeap：

 

[cpp]  view plain copy

1. #include<iostream>  
2. using namespace std;  
3. typedef struct Heap  
4. {  
5.     int capacity;  
6.     int size;  
7.     int *Elem;  
8. }Heap,*HeapQueue;  
9. #define MaxData 32767  
10. HeapQueue init(int maxElem)  
11. {  
12.     HeapQueue H;  
13.     H=(HeapQueue)malloc(sizeof(Heap));  
14.     H->capacity=maxElem;  
15.     H->size=0;  
16.     H->Elem=(int *)malloc((maxElem+1)*sizeof(int));  
17.     H->Elem[0]=MaxData;  
18.     return H;  
19. }  
20. void InsertMax(int x,HeapQueue H)  
21. {  
22.     int i;  
23.     for(i=++H->size;H->Elem[i/2]<x;i/=2)  
24.         H->Elem[i]=H->Elem[i/2];//此时i还没有进行i/2操作  
25.     H->Elem[i]=x;  
26. }  
27. int DeleteMax(HeapQueue H)  
28. {  
29.     int i,child;  
30.     int MaxElem,LastElem;           //存储最大元素和最后一个元素。  
31.     MaxElem=H->Elem[1];              //堆是从第1号元素开始的。  
32.     LastElem=H->Elem[ H->size-- ];    //这里自动让size减少了。  
33.     for(i = 1 ; i * 2 <= H->size ; i = child)  
34.     {  
35.         child=i * 2;  
36.         /*在节点有左右子树的时候，可能存在一个大一个小的情况，这时候我们就要找出最小的； 
37.           如果Child = H->Size则表明他没有右子树，这时候就没有必要比较了。 
38.         */  
39.         if(child != H->size && H->Elem[child+1]>H->Elem[child])  
40.             child++;//找最大的子树  
41. // 与 H->Elem[i]=LastElem; 结合，将两个孩子和 lastElement 中较大的放入祖先节点
42.         if(LastElem < H->Elem[child])  
43.             H->Elem[i]=H->Elem[child];
44.     }  
45.     H->Elem[i]=LastElem;  
46.     return MaxElem;  
47. }  
48. void MakeEmpty(HeapQueue H)  
49. {  
50.     H->size=0;  
51. }  
52. int FindMax(HeapQueue H)  
53. {  
54.     return H->Elem[1];  
55. }  
56. void DestoryH(HeapQueue H)  
57. {  
58.     free(H->Elem);  
59.     free(H);  
60. }  
61. int main()  
62. {  
63.       
64.     HeapQueue H=init(4);  
65.     int i;  
66.     for(i=1;i<=3;i++)  
67.         InsertMax(i,H);  
68. /* 
69.     cout<<H->size<<endl; 
70.     for(i=1;i<=3;i++) 
71.         cout<<H->Elem[i]<<endl; 
72. */  
73.     int a=DeleteMax(H);  
74.     cout<<a<<endl;  
75.     return 1;  
76. }  

 

 

最小堆MinHeap：

 

[c-sharp]  view plain copy

1. #include<iostream>  
2. using namespace std;  
3. typedef struct Heap  
4. {  
5.     int capacity;  
6.     int size;  
7.     int *Elem;  
8. }Heap,*HeapQueue;  
9. #define MinData -32767  
10. HeapQueue init(int maxElem)  
11. {  
12.     HeapQueue H;  
13.     H=(HeapQueue)malloc(sizeof(Heap));  
14.     H->capacity=maxElem;  
15.     H->size=0;  
16.     H->Elem=(int *)malloc((maxElem+1)*sizeof(int));  
17.     H->Elem[0]=MinData;  
18.     return H;  
19. }  
20. void Insert(int x,HeapQueue H)  
21. {  
22.     int i;  
23.     for(i=++H->size;H->Elem[i/2]>x;i/=2)  
24.         H->Elem[i]=H->Elem[i/2];//此时i还没有进行i/2操作  
25.     H->Elem[i]=x;  
26. }  
27. int DeleteMin(HeapQueue H)  
28. {  
29.     int i,child;  
30.     int MinElem,LastElem;  
31.     MinElem=H->Elem[1];//堆是从第1号元素开始的。  
32.     LastElem=H->Elem[H->size--];//这里自动让size减少了。  
33.     for(i = 1 ; i * 2 <= H->size ; i = child)  
34.     {  
35.         child=i * 2;  
36.         /*在节点有左右子树的时候，可能存在一个大一个小的情况，这时候我们就要找出最小的； 
37.           如果Child = H->Size则表明他没有右子树，这时候就没有必要比较了。 
38.         */  
39.         if(child != H->size && H->Elem[child+1]<H->Elem[child])  
40.             child++;  
41.         if(LastElem>H->Elem[child])  
42.             H->Elem[i]=H->Elem[child];  
43.     }  
44.     H->Elem[i]=LastElem;  
45.     return MinElem;  
46. }  
47. void MakeEmpty(HeapQueue H)  
48. {  
49.     H->size=0;  
50. }  
51. int FindMin(HeapQueue H)  
52. {  
53.     return H->Elem[1];  
54. }  
55. void DestoryH(HeapQueue H)  
56. {  
57.     free(H->Elem);  
58.     free(H);  
59. }  
60. int main()  
61. {  
62.     /* 
63.     HeapQueue H=init(4); 
64.     int i; 
65.     for(i=1;i<=4;i++) 
66.         Insert(i,H); 
67.     int a=DeleteMin(H); 
68.     cout<<a; 
69.     */  
70. }  

 

 

 

本文参考了http://blog.csdn.net/xw13106209/article/details/4942331