数据结构(C语言版)严蔚敏-＞队列的顺序存储(循环队列)和链式存储

Posted 2023-03-06 坚持不懈的大白

1. 队列的顺序存储

1.1 队列的顺序存储结构：

#define MaxSize 50 // 定义队列中的元素的最大个数
typedef struct
	ElemType data[MaxSize];
	int front,rear; // 对头指针和队尾指针
SqQueue;

1.2 队列的初始状态、进队操作及出队操作

• 初始状态：Q.front = Q.rear = 0;
• 进队操作：队列不满时，先送值到队尾元素，再将队尾指针加1；
• 出队操作：队列不空时，先取对头元素值，再将对头指针加1；

【注】：队列为空时，有Q.front==Q.rear=0成立；不能用Q.rear = MaxSize 来队列已满。

1.3 循环队列

把存储队列元素的表从逻辑上视为一个环，称为循环队列。

• 初始状态：Q.front = Q.rear = 0
• 入队操作后队尾指针进1：Q.rear =(Q.rear+1)%MaxSize;
• 出队操作后对头指针进1：Q.front = (Q.front+1)%MaxSize;
• 队列长度：(Q.rear-Q.front+MaxSize)%MaxSize;

【注】：队列为空的条件是Q.front = Q.rear;若入队元素的速度快于出队元素的速度，则队尾指针很快就追上了对头指针，此时对满时也有Q.front = Q.rear，为了区分对空还是对满，有如下3中处理方式。

• 牺牲一个单元来区分对空还是对满，入队时少用一个队列单元。
  • 对满的条件为:(Q.rear+1)%MaxSize == Q.front;
  • 对空的条件为：Q.front == Q.rear
  • 队列中元素个数：(Q.rear-Q.front+MaxSize)%MaxSize
• 类型中增设表示元素个数的数据成员。这样对空条件为Q.size == 0,对满条件为Q.size==MaxSize。
  • 此时队列的结构如下：

#define MaxSize 50 // 定义队列中的元素的最大个数
typedef struct
	ElemType data[MaxSize];
	int front,rear; // 对头指针和队尾指针
	int size;
SqQueue;

• 类型中增设tag数据成员，以区分对满还是对空。tag等于0时，若因删除导致Q.front==Q.rear,则为对空；tag等于1时，若因插入导致Q.front = Q.rear,则为对满。
  • 此时队列的结构如下：

#define MaxSize 50 // 定义队列中的元素的最大个数
typedef struct
	ElemType data[MaxSize];
	int front,rear; // 对头指针和队尾指针
	int tag;
SqQueue;

其实就是初始化时Q.tag=0，当执行入队操作时，Q.tag赋值为1，当执行出队操作时，Q.tag赋值为0.

2. 队列的链式存储

linkqueue.h

#ifndef LINKQUEUE_H_INCLUDED
#define LINKQUEUE_H_INCLUDED

typedef int ElemType;

typedef struct LinkNode
    ElemType data;
    struct LinkNode *next;
LinkNode;

typedef struct
    LinkNode *front2,*rear;
LinkQueue;


void InitQueue(LinkQueue &Q);
// 初始化队列
bool QueueEmpty(LinkQueue Q);
// 判断队列是否为空
bool EnQueue(LinkQueue &Q,ElemType e);
// 入队操作
bool DeQueue(LinkQueue &Q,ElemType &e);
// 出队操作
bool GetHead(LinkQueue Q,ElemType &e);
//获取队头元素
int QueueLength(LinkQueue Q);
//获取队列长度
#endif // LINKQUEUE_H_INCLUDED

linkqueue.cpp

#include <stdlib.h>
#include "linkqueue.h"

// 带头节点
void InitQueue(LinkQueue &Q)
    Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
    if(!Q.rear)
        exit(-1);
    // 分配资源失败
    Q.front2=Q.rear;
    Q.front2->next = NULL;

// 初始化队列
bool QueueEmpty(LinkQueue Q)
    return Q.front2 == Q.rear;

// 判断队列是否为空
bool EnQueue(LinkQueue &Q,ElemType e)
    LinkNode *p = (LinkNode *)malloc(sizeof(LinkNode));
    if(!p)
        exit(-1);
    // 资源分配失败
    p->data = e;
    p->next = NULL;
    // 创建新节点，插入到链尾
    Q.rear->next = p;
    Q.rear = p;
    return false;

// 入队操作
bool DeQueue(LinkQueue &Q,ElemType &e)
    if(QueueEmpty(Q))
        return false;
    // 如果队列已经为空
    LinkNode *p = Q.front2->next;
    // p节点才是出队的节点
    e = p->data;
    Q.front2->next = p->next;
    if(Q.rear == p)
        Q.rear = Q.front2;
    // 原队列中只有一个节点，删除后变空
    free(p);
    return true;

// 出队操作
bool GetHead(LinkQueue Q,ElemType &e)
    if(QueueEmpty(Q))
        return false;
    e = Q.front2->next->data;
    return true;

//获取队头元素
int QueueLength(LinkQueue Q)
    LinkNode *p = Q.front2->next;
    int i = 0;
    while(p)
        ++i;
        p = p->next;
    
    return i;

//获取队列长度

main.cpp

#include <stdio.h>
#include "linkqueue.h"

int main()

    LinkQueue Q;
    InitQueue(Q);
    int a[] =1,2,3,4,5,6,7,8,9,10;
    int e;
    for(int i=0;i<10;i++)
        EnQueue(Q,a[i]);
    GetHead(Q,e);
    printf("The head node element of the queue is %d\\n",e);
    int q_len = QueueLength(Q);
    printf("The length of the queue is %d\\n",q_len);
    while(!QueueEmpty(Q))
        DeQueue(Q,e);
        printf("%d\\t",e);
    
    printf("\\n");
    return 0;

运行结果：