一.Queue 基本概念

隊列是一種特殊的線性表

隊列僅在線性表的兩端進行操作

隊頭(Front)：取出數據元素的一端

隊尾(Rear)：插入數據元素的一端

隊列不允許在中間部位進行操作！

常用操作

• 銷毀隊列
• 清空隊列
• 進隊列
• 出隊列
• 獲取隊頭元素
• 獲取隊列的長度

二.隊列的順序存儲設計與實現

seqlist.h

#ifndef __MY_SEQLIST_H__
#define __MY_SEQLIST_H__

#define DLL_API  __declspec(dllexport)    //_declspec(dllexport)：導出標誌
 


typedef void SeqList;
typedef void SeqListNode;


// 創建線性表
DLL_API SeqList* SeqList_Create(int capacity);

// 銷毀線性表
DLL_API void SeqList_Destroy(SeqList *list);

// 清空線性表
DLL_API void SeqList_Clear(SeqList *list);

// 獲得線性表的長度
DLL_API int SeqList_Length(SeqList *list);

// 獲得線性表的容量
DLL_API int
 
 SeqList_Capacity(SeqList *list);

// 向線性表中插入一個元素
DLL_API int SeqList_Insert(SeqList *list, SeqListNode *node, int pos);

// 獲取線性表中某一個位置的元素
DLL_API SeqListNode* SeqList_Get(SeqList *list, int pos);

// 刪除線性表中某一個位置的元素
DLL_API SeqListNode* SeqList_Delete(SeqList *list, int pos);



#endif

seqlist.c

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


typedef struct _tag_SeqList
{
    int capacity;
    int length;
    unsigned int *node; // unsigned int array[capacity]
}TSeqList;



// 創建線性表
SeqList* SeqList_Create(int capacity)
{
    TSeqList *ret = NULL;
    if (capacity < 0)
    {
        return NULL;
    }
    ret = malloc(sizeof(TSeqList) + sizeof(unsigned int)*capacity);
    if (ret == NULL)
    {
        return NULL;
    }
    memset(ret, 0, sizeof(TSeqList)+sizeof(unsigned int)*capacity);
    ret->node = (unsigned int *)(ret + 1); // ret 向後跳轉sizeof(TSeqList)
    ret->capacity = capacity;
    ret->length = 0;

    return ret;
}


// 銷毀線性表
void SeqList_Destroy(SeqList *list)
{
    if (list != NULL)
    {
        free(list);
    }

}


// 清空線性表
void SeqList_Clear(SeqList *list)
{
    TSeqList *tList = NULL;
    if (list == NULL)
    {
        return;
    }
    tList = (SeqList*)list;
    tList->length = 0;
}


// 獲得線性表的長度
int SeqList_Length(SeqList *list)
{
    TSeqList *tList = NULL;
    tList = (TSeqList*)list;
    if (tList == NULL)
    {
        return -1;
    }
    return tList->length;
}



// 獲得線性表的容量
int SeqList_Capacity(SeqList *list)
{
    TSeqList *tList = NULL;
    tList = (TSeqList*)list;
    if (tList == NULL)
    {
        return -1;
    }
    return tList->capacity;
}

// 向線性表中插入一個元素
DLL_API int SeqList_Insert(SeqList *list, SeqListNode *node, int pos)
{
    int i = 0;
    TSeqList *tList = NULL;
    tList = (TSeqList*)list;

    // 保證傳入的線性表和元素節點不能為NULL
    if (list == NULL || node == NULL)
    {
        return -1;
    }

    // 判斷該線性表是否已滿
    if (tList->length >= tList->capacity)
    {
        return -2;
    }

    // 判斷插入索引是否合法
    if (pos < 0 || pos >= tList->capacity)
    {
        return -3;
    }

    // 若索引值大於線性表當前長度，則將元素插入到線性表的末尾
    if (pos >= tList->length)
    {
        pos = tList->length;
    }

    // 插入算法
    // 將pos位置後的元素移次向後移
    for (i = tList->length; i > pos; i--)
    {
        // 更新後移元素的值
        tList->node[i] = tList->node[i - 1];
    }

    // 元素後移完畢後，將元素放到指定的位置
    tList->node[pos] = (unsigned int)node;
    tList->length ++;
    return 0;
}



// 獲取線性表中某一個位置的元素
SeqListNode* SeqList_Get(SeqList *list, int pos)
{
    SeqListNode *ret = NULL;
    TSeqList *tList = NULL;
    tList = (TSeqList*)list;
    
    // 過濾非法參數
    if (list == NULL || pos < 0 || pos >= tList->length)
    {
        return NULL;
    }

    ret = (SeqListNode*)tList->node[pos];
    return ret;
}


// 刪除線性表中某一個位置的元素
SeqListNode* SeqList_Delete(SeqList *list, int pos)
{
    int i = 0;
    TSeqList *tList = NULL;
    SeqListNode *ret = NULL;
    tList = (TSeqList*)list;

    if (list == NULL || pos < 0 || pos >= tList->length)
    {
        return NULL;
    }

    ret = (SeqListNode*)tList->node[pos];
    // 刪除算法
    for (i=pos+1; i<tList->length; i++)
    {
        tList->node[i - 1] = tList->node[i];
    }
    tList->length--;

    return ret;
}

seqqueue.h

#ifndef __MY_SEQ_QUEUE_H__
#define __MY_SEQ_QUEUE_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);

// 移除隊列頭部元素
void* SeqQueue_Retrieve(SeqQueue* queue);

// 獲取隊列頭部元素
void* SeqQueue_Header(SeqQueue* header);

// 獲取隊列長度
int SeqQueue_Length(SeqQueue* length);

// 獲取隊列容量
int SeqQueue_Capacity(SeqQueue* queue);



#endif

seqqueue.c

#include "seqqueue.h"
#include "seqlist.h"


// 創建隊列
SeqQueue* SeqQueue_Create(int capacity)
{
    return SeqList_Create(capacity);
}

// 銷毀隊列
void SeqQueue_Destroy(SeqQueue* queue)
{
    SeqList_Destroy(queue);
}

// 清空隊列
void SeqQueue_Clear(SeqQueue* queue)
{
    SeqList_Clear(queue);
}

// 向隊尾添加元素,相當於向線性表的尾部插入元素
int SeqQueue_Append(SeqQueue* queue, void* item)
{
    return SeqList_Insert(queue, item, SeqList_Length(queue));
}


// 移除隊列頭部元素
void* SeqQueue_Retrieve(SeqQueue* queue)
{
    return SeqList_Delete(queue, 0);
}


// 獲取隊列頭部元素
void* SeqQueue_Header(SeqQueue* queue)
{
    return SeqList_Get(queue, 0);
}

// 獲取隊列長度
int SeqQueue_Length(SeqQueue* queue)
{
    return SeqList_Length(queue);
}

// 獲取隊列容量
int SeqQueue_Capacity(SeqQueue* queue)
{
    return SeqList_Capacity(queue);
}

運行結果：

current queue capacity is: 10

current queue length is: 6

current student age is: 12
current new length is: 0
請按任意鍵繼續. . .

5.隊列