C语言实现优先队列

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MinPQSize (10)
#define MinData (-32767)

struct heap
{
    int capacity;
    int size;
    int *elements;
};

typedef struct heap *pri_queue;

pri_queue pri_queue_init(int queue_size);  // 初始化一个优先队列
void push_pri_queue(int val, pri_queue H); // 将元素放入优先队列
int pop_pri_queue(pri_queue H);            // 将优先队列的元素取出
void make_prique_empty(pri_queue H);       // 设置优先队列为空
int find_que_min(pri_queue H);             // 在优先队列里搜索元素
int is_queue_empty(pri_queue H);           // 判断优先队列是不是为空
int is_queue_full(pri_queue H);            // 判断优先队列是不是满
void destroy_queue(pri_queue H);           // 销毁优先队列
void printf_pri_queue(pri_queue H);        // 直接输出整个优先队列的内容



/* 测试优先队列 */
int main(int argc, char **argv)
{
    pri_queue H = pri_queue_init(50);
    int ar[] = {11, 2, 7, 8, 3, 4, 12, 13, 14, 1, 10, 15, 6, 9, 29, 11, 23, 22, 13, 14, 5, 28, 16, 26, 27, 17, 18, 12, 20, 21, 31, 30, 24, 25, 19};
    int i;

    for (i = 0; i < sizeof(ar) / sizeof(int); i++)
        push_pri_queue(ar[i], H);

    printf_pri_queue(H);

    printf("\n测试pop_pri_queue():\n");
    for (i = 0; i < sizeof(ar) / sizeof(int); i++)
    {
        printf("%d ", pop_pri_queue(H));
    }
    printf("\n\n");

    return 0;
}


// 初始化一个优先队列
pri_queue pri_queue_init(int queue_size)
{
    pri_queue H;

    if (queue_size < MinPQSize)
        exit(EXIT_FAILURE);

    H = (pri_queue)calloc(1, sizeof(struct heap));
    if (H == NULL)
        exit(EXIT_FAILURE);

    H->elements = (pri_queue)calloc(1, (queue_size + 1) * sizeof(int));
    if (H->elements == NULL)
        exit(EXIT_FAILURE);

    H->capacity = queue_size;
    H->size = 0;
    H->elements[0] = MinData;

    return H;
}

// 将元素放入优先队列
void push_pri_queue(int val, pri_queue H)
{
    int i;

    if (is_queue_full(H))
        return;

    for (i = ++H->size; H->elements[i / 2] > val; i /= 2)
        H->elements[i] = H->elements[i / 2];

    H->elements[i] = val;
}

// 将优先队列的元素取出
int pop_pri_queue(pri_queue H)
{
    int i, child;
    int min, last;

    if (is_queue_empty(H))
        return H->elements[0];

    min = H->elements[1];
    last = H->elements[H->size--];

    for (i = 1; i * 2 <= H->size; i = child)
    {
        child = i * 2;

        if (child != H->size && H->elements[child + 1] < H->elements[child])
            child++;

        if (last > H->elements[child])
            H->elements[i] = H->elements[child];
        else
            break;
    }

    H->elements[i] = last;

    return min;
}

// 设置优先队列为空
void make_prique_empty(pri_queue H)
{
    H->size = 0;
}

// 在优先队列里搜索元素
int find_que_min(pri_queue H)
{
    if (!is_queue_empty(H))
        return H->elements[1];

    printf("queue empty\n");
    return H->elements[0];
}

// 判断优先队列是不是为空
int is_queue_empty(pri_queue H)
{
    return (H->size == 0);
}

// 判断优先队列是不是满
int is_queue_full(pri_queue H)
{
    return (H->size == H->capacity);
}

// 销毁优先队列
void destroy_queue(pri_queue H)
{
    free(H->elements);
    H->elements = NULL;
    free(H);
    H = NULL;
}

void printf_pri_queue(pri_queue H)
{
    int i = 0;

    printf("\n直接输出优先队列的内容：\n");

    for (i = 1; i <= H->size; i++)
        printf("%d ", H->elements[i]);

    printf("\n\n");
}