DLL + heap

#include <stdio.h>
 
int bn;
struct Node
{
    int val;
    Node* prev;
    Node* next;
    Node* alloc(int _val, Node* _prev, Node* _next)
    {
        val = _val;
        prev = _prev;
        next = _next;
 
        if (prev)    prev->next = this;
        if (next)    next->prev = this;
 
        return this;
    }
    void del()
    {
        if (prev)    prev->next = next;
        if (next)    next->prev = prev;
        prev = next = 0;
    }
}buf[10000], *hash[1000], *hash_tail[1000];
 
#define MAX_SIZE 100
 
struct Heap
{
    int val;
    Node* p;
}heap[10000];
 
int heapSize = 0;
 
int heapPush(int value, Node* _p)
{
    if (heapSize + 1 > MAX_SIZE)
    {
        printf("queue is full!");
        return 0;
    }
 
    heap[heapSize].val = value;
    heap[heapSize].p = _p;
 
    int current = heapSize;
    while (current > 0 && heap[current].val < heap[(current - 1) / 2].val)
    {
        int temp_val = heap[(current - 1) / 2].val;
        Node* temp_p = heap[(current - 1) / 2].p;
 
        heap[(current - 1) / 2].val = heap[current].val;
        heap[(current - 1) / 2].p = heap[current].p;
 
        heap[current].val = temp_val;
        heap[current].p = temp_p;
        current = (current - 1) / 2;
    }
 
    heapSize = heapSize + 1;
 
    return 1;
}
 
Node* heapPop(int *value)
{
    if (heapSize <= 0)
    {
        return 0;
    }
 
    *value = heap[0].val;
    Node* ret_p = heap[0].p;
    heapSize = heapSize - 1;
 
    heap[0] = heap[heapSize];
 
    int current = 0;
    while (current * 2 + 1 < heapSize)
    {
        int child;
        if (current * 2 + 2 == heapSize)
        {
            child = current * 2 + 1;
        }
        else
        {
            child = heap[current * 2 + 1].val < heap[current * 2 + 2].val ? current * 2 + 1 : current * 2 + 2;
        }
 
        if (heap[current].val < heap[child].val)
        {
            break;
        }
 
        int temp_val = heap[current].val;
        Node* temp_p = heap[current].p;
 
        heap[current].val = heap[child].val;
        heap[current].p = heap[child].p;
 
        heap[child].val = temp_val;
        heap[child].p = temp_p;
 
        current = child;
    }
    return ret_p;
}
 
int main()
{
    hash[0] = buf[bn++].alloc(0, 0, 0);
    hash_tail[0] = buf[bn++].alloc(0, 0, 0);
    hash[0] = hash_tail[0];
    hash_tail[0]->prev = hash[0];
 
    int arr[5] = { 3, 2, 5, 4, 1 };
 
    for (int i = 0; i < 5; ++i)        {
        buf[bn].alloc(arr[i], hash_tail[0]->prev, hash_tail[0]);
        heapPush(arr[i], &buf[bn]);
        bn++;
    }
 
    for (Node*p = hash[0]->next; p != hash_tail[0]; p = p->next)    {
        printf("val:%d\n", p->val);
    }
 
    int value;
    Node* del_p = heapPop(&value);
    printf("pop %d\n", value);
    del_p->del();
 
 
    for (Node*p = hash[0]->next; p != hash_tail[0]; p = p->next)    {
        printf("val:%d\n", p->val);
    }
 
    del_p = heapPop(&value);
    printf("pop %d\n", value);
    del_p->del();
 
    for (Node*p = hash[0]->next; p != hash_tail[0]; p = p->next)    {
        printf("val:%d\n", p->val);
    }
 
    return 0;
}