数据结构之顺序队列（优化版）

上一篇文章我说了顺序队列的不足之处是常用的Append操作时间复杂度是O(n),

所以我们下面就把它优化成O(1)，闲话少说直接上代码。  

第九个例子，顺序队列优化版的实现：

头文件

#ifndef _SEQQUEUE_H_
#define _SEQQUEUE_H_

typedef void SeqQueue;

SeqQueue* SeqQueue_Create(int capacity);

void SeqQueue_Destroy(SeqQueue* queue);

void SeqQueue_Clear(SeqQueue* queue);

int SeqQueue_Append(SeqQueue* queue, void* item);

int SeqQueue_Length(SeqQueue* queue);

int SeqQueue_Capacity(SeqQueue* queue);

void* SeqQueue_Retrieve(SeqQueue* queue);

void* SeqQueue_Header(SeqQueue* queue);

#endif

我个人有点小小的强迫症，代码尽量要求简洁，所以没有注释，有什么不明白的可以留言。

实现文件

#include <stdio.h>
#include <malloc.h>
#include "SeqQueue.h"

typedef unsigned int TSeqQueueNode;
typedef struct tag_SeqQueue
{
    int length;
    int capacity;
    int front;
    int rear;
    TSeqQueueNode* node;        
} TSeqQueue;

SeqQueue* SeqQueue_Create(int capacity)
{        
    TSeqQueue* ret = NULL;
    
    if (capacity >= 0)
    {
        ret = (TSeqQueue*)malloc(sizeof(TSeqQueue) + sizeof(TSeqQueueNode) * capacity);
    }
    if (ret)
    {
        ret->capacity = capacity;
        ret->length = 0;
        ret->front = 0;
        ret->rear = 0;
        ret->node = (TSeqQueueNode*)(ret + 1);
    }
    
    return ret;
}

void SeqQueue_Destroy(SeqQueue* queue)
{
    free(queue);
}

void SeqQueue_Clear(SeqQueue* queue)
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    
    if (sQueue != NULL)
    {
        sQueue->length = 0;
        sQueue->front = 0;
        sQueue->rear = 0;
    }
}

int SeqQueue_Append(SeqQueue* queue, void* item)
{  
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    int ret = (sQueue != NULL) && (item != NULL);
    ret = ret && ((sQueue->length + 1) <= sQueue->capacity);
    
    if (ret)
    {
        sQueue->node[sQueue->rear] = (TSeqQueueNode)item;
        sQueue->rear = (sQueue->rear + 1) % sQueue->capacity;     
        sQueue->length++;
    }
    
    return ret;  
}

int SeqQueue_Length(SeqQueue* queue)
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    int ret = -1;
    
    if (sQueue != NULL)
    {
        ret = sQueue->length;
    }
    
    return ret;
}

int SeqQueue_Capacity(SeqQueue* queue)
{   
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    int ret = -1;
    
    if (sQueue != NULL)
    {
        ret = sQueue->capacity;
    }
    
    return ret;
}

void* SeqQueue_Retrieve(SeqQueue* queue)
{  
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    void* ret = SeqQueue_Header(queue);
    
    if (ret)
    {
        sQueue->front = (sQueue->front + 1) % sQueue->capacity;
        sQueue->length--;
    }
    
    return ret;
}

void* SeqQueue_Header(SeqQueue* queue)
{
    TSeqQueue* sQueue = (TSeqQueue*)queue;
    void* ret = NULL;
    
    if ((sQueue != NULL) && (sQueue->length > 0))
    {
        ret = (void*)sQueue->node[sQueue->front];
    }
    
    return ret;
}

跟顺序表实现差不多吧！！！其实数据结构很多东西都是通用的。

#include <stdio.h>
#include <stdlib.h>
#include "SeqQueue.h"

int main(int argc, char *argv[])
{
    SeqQueue* queue = SeqQueue_Create(20);
    int a[10] = {0};
    int i = 0;
    
    for (i = 0; i < 10; i++)
    {
        a[i] = i + 1;
        
        SeqQueue_Append(queue, a + i);    
    }
    
    printf("capacity:%d\n", SeqQueue_Capacity(queue));
    printf("length:%d\n", SeqQueue_Length(queue));
    printf("header:%d\n", *((int*)SeqQueue_Header(queue)));
    
    while (SeqQueue_Length(queue) > 0)
    {
        printf("retrieve:%d\n", *((int*)SeqQueue_Retrieve(queue)));      
    }
    
    SeqQueue_Clear(queue);
    SeqQueue_Destroy(queue);
     
    system("PAUSE");	
    return 0;
}

测试文件跟上一个版本的一样，原封不动，测试的结果跟上一个版本的结果一样，

唯一的区别就是代码的效率提高了。