数据结构 队列

队列

（1）队列是一种先进先出的线性表

（2）只能从队头进行删除，从队尾进行插入

 

（一）链队列

（1）需要一个指向头结点的头指针和一个指向尾结点的尾指针

（2）通常为了操作的方便起见，都会给链队添加一个头结点，头结点不存数据。

（3)有头结点的链队列判空的条件是头指针和尾指针都指向头结点

 

 

链队列的实现代码

 

#include<stdio.h>
#include<stdlib.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
#define OK 1
#define ERROR 0
typedef struct QNode
{
    char data;
    struct QNode *next;
}QNode, *QueuePtr;

typedef struct {
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

//创建队列
void InitQueue(LinkQueue *Q)
{ /* 构造一个空队列Q */
    (*Q).front = (*Q).rear = (QueuePtr)malloc(sizeof(QNode));
    if (!(*Q).front) exit(ERROR);
    (*Q).front->next = NULL;
}

//入队
void EnQueue(LinkQueue *Q, char e)
{ /* 插入元素e为Q的新的队尾元素 */
    QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    if (!p)  exit(ERROR);  /* 存储分配失败 */
    p->data = e;        p->next = NULL;
    (*Q).rear->next = p;   (*Q).rear = p;
}

//出队
void DeQueue(LinkQueue *Q, char *e)
{ /* 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR */
    QueuePtr p;
    if ((*Q).front == (*Q).rear)   exit(ERROR); /* 空队列退出 */
    p = (*Q).front->next;
    *e = p->data;
    (*Q).front->next = p->next;
    if ((*Q).rear == p)  (*Q).rear = (*Q).front;
    free(p);
}

//输入队列内容
void printfQueue(LinkQueue Q)
{
    QueuePtr p;
    p = Q.front->next;
    while (p)
    {
        printf("%c  ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main()
{
    LinkQueue Q;
    char e;
    InitQueue(&Q);

    int num, i;
    char a,c;
    printf("输入入队元素个数:\n");
    scanf("%d", &num);
    c = getchar();
    printf("输入入队元素:\n");

    for (i = 0; i < num; i++){
        scanf("%c", &a);
        c = getchar();
        EnQueue(&Q, a);
    }
    printf("队里的元素为：");
    printfQueue(Q);
    printf("出队顺序为：");
    for (i = 0; i < num; i++){
        DeQueue(&Q, &e);
        printf("%c  ",e);
    }
    system("pause");
    return 0;
}

 

循环队列

采用一组地址连续的存储单元依次存放从队头到队尾的元素，并且附加两个指针front和rear分别指向队头和队尾。

（1）无法使用Q.front = Q.rear 来判别队列是“空”还是“满”，如下图，空队列和存满的队列都有Q.front = Q.rear

可以采用少用一个元素空间的存储方式，约定以队列头指针在队列尾指针的下一位置上作为队列呈“满”状态的标志。如图

 判断队列是否为“满” 语句：(Q.rear + 1) % MAX_QSIZE == Q.front   （MAX_QSIZE表示队列容量)

 

实现代码

 

#include<stdio.h>
#include<stdlib.h>
typedef int Status;
#define OK 1
#define ERROR 0
#define MAX_QSIZE 10
typedef struct
{
    char *base; /* 初始化的动态分配存储空间 */
    int front; /* 头指针，若队列不空，指向队列头元素 */
    int rear; /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SqQueue;

//创建循环队列
void InitQueue(SqQueue *Q)
{ /* 构造一个空队列Q */
    (*Q).base = (char *)malloc(MAX_QSIZE*sizeof(int));
    if (!(*Q).base) /* 存储分配失败 */
        exit(ERROR);
    (*Q).front = (*Q).rear = 0;
}

//入队
void EnQueue(SqQueue *Q, int e)
{ /* 插入元素e为Q的新的队尾元素 */
    if (((*Q).rear + 1) % MAX_QSIZE == (*Q).front) /* 队列满 */
        exit(ERROR);;
    (*Q).base[(*Q).rear] = e;
    (*Q).rear = ((*Q).rear + 1) % MAX_QSIZE;
}
//出队
void DeQueue(SqQueue *Q, char *e)
{ /* 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR */
    if ((*Q).front == (*Q).rear) /* 队列空 */
        exit(ERROR);
    *e = (*Q).base[(*Q).front];
    (*Q).front = ((*Q).front + 1) % MAX_QSIZE;
}

//输出队列内容
void printfQueue(SqQueue Q)
{ /* 从队头到队尾依次对队列Q中每个元素输出 */
    int i;
    i = Q.front;
    while (i != Q.rear)
    {
        printf("%3c", Q.base[i]);
        i = (i + 1) % MAX_QSIZE;
    }
    printf("\n");
}

void main()
{
    int  i,num;
    char a,d,c;
    SqQueue Q;
    InitQueue(&Q);
    printf("输入入队元素个数:\n");
    scanf("%d", &num);
    c = getchar();
    printf("输入入队元素:\n");
    for (i = 0; i < num; i++){
        scanf("%c", &a);
        c = getchar();
        EnQueue(&Q, a);
    }
    printf("队里的元素为：");
    printfQueue(Q);
    printf("出队顺序为：");
    for (i = 0; i < num; i++){
        DeQueue(&Q, &d);
        printf("%c  ", d);
    }

    system("pause");
}