二叉堆的C语言实现

原文链接：http://blog.chinaunix.net/uid-20937170-id-3331263.html

                                    二叉堆的C语言实现               

二叉堆的实现数据结构中如何使用，我任务主要是在操作系统中的任务优先级调度问题，当然也可以用于实现堆排序问题，比如找出数组中的第K个最小值问题，采用二叉堆能够快速的实现，今天我就采用C语言实现了一个简单的二叉堆操作，完成这些数据结构我并不知道能干什么，我就当自己在练习C语言的功底吧。逐步完成自己的代码，希望自己在知识的理解力上有一定的提高。

 

二叉堆是非常有特点的数据结构，可以采用简单的数组就能实现，当然链表的实现也是没有问题的，毕竟是一个二叉树问题，当然可以采用链表实现。采用数组实现时，可以找到两个特别明显的规律：

 

左儿子：L_Son = Parent * 2;

右儿子：R_Son = Parent * 2 + 1;

 

二叉堆是一颗完全填满的树，可能例外的是在底层，底层上的元素是从左到右填入，当然二叉堆可以是基于大值的排序，也可以是基于小值的排列形式，本文采用简单的基于小值的形式。主要完成的操作：1、最小值的删除操作，该操作会删除根节点，然后提升儿子节点来代替根节点，具体的实现过程中通过提升左右儿子中较小的作为父结点，依此提升直到到达最底层，这种实现方式叫做下虑法。2、数据的插入操作，插入操作可能会破坏二叉堆的结构，一般在最底层创建一个空穴，然后比较插入值与空穴父结点的值，如果大于父结点的值，那么直接插入到空穴中，如果小于父结点，则将父结点的值插入到刚创建的空穴中，在父结点所在位置上形成新的父结点，这时候再和父结点的父结点比较，具体操作如上所述，直到找到具体的插入地址。当结点个数为偶数时，在删除操作中需要注意节点是否有右儿子的情况。具体的可以参考代码中的说明。

 

具体的实现如下：

结构体：

点击(此处)折叠或打开

1. #ifndef __BINARYHEAP_H_H_
   
2. #define __BINARYHEAP_H_H_
   
3. 
   
4. #include <stdlib.h>
   
5. #include <assert.h>
   
6. 
   
7. #define bool int
   
8. #define true 1
   
9. #define false 0
   
10. 
    
11. /*打算采用数组的方式实现完全二叉堆*/
    
12. typedef struct _binaryheap
    
13. {
    
14.         /*因为需要动态扩展，
    
15.         *采用静态数组不方便*/
    
16.         int * parray;
    
17.         /*目前存在的结点*/
    
18.         int currentSize;
    
19.         /*树的实际容量*/
    
20.         int capacity;
    
21. }BinaryHeap_t, *BinaryHeap_handle_t;
    
22. 
    
23. #ifdef __cplusplus
    
24. extern "C"
    
25. {
    
26. #endif
    
27. 
    
28. bool init_BinaryHeap(BinaryHeap_handle_t heap, int capacity);
    
29. bool alloc_BinaryHeap(BinaryHeap_handle_t *heap, int capacity);
    
30. void delete_BinaryHeap(BinaryHeap_handle_t heap);
    
31. void free_BinaryHeap(BinaryHeap_handle_t *heap);
    
32. 
    
33. bool insert(BinaryHeap_handle_t heap,int value);
    
34. int deleteMin(BinaryHeap_handle_t heap);
    
35. bool isEmpty(BinaryHeap_handle_t heap);
    
36. 
    
37. #ifdef __cplusplus
    
38. }
    
39. #endif
    
40. 
    
41. #endif

实现的接口函数如下：

点击(此处)折叠或打开

1. #include "binaryheap.h"
   
2. 
   
3. bool isEmpty(BinaryHeap_handle_t heap)
   
4. {
   
5.         assert(heap != NULL);
   
6.         return heap->currentSize == 0;
   
7. }
   
8. 
   
9. bool init_BinaryHeap(BinaryHeap_handle_t heap, int capacity)
   
10. {
    
11.         int *parray = NULL;
    
12. 
    
13.         if(heap == NULL)
    
14.                 return false;
    
15.     
    
16.         parray = (int *)calloc(capacity+1,sizeof(int));
    
17.         if(parray == NULL)
    
18.                 return false; 
    
19.     
    
20.         heap->parray = parray;
    
21.         heap->capacity = capacity;
    
22.         heap->currentSize = 0;
    
23. 
    
24.         return true;
    
25. }
    
26. 
    
27. void delete_BinaryHeap(BinaryHeap_handle_t heap)
    
28. {
    
29.         assert(heap != NULL && heap->parray != NULL);
    
30. 
    
31.         heap->capacity = 0;
    
32.         heap->currentSize = 0;
    
33. 
    
34.         free(heap->parray);
    
35.         heap->parray = NULL;
    
36. }
    
37. 
    
