考研《循环队列的代码实现》 rear指针指向队列元素的后一个位置的三种判断队列为空为满的方法

rear指针指向队尾元素的后一个位置

声明：为了快速检测，我并没有去写获取队列元素的函数，而是直接偷懒写了遍历的操作，此操作并没有在王道书中指明，所以，大家不要去借鉴循环打印的那两个函数。感谢。

A. 判断为空或者满了的方法：牺牲一个存储单元：

代码如下

//
//  SqQueue.cpp
//  Third
//
//  Created by Jeffery on 2024/3/27.
//

#include <stdio.h>
#include <iostream>

#define MaxSize 10

using namespace std;

typedef int ElemType;

typedef struct {
    ElemType data[MaxSize];
    int front;
    int rear;
}SqQueue;


/*
 1. rear 指向队尾元素的后一个位置 (也就是插入元素的下一个位置）
 a. 牺牲一个存储单元的写法：
 */

// 初始化
void InitQueueA(SqQueue &Q){
    Q.rear = Q.front = 0;
}

// 判断队列满
bool IsFullQueueA(SqQueue Q){
    if ((Q.rear + 1) % MaxSize == Q.front) return true;
    else return false;
}

// 判断队列是否为空
bool IsEmptyQueueA(SqQueue Q){
    if (Q.front == Q.rear) return true;
    else return false;
}

// 入队
bool InQueueA(SqQueue &Q, ElemType x){
    if(IsFullQueueA(Q)) return false;

    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MaxSize;
    return true;
}

// 出队
bool OutQueueA(SqQueue &Q, ElemType &x){
    if(IsEmptyQueueA(Q)) return false;
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    return true;
}

// 计算队列长度
int LengthQueueA(SqQueue Q){
    int length = (Q.rear + MaxSize - Q.front) % MaxSize;
    return length;
}

// ********************************************************************************

    

// 打印队列
void PrintQueue(SqQueue Q){
    for (int i = Q.front; i < Q.rear; i ++) {
        printf("%d，", Q.data[i]);
    }
    printf("\n");
}
int main(int argc, const char * argv[]) {
    SqQueue Q;
    int x;
    InitQueueA(Q);
    InQueueA(Q, 1);
    InQueueA(Q, 2);
    InQueueA(Q, 3);
    InQueueA(Q, 4);
    
    PrintQueue(Q);
    OutQueueA(Q, x);
    printf("-----出一个之后----------\n");
    PrintQueue(Q);
    printf("-----计算长度:-----------\n");
    int length = LengthQueueA(Q);
    printf("length = %d", length);
    printf("\n");
    
    
    return 0;
}

A. 判断为空或者满了的方法：用一个变量size记录当前队列的长度

代码：

#include <stdio.h>
#include <iostream>

#define MaxSize 10

using namespace std;

typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];
    int front;
    int rear;
    int size; //记录队列长度
}SqQueue;

void InitQueueB(SqQueue &Q){
    Q.rear = Q.front = 0;
    Q.size = 0;
}

//判断队列是否为满
bool IsFullQueueB(SqQueue Q){
    if (Q.size == MaxSize) return true;
    else return false;
}

// 判断队列是否为空
bool IsEmptyQueueB(SqQueue Q){
    if (Q.size == 0) return true;
    else return false;
}

// 入队
bool InQueueB(SqQueue &Q, ElemType x){
    if (IsFullQueueB(Q)) {
        printf("队列满了！没法加了.");
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MaxSize;
    Q.size ++;
    return true;
}

// 出队
bool OutQueueB(SqQueue &Q, ElemType &x){
    if (IsEmptyQueueB(Q)){
        printf("队列空啦！没有办法出队了.");
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    Q.size --;
    return true;
}

// 计算队列长度
int LengthQueueB(SqQueue Q){
    return Q.size;
}


// 打印没有满的队列
void PrintQueue(SqQueue Q){
    for (int i = Q.front; i <= Q.rear; i ++) {
        printf("%d，", Q.data[i]);
    }
    printf("\n");
}

// 打印满了的队列
void PrintFullQueue(SqQueue Q){
    for (int i = 0; i <= MaxSize - 1; i ++) {
        printf("%d，", Q.data[i]);
    }
    printf("\n");
}
int main(int argc, const char * argv[]) {
    SqQueue Q;
    InitQueueB(Q);
    InQueueB(Q, 1);
    InQueueB(Q, 2);
    InQueueB(Q, 3);
    InQueueB(Q, 4);
    InQueueB(Q, 5);
//    InQueueB(Q, 6);
    int length = LengthQueueB(Q);
//    printf("length = %d", length);
//    printf("Q.size = %d", Q.size);
//    PrintFullQueue(Q);
    return 0;
}

C. 判断为空或者满了的方法：增加一个tag变量作为标志的写法

用于标记最后一次操作室出队还是入队
插入成功，就令 tag = 1
删除成功，就令 tag = 0

/*
 1. rear 指向队尾元素的后一个位置 (也就是插入元素的下一个位置）
 c. 增加一个tag变量作为标志的写法：
 用于标记最后一次操作室出队还是入队
 插入成功，就令 tag = 1
 删除成功，就令 tag = 0
 */
 
#include <stdio.h>
#include <iostream>

#define MaxSize 10

using namespace std;

typedef int ElemType;

typedef struct {
    ElemType data[MaxSize];
    int front;
    int rear;
    int tag;
}SqQueue;

// 初始化
void InitQueueC(SqQueue &Q){
    Q.rear = Q.front = 0;
    Q.tag = 0;
}

// 判断队列是否为满
bool IsFullQueueC(SqQueue Q){
    if (Q.rear == Q.front && Q. tag == 1) return true;
    else return false;
}

// 判断队列是否为空
bool IsEmptyQueueC(SqQueue Q){
    if (Q.rear == Q.front && Q.tag == 0) return true;
    else return false;
}

// 入队
bool InQueueC(SqQueue &Q, ElemType x){
    if (IsFullQueueC(Q)) {
        printf("队列满了！没法加了.\n");
        return false;
    }
    Q.data[Q.rear] = x;
    Q.rear = (Q.rear + 1) % MaxSize;
    Q.tag = 1;
    return true;
}

// 出队
bool OutQueueC(SqQueue &Q, ElemType &x){
    if (IsEmptyQueueC(Q)){
        printf("队列空啦！没有办法出队了.\n");
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front + 1) % MaxSize;
    Q.tag = 0;
    return true;
}

//计算队列长度
int LengthQueueC(SqQueue Q){
    return (Q.rear + MaxSize - Q.front) % MaxSize;
}


// 打印没有满的队列
void PrintQueue(SqQueue Q){
    for (int i = Q.front; i <= Q.rear; i ++) {
        printf("%d，", Q.data[i]);
    }
    printf("\n");
}

// 打印满了的队列
void PrintFullQueue(SqQueue Q){
    for (int i = 0; i <= MaxSize - 1; i ++) {
        printf("%d，", Q.data[i]);
    }
    printf("\n");
}
int main(int argc, const char * argv[]) {
    SqQueue Q;
    int a;
    InitQueueC(Q);
    InQueueC(Q, 1);
    InQueueC(Q, 1);
    InQueueC(Q, 1);
    InQueueC(Q, 1);
    InQueueC(Q, 1);
    //    PrintFullQueue(Q);
    OutQueueC(Q, a);
    OutQueueC(Q, a);
    OutQueueC(Q, a);
    OutQueueC(Q, a);
    OutQueueC(Q, a);
    OutQueueC(Q, a);
    OutQueueC(Q, a);
//    PrintQueue(Q);
    return 0;
}