堆的C语言实现

在C++中，可以通过std::priority_queue来使用堆。

堆的C语言实现：

heap.c

  1 /** @file heap.c
  2 * @brief 堆,默认为小根堆,即堆顶为最小.
  3 */
  4 #include <stdlib.h> /* for malloc() */
  5 #include <string.h> /* for memcpy() */
  6 typedef int heap_elem_t; // 元素的类型
  7
  8 /**
  9 * @struct
 10 * @brief 堆的结构体
 11 */
 12 typedef struct heap_t
 13 {
 14 　　int size;　　/** 实际元素个数 */
 15 　　int capacity; 　　/** 容量,以元素为单位 */
 16 　　heap_elem_t *elems;　　/** 堆的数组 */
 17 　　int (*cmp)(const heap_elem_t*, const heap_elem_t*);
 18 }heap_t;
 19
 20 /** 元素的比较函数 */
 21 /** 基本类型(如 int, long, float, double)的比较函数 */
 22 int cmp_int(const int *x, const int *y)
 23 {
 24 　　const int sub = *x - *y;
 25 　　if(sub > 0)
 26 　　{
 27 　　　　return 1;
 28 　　}
 29 　　else if(sub < 0)
 30 　　{
 31 　　　　return -1;
 32 　　}
 33 　　else
 34 　　{
 35 　　　　return 0;
 36 　　}
 37 }
 38
 39 /**
 40 * @brief 堆的初始化.
 41 * @param[out] h 堆对象的指针
 42 * @param[out] capacity 初始容量
 43 * @param[in] cmp cmp 比较函数,小于返回-1,等于返回 0
 44 * 大于返回 1,反过来则是大根堆
 45 * @return 成功返回 0,失败返回错误码
 46 */
 47 int heap_init(heap_t *h, const int capacity, int (*cmp)(const heap_elem_t*, const heap_elem_t*))
 48 {
 49 　　h->size = 0;
 50 　　h->capacity = capacity;
 51 　　h->elems = (heap_elem_t*)malloc(capacity * sizeof(heap_elem_t));
 52 　　h->cmp = cmp;
 53 　　return 0;
 54 }
 55
 56 /**
 57 * @brief 释放堆.
 58 * @param[inout] h 堆对象的指针
 59 * @return 成功返回 0,失败返回错误码
 60 */
 61 int heap_uninit(heap_t *h)
 62 {
 63 　　h->size = 0;
 64 　　h->capacity = 0;
 65 　　free(h->elems);
 66 　　h->elems = NULL;
 67 　　h->cmp = NULL;
 68 　　return 0;
 69 }
 70
 71 /**
 72 * @brief 判断堆是否为空.
 73 * @param[in] h 堆对象的指针
 74 * @return 是空,返回 1,否则返回 0
 75 */
 76 int heap_empty(const heap_t *h)
 77 {
 78 　　return h->size == 0;
 79 }
 80
 81 /**
 82 * @brief 获取元素个数.
 83 * @param[in] s 堆对象的指针
 84 * @return 元素个数
 85 */
 86 int heap_size(const heap_t *h)
 87 {
 88 　　return h->size;
 89 }
 90
 91 /*
 92 * @brief 小根堆的自上向下筛选算法.
 93 * @param[in] h 堆对象的指针
 94 * @param[in] start 开始结点
 95 * @return 无
 96 */
 97 void heap_sift_down(const heap_t *h, const int start)
 98 {
 99 　　int i = start;
100 　　int j;
101 　　const heap_elem_t tmp = h->elems[start];
102 　　for(j = 2 * i + 1; j < h->size; j = 2 * j + 1)
103 　　{
104 　　　　if(j < (h->size - 1) && h->cmp(&(h->elems[j]), &(h->elems[j + 1])) > 0)
105 　　　　{
106 　　　　　　j++; /* j 指向两子女中小者 */
107 　　　　}
108 　　　　// tmp <= h->data[j]
109 　　　　if(h->cmp(&tmp, &(h->elems[j])) <= 0)
110 　　　　{
111 　　　　　　break;
112 　　　　}
113 　　　　else
114 　　　　{
115 　　　　　　h->elems[i] = h->elems[j];
116 　　　　　　i = j;
117 　　　　}
118 　　}
119 　　h->elems[i] = tmp;
120 }
121
122 /*
123 * @brief 小根堆的自下向上筛选算法.
124 * @param[in] h 堆对象的指针
125 * @param[in] start 开始结点
126 * @return 无
127 */
128 void heap_sift_up(const heap_t *h, const int start)
129 {
130 　　int j = start;
131 　　int i= (j - 1) / 2;
132 　　const heap_elem_t tmp = h->elems[start];
133 　　
134 　　while(j > 0)
135 　　{
136 　　　　// h->data[i] <= tmp
137 　　　　if(h->cmp(&(h->elems[i]), &tmp) <= 0)
138 　　　　{
139 　　　　　　break;
140 　　　　}
141 　　　　else
142 　　　　{
143 　　　　　　h->elems[j] = h->elems[i];
144 　　　　　　j = i;
145 　　　　　　i = (i - 1) / 2;
146 　　　　}
147 　　}
148 　　h->elems[j] = tmp;
149 }
150
151 /**
152 * @brief 添加一个元素.
153 * @param[in] h 堆对象的指针
154 * @param[in] x 要添加的元素
155 * @return 无
156 */
157 void heap_push(heap_t *h, const heap_elem_t x)
158 {
159 　　if(h->size == h->capacity)
160 　　{
161 　　　　/* 已满,重新分配内存 */
162 　　　　heap_elem_t* tmp = (heap_elem_t*)realloc(h->elems, h->capacity * 2 * sizeof(heap_elem_t));
163 　　　　h->elems = tmp;
164 　　　　h->capacity *= 2;
165 　　}
166 　　h->elems[h->size] = x;
167 　　h->size++;
168 　　heap_sift_up(h, h->size - 1);
169 }
170
171 /**
172 * @brief 弹出堆顶元素.
173 * @param[in] h 堆对象的指针
174 * @return 无
175 */
176 void heap_pop(heap_t *h)
177 {
178 　　h->elems[0] = h->elems[h->size - 1];
179 　　h->size --;
180 　　heap_sift_down(h, 0);
181 }
182
183 /**
184 * @brief 获取堆顶元素.
185 * @param[in] h 堆对象的指针
186 * @return 堆顶元素
187 */
188 heap_elem_t heap_top(const heap_t *h)
189 {
190 　　return h->elems[0];
191 }