38. void free_BinaryHeap(BinaryHeap_handle_t *heap)
    
39. {
    
40.         assert(*heap != NULL);
    
41. 
    
42.         (*heap)->capacity = 0;
    
43.         (*heap)->currentSize = 0;
    
44. 
    
45.         free((*heap)->parray);
    
46.         (*heap)->parray = NULL;
    
47. 
    
48.         free(*heap);
    
49.         *heap = NULL;
    
50. }
    
51. 
    
52. bool alloc_BinaryHeap(BinaryHeap_handle_t *heap, int capacity)
    
53. {
    
54.         int *parray = NULL;
    
55. 
    
56.         if(*heap != NULL)
    
57.                 return false;
    
58. 
    
59.         *heap = (int *)calloc(1, sizeof(BinaryHeap_t));
    
60.         if(*heap == NULL)
    
61.                 return false;
    
62. 
    
63.         /*其中的1，主要是为了使得数组从下标1开始计算*/
    
64.         parray =(int *)calloc(capacity + 1, sizeof(int));
    
65.         if(parray == NULL)
    
66.                 return false;
    
67. 
    
68.         (*heap)->parray = parray;
    
69.         (*heap)->capacity = capacity;
    
70.         (*heap)->currentSize = 0;
    
71. 
    
72.         return true;
    
73. }
    
74. 
    
75. /**************************************************
    
76.  * 采用上虑法实现数据的插入操作
    
77.  * 上虑法的实现方式比较简单，首先创建一个空节点
    
78.  * 然后将需要插入的值与当前空穴的父结点进行比较
    
79.  * 如果大于父结点，直接插入空穴中
    
80.  * 如果小于父结点的值，则将父结点的值下拉到空穴中
    
81.  * 之前父结点的位置就是空穴，接着与上层比较
    
82.  * 直到找到父结点大于当前插入值的情况
    
83.  **************************************************/
    
84. bool insert(BinaryHeap_handle_t heap, int value)
    
85. {
    
86.         int index = 0;
    
87. 
    
88.         if(heap == NULL || heap->parray == NULL)
    
89.                 return false;
    
90. 
    
91.         /*得到一个新的空穴下标*/
    
92.         index = ++heap->currentSize;
    
93.         /*条件是不是第一个下标和插入值比对应父结点小*/
    
94.         while(index > 1 && value < heap->parray[index/2])
    
95.         {
    
96.                 /*将父结点保存到当前结点处*/
    
97.                 heap->parray[index] = heap->parray[index/2];
    
98.                 /*得到父结点的空穴位置*/
    
99.                 index /= 2;
    
100.         }
     
101.         /*将插入的值保存到剩余的空穴中*/
     
102.         heap->parray[index] = value;
     
103. 
     
104.         return true;
     
105. }
     
106. 
     
107. /***********************************************************
     
108.  * 下虑法实现数据的重排序操作
     
109.  * 实现的方式，将子结点的两个儿子进行比较，将小的提升
     
110.  * 需要注意的是如何让判断节点是否一定存在右儿子
     
111.  * 实现的方式主要是利用了二叉堆的特性:
     
112.  * 2*pare = L_child
     
113.  * 2*pare + 1 = R_child; 
     
114.  ***********************************************************/
     
115. static void presort_BinaryHeap(BinaryHeap_handle_t heap,int hole)
     
116. {
     
117.         /*这是二叉堆的特性*/
     
118.         int child = hole * 2;
     
119.         /*保存当前数据操作*/
     
120.         int tmp = 0;
     
121. 
     
122.         assert(heap != NULL && heap->parray != NULL);
     
123. 
     
124.         tmp = heap->parray[hole];
     
125.         /*hold * 2 <= heap->currentSize 判断了当前结点是否为最低层*/
     
126.         for(; hole * 2 <= heap->currentSize; hole = child)
     
127.         {
     
128.                 child = hole * 2;
     
129. 
     
130.                 /*******************************
     
131.                 *这句代码解决是否存在右结点的问题
     
132.                 *并确定了那个子结点提升的问题
     
133.                 *******************************/
     
134.                 if((child != heap->currentSize)
     
135.                         && (heap->parray[child + 1] < heap->parray[child]))
     
136.                         child ++;
     
137. 
     
138.                 if(heap->parray[child] < tmp)
     
139.                 {
     
140.                         /*将子结点提升为父结点*/
     
141.                        heap->parray[hole] = heap->parray[child];
     
142.                 }
     
143.         }
     
144.         /*到达了最低的层，也就是树叶*/
     
145.         heap->parray[hole] = tmp;
     
146. }
     
147. 
     
148. /*实现数据的下虑法实现数据的删除操作*/
     
149. int deleteMin(BinaryHeap_handle_t heap)
     
