【数据结构】队列（8）

队列

（1）链式队列

typedef int ElemType 
struct Node
{
    ElemType data;
    struct Node * pNext;
};
struct LinkQueue
{
    struct Node * front;
    struct Node * rear;
};

//链队列的基本操作（9个）
//1构造一个空队列
void init_queueLink(struct LinkQueue * pLQ)
{
    pLQ->front = pLQ->rear = (struct Node *) malloc(sizeof (struct Node));
    if (!pLQ->front)
        exit(-1);
    pLQ->front->pNext = NULL;
}

//2销毁队列
void destroy_queueLink(struct LinkQueue * pLQ)
{
    while (pLQ->front)
    {
        pLQ->rear = pLQ->front->pNext;
        free(pLQ->front);
        pLQ->front = pLQ->rear;
    }
}

//3清空队列
void clear_queueLink(struct LinkQueue * pLQ)
{
    destroy_queueLink(pLQ);
    init_queueLink(pLQ);
}

//4判断队列是否为空
bool is_emptyLink(struct LinkQueue * pLQ)
{
    if (pLQ->front->pNext == NULL)
        return true;
    else
        return false;
}

//5求队列长度
int queue_lengthLink(struct LinkQueue * pLQ)
{
    int i = 0;
    struct Node * p = pLQ->front;
    while (pLQ->rear != p)
    {
        i++;
        p = p->pNext;
    }
    return i;
}

//6求队列的头元素
bool get_headLink(struct LinkQueue * pLQ, ElemType * val)
{
    struct Node * p;
    if(is_emptyLink(pLQ))
        return false;
    p = pLQ->front->pNext;
    *val = p->data;
    return true;
}

//7入队
void en_queueLink(struct LinkQueue * pLQ, ElemType val)
{
    struct Node * p;
    p = (struct Node *) malloc(sizeof (struct Node));
    if (!p)
        exit(-1);
    p->data = val;
    p->pNext = NULL;
    pLQ->rear->pNext = p;
    pLQ->rear = p;

}

//8出队
bool out_queueLink(struct LinkQueue * pLQ, ElemType * val)
{
    if (is_emptyLink(pLQ))
        return false;
    struct Node * p = pLQ->front->pNext;
    struct Node * q = p->pNext;
    *val = p->data;
    pLQ->front->pNext = q;
    if (pLQ->rear == p)
        pLQ->rear = pLQ->front;
    free(p);

    return true;
}

//9遍历队列
void traverse_queueLink(struct LinkQueue * pLQ)
{
    struct Node * p = pLQ->front->pNext;
    while (p)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");
}

（2）静态队列（循环队列）

typedef int ElemType;
struct Queue
{
    ElemType * pBase;
    ElemType front;
    ElemType rear;
};

//循环队列的基本操作（9个）
//1构造一个空队列
void init_queue(struct Queue * pQ)
{
    pQ->pBase = (ElemType *) malloc(MAX_SIZE * sizeof (ElemType));
    if (!pQ->pBase)
        exit(-1);

    pQ->front = pQ->rear = 0;
}

//2销毁队列
void destroy_queue(struct Queue * pQ)
{
    if (pQ->pBase)
        free(pQ->pBase);
    pQ->pBase = NULL;
    pQ->front = pQ->rear = 0;
}

//3清空队列
void clear_queue(struct Queue * pQ)
{
    pQ->front = pQ->rear = 0;
}

//4判断是否为空
bool is_empty(struct Queue * pQ)
{
    if (pQ->front == pQ->rear)
        return true;
    else
        return false;
}

//5如果队列不为空，用val返回队头元素
bool get_head(struct Queue * pQ, ElemType * val)
{
    if (is_empty(pQ))
        return false;
    *val = pQ->pBase[pQ->front];
    return true;
}

//6入队
bool en_queue(struct Queue * pQ, ElemType val)
{
    if ((pQ->rear + 1) % MAX_SIZE == pQ->front)
        return false;
    pQ->pBase[pQ->rear] = val;
    pQ->rear = (pQ->rear + 1) % MAX_SIZE;
    return true;
}

//7出队
bool out_queue(struct Queue * pQ, ElemType * val)
{
    if (is_empty(pQ))
        return false;
    *val = pQ->pBase[pQ->front];
    pQ->front = (pQ->front + 1) % MAX_SIZE;

    return true;
}

//8返回队列长度
int queue_length(struct Queue * pQ)
{
    int len;
    len = (pQ->rear - pQ->front + MAX_SIZE) % MAX_SIZE;
    return len;
}

//9遍历队列
void traverse_queue(struct Queue * pQ)
{
    ElemType i;
    i = pQ->front;
    while (i != pQ->rear)
    {
        printf("%d ", pQ->pBase[i]);
        i = (i + 1) % MAX_SIZE;
    }
    printf("\n");
}

测试

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
#define MAX_SIZE 6

int main()
{
    struct Queue Q;
    init_queue(&Q);
    en_queue(&Q, 3);
    en_queue(&Q, 6);
    en_queue(&Q, 7);
    en_queue(&Q, 20);
    en_queue(&Q, 32);
    en_queue(&Q, 8);
    traverse_queue(&Q);

    ElemType val;
    out_queue(&Q, &val);
    printf("val = %d\n",val);
    traverse_queue(&Q);

    int len;
    len = queue_length(&Q);
    printf("len = %d\n", len);

    ElemType val_head;
    get_head(&Q, &val_head);
    printf("val_head = %d\n", val_head);

    printf("----------------------------\n");

    struct LinkQueue LQ;
    init_queueLink(&LQ);
    en_queueLink(&LQ, 3);
    en_queueLink(&LQ, 6);
    en_queueLink(&LQ, 7);
    en_queueLink(&LQ, 20);
    en_queueLink(&LQ, 32);
    en_queueLink(&LQ, 8);

    traverse_queueLink(&LQ);

    ElemType valLink;
    out_queueLink(&LQ, &valLink);
    printf("val = %d\n",val);
    traverse_queueLink(&LQ);

    int len_L;
    len_L = queue_lengthLink(&LQ);
    printf("len_L = %d\n", len_L);

    ElemType val_head_L;
    get_headLink(&LQ, &val_head_L);
    printf("val_head_L = %d\n", val_head_L);

    return 0;
}