数据结构之链式队列（优化版）

前面我们实现了链式队列，总的来说跟链式栈区别不大，同顺序队列一样，

链式队列也存在着效率问题，所以今天我实现了下它的升级版。

第十一个例子，链式队列升级版的实现：

头文件

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

typedef void LinkQueue;

LinkQueue* LinkQueue_Create();

void LinkQueue_Destroy(LinkQueue* queue);

void LinkQueue_Clear(LinkQueue* queue);

int LinkQueue_Length(LinkQueue* queue);

int LinkQueue_Append(LinkQueue* queue, void* item);

void* LinkQueue_Retrieve(LinkQueue* queue);

void* LinkQueue_Header(LinkQueue* queue);

#endif

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

实现文件

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

typedef struct tag_LinkQueueNode TLinkQueueNode;
struct tag_LinkQueueNode
{
    TLinkQueueNode* next;
    void* item;
};

typedef struct tag_LinkQueue
{
    TLinkQueueNode* front;
    TLinkQueueNode* rear; 
    int length;
}TLinkQueue;

LinkQueue* LinkQueue_Create()
{
    TLinkQueue* ret = (TLinkQueue*)malloc(sizeof(TLinkQueue));
    
    if (ret != NULL)
    {
       ret->front = NULL;
       ret->rear = NULL;
       ret->length = 0;
    }
    
    return (LinkQueue*)ret;
}

void LinkQueue_Destroy(LinkQueue* queue)
{
    LinkQueue_Clear(queue);
    free(queue);         
}

void LinkQueue_Clear(LinkQueue* queue)
{
    while (LinkQueue_Length(queue) > 0)
    {
        LinkQueue_Retrieve(queue);
    }
}

int LinkQueue_Length(LinkQueue* queue)
{
    TLinkQueue* sQueue = (TLinkQueue*)queue;
    int ret = -1;
    
    if (sQueue != NULL)
    {
        ret = sQueue->length;
    }
    
    return ret;  
}

int LinkQueue_Append(LinkQueue* queue, void* item)
{
    TLinkQueue* sQueue = (TLinkQueue*)queue;
    TLinkQueueNode* node = (TLinkQueueNode*)malloc(sizeof(TLinkQueueNode));
    int ret = -1;
    
    if (node != NULL)
    {
        ret = (sQueue != NULL) && (item != NULL);
        
        if (ret)
        {
            node->item = item;
            
            if (sQueue->length > 0)
            {
                sQueue->rear->next = node;
                sQueue->rear = node;
                node->next = NULL;
            }
            else
            {
                sQueue->front = node;
                sQueue->rear = node;
                node->next = NULL;
            }
                
            sQueue->length++;
        }
        else
        {
            free(node);
        }
    }

    return ret;     
}

void* LinkQueue_Retrieve(LinkQueue* queue)
{
    TLinkQueue* sQueue = (TLinkQueue*)queue;
    TLinkQueueNode* node = NULL;
    void* ret = NULL;
    
    if ((sQueue != NULL) && (sQueue->length > 0))
    {
        node = sQueue->front;
        sQueue->front = node->next;  
        ret = node->item;
        free(node);
        
        sQueue->length--;
        
        if (sQueue->length == 0)
        {
            sQueue->front = NULL;
            sQueue->rear = NULL;
        }
    }
    
    return ret;     
}

void* LinkQueue_Header(LinkQueue* queue)
{
    TLinkQueue* sQueue = (TLinkQueue*)queue;
    void* ret = NULL;
    
    if ((sQueue != NULL) && (sQueue->length > 0))
    {
        ret = sQueue->front->item;
    }
    
    return ret;     
}

跟顺序队列的优化版很想吧！只不过把编号操作改成了一前一后2个指针。

测试文件

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

int main(int argc, char *argv[])  
{  
    LinkQueue* queue = LinkQueue_Create();  
    int a[10] = {0};  
    int i = 0;  
      
    for (i = 0; i < 10; i++)  
    {  
        a[i] = i + 1;  
          
        LinkQueue_Append(queue, a + i);      
    }  
      
    printf("length:%d\n", LinkQueue_Length(queue));  
    printf("header:%d\n", *((int*)LinkQueue_Header(queue)));  
      
    while (LinkQueue_Length(queue) > 0)  
    {  
        printf("retrieve:%d\n", *((int*)LinkQueue_Retrieve(queue)));        
    }  
      
    LinkQueue_Clear(queue);  
    LinkQueue_Destroy(queue);  
       
    system("PAUSE");      
    return 0;  
}  

测试文件跟前一版本一模一样，所以可以对比着看看，结果都一样的。