C数据结构-优化顺序队列

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/water_3700348/article/details/78191031

优化顺序队列

如果直接复用之前的顺序表，那么在队列的入队和出队操作里，势必会有一个操作的时间复杂度是O(n)，因为发生了数组元素的挪移操作。下面是优化后的顺序队列，其中使用了一个头位置和一个尾位置来循环的使用数组空间，以达到入队和出队的时间复杂度都是O(1)。

#ifndef OPTSEQQUEUE
#define OPTSEQQUEUE

#ifndef NULL
#define NULL 0
#endif

/* 元素类型 */
typedef int elem_t;

/* 顺序表结构体 */
typedef struct
{
    int length;/* 顺序表长度 */
    int capacity;/* 顺序表的最大容量 */
    int header;/* 头元素的位置 */
    int tail;/* 尾元素的位置 */
    elem_t data[];

}opt_seq_queue;

/**
 * 优化顺序队列初始化
 * @param capacity
 * @return
 */
opt_seq_queue *opt_seq_queue_init(int capacity);

/**
 * 入队
 * @param p 队列指针
 * @return 成功：1，失败：0
 */
int opt_seq_queue_enqueue(opt_seq_queue *p,elem_t *pe);

/**
 * 出队
 * @param p 队列指针
 * @return 返回元素的值
 */
elem_t opt_seq_queue_dequeue(opt_seq_queue *p);

/**
 * 获取对头元素的值
 * @param p 队列指针
 * @return
 */
elem_t opt_seq_queue_header(opt_seq_queue *p);

/**
 * 获取队列长度
 * @param p
 * @return
 */
int opt_seq_queue_length(opt_seq_queue *p);

/**
 * 队列清空
 * @param p
 * @return
 */
int opt_seq_queue_clear(opt_seq_queue *p);

/**
 * 销毁队列
 * @param p
 * @return
 */
int opt_seq_queue_destroy(opt_seq_queue *p);

#endif // OPTSEQQUEUE

#include "OptSeqQueue.h"
#include <malloc.h>

/**
 * 优化顺序队列初始化
 * @param capacity
 * @return
 */
opt_seq_queue *opt_seq_queue_init(int capacity)
{
    opt_seq_queue *plist = (opt_seq_queue *)malloc(sizeof(opt_seq_queue) + sizeof(elem_t) * capacity);

    if(plist)
    {
        plist->length = 0;
        plist->capacity = capacity;
        plist->header = 0;
        plist->tail = 0;
    }

    return plist;
}

/**
 * 入队
 * @param p 队列指针
 * @return 成功：1，失败：0
 */
int opt_seq_queue_enqueue(opt_seq_queue *p,elem_t *pe)
{
    int ret = ((p != NULL) && (pe != NULL) && (p->length + 1 <= p->capacity));

    if(ret)
    {
        p->data[p->tail] = *pe;
        p->tail = (p->tail + 1) % p->capacity;
        p->length++;
    }

    return ret;
}

/**
 * 出队
 * @param p 队列指针
 * @return 返回元素的值
 */
elem_t opt_seq_queue_dequeue(opt_seq_queue *p)
{
    elem_t temp;
    if((p != NULL) && (p->length > 0))
    {
        temp = p->data[p->header];
        p->header = (p->header + 1) % p->capacity;
        p->length--;
    }

    return temp;
}

/**
 * 获取对头元素的值
 * @param p 队列指针
 * @return
 */
elem_t opt_seq_queue_header(opt_seq_queue *p)
{
    elem_t temp;
    if((p != NULL) && (p->length > 0))
    {
        temp = p->data[p->header];
    }

    return temp;
}

/**
 * 获取队列长度
 * @param p
 * @return
 */
int opt_seq_queue_length(opt_seq_queue *p)
{
    int ret = -1;

    if(p != NULL)
    {
        ret = p->length;
    }

    return ret;
}

/**
 * 队列清空
 * @param p
 * @return
 */
int opt_seq_queue_clear(opt_seq_queue *p)
{
    int ret = (p != NULL);

    if(ret)
    {
        p->length = 0;
        p->header = 0;
        p->tail = 0;
    }

    return ret;
}

/**
 * 销毁队列
 * @param p
 * @return
 */
int opt_seq_queue_destroy(opt_seq_queue *p)
{
    int ret = (p != NULL);

    if(ret)
    {
        free(p);
        p = NULL;
    }

    return ret;
}