150. {
     
151.         int ret = 0;
     
152.         int index = 0;
     
153. 
     
154.         assert(!isEmpty(heap));
     
155.         /*需要返回的值*/
     
156.         ret = heap->parray[1];
     
157. 
     
158.         /*将最后需要释放内存空间的值保存到第一个内存空间中*/
     
159.         heap->parray[1] = heap->parray[heap->currentSize --];
     
160.         /*从表头开始将新的二叉树进行重新排序*/
     
161.         presort_BinaryHeap(heap, 1);
     
162. 
     
163.         return ret;
     
164. }

测试代码：

点击(此处)折叠或打开

1. #include "binaryheap.h"
   
2. #include <stdio.h>
   
3. #include <time.h>
   
4. 
   
5. void print_binaryheap(BinaryHeap_handle_t heap)
   
6. {
   
7.         int i = 0;
   
8. 
   
9.         assert(heap != NULL && heap->parray != NULL);
   
10. 
    
11.         for(i = 1; i <= heap->currentSize; ++ i)
    
12.         {
    
13.                 if(i %6)
    
14.                         printf("%d\t",heap->parray[i]);
    
15.                 else
    
16.                         printf("\n%d\t",heap->parray[i]);
    
17.         }
    
18.         printf("\n");
    
19. }
    
20. 
    
21. int main()
    
22. {
    
23.         int i = 0;
    
24.         int value = 0;
    
25. 
    
26.         srand((int)time(0));
    
27.         printf("********Test Binaryheap**************\n");
    
28. 
    
29.         BinaryHeap_t bheap;
    
30.         BinaryHeap_handle_t *pheap = NULL;
    
31. 
    
32.         printf("init and alloc test:\n");
    
33.         if(init_BinaryHeap(&bheap,10))
    
34.        {
    
35.                 printf("init_BinaryHeap() successed!\n");
    
36.         }
    
37.         if (alloc_BinaryHeap(&pheap,15));
    
38.         {
    
39.                 printf("alloc_BInaryHeap() successed!\n");
    
40.         }
    
41. 
    
42.         printf("***insert test*****\n");
    
43.         for(; i < 10; ++ i)
    
44.         {
    
45.                 if(!insert(&bheap,5 * i - rand()%20))
    
46.                 {
    
47.                         printf("i = %d:insert failed !!\n",i);
    
48.                 }
    
49.         }
    
50.         for(i = 0; i < 15; ++ i)
    
51.         {
    
52.                 if(!insert(pheap,i * 8 - rand()%20))
    
53.                 {
    
54.                         printf("i = %d:insert failed!!\n",i);
    
55.                 }
    
56.         }
    
57. 
    
58.         print_binaryheap(&bheap);
    
59.         print_binaryheap(pheap);
    
60. 
    
61.         printf("****deleteMin test****\n");
    
62.         for(i = 0; i < 5; ++ i)
    
63.         {
    
64.                 value = deleteMin(&bheap);
    
65.                 printf("bheap deleted:%d\n",value);
    
66.                 value = deleteMin(pheap);
    
67.                 printf("pheap deleted:%d\n",value);
    
68.         }
    
69.         print_binaryheap(&bheap);
    
70.         print_binaryheap(pheap);
    
71. 
    
72.         printf("deleteMin test successed\n");
    
73. 
    
74.         printf("****delete and free test:*******\n");
    
75.         delete_BinaryHeap(&bheap);
    
76. 
    
77.         printf("Is the bheap empty ? %s\n",
    
78.                         isEmpty(&bheap)?"Yes":"No");
    
79. 
    
80.         free_BinaryHeap(&pheap);
    
81. 
    
82.         printf("*********Test successed!***********\n");
    
83.         pheap = NULL;
    
84.         return 0;
    
85. }

测试结果：

点击(此处)折叠或打开

1. [gong@Gong-Computer c_binaryheap]$ ./testbinaryheap
   
2. ********Test Binaryheap**************
   
3. init and alloc test:
   
4. init_BinaryHeap() 
   
5. alloc_BInaryHeap() 
   
6. ***insert test*****
   
7. -11    -9    -9    14    15    
   
8. 10    21    23    40    26    
   
9. -16    2    14    20    13    
   
10. 21    33    49    61    67    76    
    
11. 86    83    95    109    
    
12. ****deleteMin test****
    
13. bheap deleted:-11
    
14. pheap deleted:-16
    
15. bheap deleted:-9
    
16. pheap deleted:2
    
17. bheap deleted:-9
    
18. pheap deleted:13
    
19. bheap deleted:10
    
20. pheap deleted:14
    
21. bheap deleted:14
    
22. pheap deleted:20
    
23. 15    23    21    40    26    
    
24. 21    49    21    61    67    
    
25. 76    33    95    83    109    
    
26. deleteMin test successed
    
27. ****delete and free test:*******
    
28. Is the bheap empty ? Yes
    
29. *********Test

从上面的测试结果可知，基本上实现了二叉堆的基本插入、删除操作。代码的关键点在于删除中的下虑和插入过程中的上虑操作。以及如何判断代码是否存在右儿子，如何充分运用二叉堆的特性。