最小堆

最小堆：是指根节点的关键字值是堆中的最小关键字值，且每个节点若有儿子节点，其关键字值都不大于其儿子节点的关键字值

最小堆的插入操作

   步骤：

1. 把待增加的节点编号 i 设置为已知堆的总节点数加 1 即 i=++(*n)，因此，新增的元素放在最下一层作为新的叶子节点。求出节点 i 的父节点 parent=i/2; 判断是否为空堆，并比较所插入元素与父节点关键字值的大小；
2. 若所插入节点关键字值小于父节点关键字值即item>heap[parent],则把父节点向下移,并把父节点作为当前节点，依次求父节点，即依次沿着树枝向上延伸直到根节点；
3. 把元素item插入到正确位置；

最小堆的删除操作

步骤：   

首先删除根节点，并把最后一个节点临时作为新的根节点，将新的根节点作为当前节点与其孩子节点中最小的关键值节点进行比较，若大于其孩子节点的关键值，则与其孩子节点进行交换位置，并把新位置作为当前节点继续与其孩子节点进行比较，一直延伸下去，直到没有孩子节点为止；

libevent中最小堆的实现

typedef struct min_heap
{
struct event** p;
unsigned n, a;
} min_heap_t;


static inline void     min_heap_ctor_(min_heap_t* s);
static inline void     min_heap_dtor_(min_heap_t* s);
static inline void     min_heap_elem_init_(struct event* e);
static inline int     min_heap_elt_is_top_(const struct event *e);
static inline int     min_heap_empty_(min_heap_t* s);
static inline unsigned     min_heap_size_(min_heap_t* s);
static inline struct event*  min_heap_top_(min_heap_t* s);
static inline int     min_heap_reserve_(min_heap_t* s, unsigned n);
static inline int     min_heap_push_(min_heap_t* s, struct event* e);
static inline struct event*  min_heap_pop_(min_heap_t* s);
static inline int     min_heap_adjust_(min_heap_t *s, struct event* e);
static inline int     min_heap_erase_(min_heap_t* s, struct event* e);
static inline void     min_heap_shift_up_(min_heap_t* s, unsigned hole_index, struct event* e);
static inline void     min_heap_shift_up_unconditional_(min_heap_t* s, unsigned hole_index, struct event* e);
static inline void     min_heap_shift_down_(min_heap_t* s, unsigned hole_index, struct event* e);


#define min_heap_elem_greater(a, b) \
(evutil_timercmp(&(a)->ev_timeout, &(b)->ev_timeout, >))


void min_heap_ctor_(min_heap_t* s) { s->p = 0; s->n = 0; s->a = 0; }
void min_heap_dtor_(min_heap_t* s) { if (s->p) mm_free(s->p); }
void min_heap_elem_init_(struct event* e) { e->ev_timeout_pos.min_heap_idx = -1; }
int min_heap_empty_(min_heap_t* s) { return 0u == s->n; }
unsigned min_heap_size_(min_heap_t* s) { return s->n; }
struct event* min_heap_top_(min_heap_t* s) { return s->n ? *s->p : 0; }


int min_heap_push_(min_heap_t* s, struct event* e)
{
if (min_heap_reserve_(s, s->n + 1))
return -1;
min_heap_shift_up_(s, s->n++, e);
return 0;
}


struct event* min_heap_pop_(min_heap_t* s)
{
if (s->n)
{
struct event* e = *s->p;
min_heap_shift_down_(s, 0u, s->p[--s->n]);
e->ev_timeout_pos.min_heap_idx = -1;
return e;
}
return 0;
}


int min_heap_elt_is_top_(const struct event *e)
{
return e->ev_timeout_pos.min_heap_idx == 0;
}


int min_heap_erase_(min_heap_t* s, struct event* e)
{
if (-1 != e->ev_timeout_pos.min_heap_idx)
{
struct event *last = s->p[--s->n];
unsigned parent = (e->ev_timeout_pos.min_heap_idx - 1) / 2;
/* we replace e with the last element in the heap.  We might need to
  shift it upward if it is less than its parent, or downward if it is
  greater than one or both its children. Since the children are known
  to be less than the parent, it can't need to shift both up and
  down. */
if (e->ev_timeout_pos.min_heap_idx > 0 && min_heap_elem_greater(s->p[parent], last))
min_heap_shift_up_unconditional_(s, e->ev_timeout_pos.min_heap_idx, last);
else
min_heap_shift_down_(s, e->ev_timeout_pos.min_heap_idx, last);
e->ev_timeout_pos.min_heap_idx = -1;
return 0;
}
return -1;
}


int min_heap_adjust_(min_heap_t *s, struct event *e)
{
if (-1 == e->ev_timeout_pos.min_heap_idx) {
return min_heap_push_(s, e);
} else {
unsigned parent = (e->ev_timeout_pos.min_heap_idx - 1) / 2;
/* The position of e has changed; we shift it up or down
* as needed.  We can't need to do both. */
if (e->ev_timeout_pos.min_heap_idx > 0 && min_heap_elem_greater(s->p[parent], e))
min_heap_shift_up_unconditional_(s, e->ev_timeout_pos.min_heap_idx, e);
else
min_heap_shift_down_(s, e->ev_timeout_pos.min_heap_idx, e);
return 0;
}
}


int min_heap_reserve_(min_heap_t* s, unsigned n)
{
if (s->a < n)
{
struct event** p;
unsigned a = s->a ? s->a * 2 : 8;
if (a < n)
a = n;
if (!(p = (struct event**)mm_realloc(s->p, a * sizeof *p)))
return -1;
s->p = p;
s->a = a;
}
return 0;
}


void min_heap_shift_up_unconditional_(min_heap_t* s, unsigned hole_index, struct event* e)
{
    unsigned parent = (hole_index - 1) / 2;
    do
    {
(s->p[hole_index] = s->p[parent])->ev_timeout_pos.min_heap_idx = hole_index;
hole_index = parent;
parent = (hole_index - 1) / 2;
    } while (hole_index && min_heap_elem_greater(s->p[parent], e));
    (s->p[hole_index] = e)->ev_timeout_pos.min_heap_idx = hole_index;
}


void min_heap_shift_up_(min_heap_t* s, unsigned hole_index, struct event* e)
{
    unsigned parent = (hole_index - 1) / 2;
    while (hole_index && min_heap_elem_greater(s->p[parent], e))
    {
(s->p[hole_index] = s->p[parent])->ev_timeout_pos.min_heap_idx = hole_index;
hole_index = parent;
parent = (hole_index - 1) / 2;
    }
    (s->p[hole_index] = e)->ev_timeout_pos.min_heap_idx = hole_index;
}


void min_heap_shift_down_(min_heap_t* s, unsigned hole_index, struct event* e)