【算法】隊列的C語言實現

/***
*ElemType.h - ElemType的定義
*
****/
 
#ifndef ELEMTYPE_H
#define ELEMTYPE_H
 
typedef int ElemType;
 
int  compare(ElemType x, ElemType y);
void visit(ElemType e);
 
#endif /* ELEMTYPE_H */

/***
*ElemType.cpp - ElemType的實現
*   
****/
 
#include <stdio.h>
#include "ElemType.h"
 
int compare(ElemType x, ElemType y)
{
    return(x-y);
}
 
void visit(ElemType e)
{
    printf("%d\n", e);
}


/***
*DynaLnkQueue.cpp - 動態鏈式隊列，即隊列的動態鏈式存儲實現
*
****/
 
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <assert.h>
#include "DynaLnkQueue.h"
#define NULL 0
 
/*------------------------------------------------------------
操作目的：   初始化隊列
初始條件：   無
操作結果：   構造一個空的隊列
函數參數：
        LinkQueue *Q    待初始化的隊列
返回值：
        bool            操作是否成功
------------------------------------------------------------*/
bool InitQueue(LinkQueue *Q)
{
    Q ->front = Q ->rear = (QueuePtr)malloc(sizeof(QNode));
    if(Q ->front == NULL)
        return false;
    Q ->front ->next = NULL;
    return true;
}
 
/*------------------------------------------------------------
操作目的：   銷燬隊列
初始條件：   隊列Q已存在
操作結果：   銷燬隊列Q
函數參數：
        LinkQueue *Q    待銷燬的隊列
返回值：
        無
------------------------------------------------------------*/
void DestroyQueue(LinkQueue *Q)
{
    assert(Q != NULL);
    while(Q ->front)
    {
        Q ->rear = Q ->front ->next;
        free(Q ->front);
        Q ->front = Q ->rear;
    }
}
 
/*------------------------------------------------------------
操作目的：   判斷隊列是否爲空
初始條件：   隊列Q已存在
操作結果：   若Q爲空隊列，則返回true，否則返回false
函數參數：
        LinkQueue Q     待判斷的隊列
返回值：
        bool            是否爲空
------------------------------------------------------------*/
bool QueueEmpty(LinkQueue Q)
{
    assert(Q.front != NULL && Q.rear != NULL);
    if(Q.front == Q.rear)
        return true;
    else
        return false;
}
/*------------------------------------------------------------
操作目的：   得到隊列的長度
初始條件：   隊列Q已存在
操作結果：   返回Q中數據元素的個數
函數參數：
        LinkQueue Q     隊列Q
返回值：
        int             數據元素的個數
------------------------------------------------------------*/
int QueueLength(LinkQueue Q)
{
    assert(Q.front != NULL);
    QueuePtr p = Q.front;
    int Length = 0;
    while (p != Q.rear)
    {
        Length++;
        p = p->next;
    }
    return Length;
}
/*------------------------------------------------------------
操作目的：   得到隊列首元素
初始條件：   隊列Q已存在
操作結果：   用e返回隊列首元素
函數參數：
        LinkQueue Q     隊列Q
        ElemType *e     隊列首元素的值
返回值：
        bool            操作是否成功
------------------------------------------------------------*/
bool GetHead(LinkQueue Q, ElemType *e)
{
    assert(Q.front != NULL);
    if(QueueEmpty(Q))
        return false;
    else
    {
        *e = Q.front ->next ->data;
        return true;
    }
     
}
/*------------------------------------------------------------
操作目的：   遍歷隊列
初始條件：   隊列Q已存在
操作結果：   依次對Q的每個元素調用函數fp
函數參數：
        LinkQueue Q     隊列Q
        void (*fp)()    訪問每個數據元素的函數指針
返回值：
        無
------------------------------------------------------------*/
void QueueTraverse(LinkQueue Q, void (*fp)(ElemType))
{
    assert(Q.front != NULL);
    QueuePtr p = Q.front ->next;
    while(p)
    {
        (*fp)(p ->data);
        p = p ->next;
    }
}
 
/*------------------------------------------------------------
操作目的：   清空隊列
初始條件：   隊列Q已存在
操作結果：   將隊列清空
函數參數：
        LinkQueue *Q    隊列Q
返回值：
        無
------------------------------------------------------------*/
void ClearQueue(LinkQueue *Q)
{
    assert(Q ->front != NULL);
    QueuePtr p = Q ->front ->next;
    while(p)
    {
        Q ->front ->next = p ->next;
        free(p);
        p = Q ->front ->next;
    }        
}
 
/*------------------------------------------------------------
操作目的：   在隊列末尾插入元素e
初始條件：   隊列Q已存在
操作結果：   插入元素e作爲隊列新的尾結點
函數參數：
        LinkQueue *Q        隊列Q
        ElemType e      待插入的數據元素
返回值：
        bool            操作是否成功
------------------------------------------------------------*/
bool EnQueue(LinkQueue *Q, ElemType e)
{
    QueuePtr temp = (QueuePtr )malloc(sizeof(QNode));
    if(!temp)
        return false;
    temp ->data = e;
    temp ->next = NULL;
    Q->rear ->next = temp;
    Q ->rear = temp;
    return true;
}
 
/*------------------------------------------------------------
操作目的：   刪除鏈式隊列的頭結點
初始條件：   隊列Q已存在
操作結果：   刪除鏈式隊列的頭結點
函數參數：
        LinkQueue *Q        隊列Q
        ElemType *e     待插入的數據元素
返回值：
        bool            操作是否成功
------------------------------------------------------------*/
bool DeQueue(LinkQueue *Q, ElemType *e)
{
    if(Q ->front == Q->rear)
        return false;
    QueuePtr temp = Q->front ->next;
    *e = temp ->data;
    Q ->front ->next= temp ->next;
    if(Q ->rear == temp)
        Q ->rear = Q ->front;
    free(temp);
    return true;
}


/***
*DynaLnkQueue.h - 動態鏈式隊列的定義
*   
****/
 
#if !defined(DYNALNKQUEUE_H)
#define DYNALNKQUEUE_H
 
#include "ElemType.h"
 
/*------------------------------------------------------------
// 鏈式隊列結構的定義
------------------------------------------------------------*/
 
typedef struct Node
{
    ElemType data;              // 元素數據
    struct Node *next;          // 鏈式隊列中結點元素的指針
} QNode, *QueuePtr;
 
typedef struct
{
    QueuePtr front;             // 隊列頭指針
    QueuePtr rear;              // 隊列尾指針
} LinkQueue;
 
/*------------------------------------------------------------
// 鏈式隊列的基本操作
------------------------------------------------------------*/
 
bool InitQueue(LinkQueue *Q);
void DestroyQueue(LinkQueue *Q);
bool QueueEmpty(LinkQueue Q);
int  QueueLength(LinkQueue Q);
bool GetHead(LinkQueue Q, ElemType *e);
void QueueTraverse(LinkQueue Q, void (*fp)(ElemType));
void ClearQueue(LinkQueue *Q);
bool EnQueue(LinkQueue *Q, ElemType e);
bool DeQueue(LinkQueue *Q, ElemType *e);
 
#endif /* DYNALNKQUEUE_H */

#include <stdio.h>
#include <stdlib.h>
#include "DynaLnkQueue.h"
 
int main()
{
    // TODO: Place your test code here
    /*LinkQueue W;
    InitQueue(&W);
    EnQueue(&W,1);
    EnQueue(&W,2);
    QueueTraverse(W,visit);*/
    system("PAUSE");
    return 0;
}