PTA: jmu-ds-舞伴问题-优快云博客

本文链接：https://blog.youkuaiyun.com/ly1012_/article/details/146387286

假设在周末舞会上，男士和女士们分别进入舞厅，各自排成一队。跳舞开始，依次从男队和女队队头各出一人配成舞伴，若两队初始人数不同，则较长那一队未配对者等待下一轮舞曲。现要求写一算法模拟上述舞伴配对问题。
你需要用队列操作实现上述算法。请完成下面5个函数的操作。

函数接口定义：

int QueueLen(SqQueue Q);//队列长度 
int EnQueue(SqQueue &Q, Person e);//加入队列 
int QueueEmpty(SqQueue &Q);//队列是否为空 
int DeQueue(SqQueue &Q, Person &e);//出队列 
void DancePartner(Person dancer[], int num); //配对舞伴

Q：队列
e:参加舞会的人
dancer:全部舞者
num:参加舞会的人数

###输入说明
先输入参加舞会人数，再分别输入参加舞会人的姓名和性别
###输出说明
先输出配对的男女舞伴，若队伍有剩人，则输出剩下人性别及剩下人数目。

裁判测试程序样例：

#include<iostream>
#define MAXQSIZE 100//队列可能达到的最大长度
#define OK 1
#define ERROR 0
#define OVERFLOW -2
using namespace std;
typedef struct {
    char name[20]; //姓名
    char sex; //性别，'F'表示女性，'M'表示男性
} Person;
//- - - - - 队列的顺序存储结构- - - - - 
typedef struct {
    Person data[MAXQSIZE]; 
    int front; //头指针
    int rear; //尾指针
} Queue;
typedef Queue *SqQueue;
SqQueue Mdancers, Fdancers; //分别存放男士和女士入队者队列
int InitQueue(SqQueue &Q);
void DestroyQueue(SqQueue &q);
int QueueLen(SqQueue Q);//队列长度 
int EnQueue(SqQueue &Q, Person e);//加入队列 
int QueueEmpty(SqQueue &Q);//队列是否为空 
int DeQueue(SqQueue &Q, Person &e);//出队列 
void DancePartner(Person dancer[], int num); //配对舞伴 
int main(){
    int i;
    int n;
    Person dancer[MAXQSIZE];
    cin>>n;
    for(i=0;i<n;i++) cin>> dancer[i].name >> dancer[i].sex;
    InitQueue(Mdancers); //男士队列初始化
    InitQueue(Fdancers); //女士队列初始化
    cout << "The dancing partners are:" << endl;
    DancePartner(dancer, n);
    if (!QueueEmpty(Fdancers)) { 
        cout << "F:"<<QueueLen(Fdancers) ;
    } else if (!QueueEmpty(Mdancers)) { 
        cout << "M:"<<QueueLen(Mdancers) ;
    }
    DestroyQueue(Fdancers);
    DestroyQueue(Mdancers);
    return 0;
}
int InitQueue(SqQueue &Q) {//构造一个空队列Q
    Q = new Queue; //为队列分配一个最大容量为MAXSIZE的数组空间
    if (!Q->data)
        exit( OVERFLOW); //存储分配失败
    Q->front = Q->rear = 0; //头指针和尾指针置为零，队列为空
    return OK;
}
void DestroyQueue(SqQueue &q)
{
    delete q;
}
/* 请在这里填写答案 */

输入样例：

6
张1 F
林1 F
王2 M
李1 F
薛2 M
翁1 F

输出样例：

The dancing partners are:
张1  王2
林1  薛2
F:2

先介绍一下循环队列：

1）普通队列存在 “假溢出” 问题：普通队列使用数组存储元素，通过头指针 front 和尾指针 rear 来标记队列的首尾位置。在入队操作时，rear 指针向后移动；出队操作时，front 指针向后移动。当 rear 指针到达数组末尾时，即使数组前面还有空闲空间，也无法再进行入队操作，这就是 “假溢出” 现象。

2）循环队列的实现原理：循环队列通过将数组看作一个环形结构来解决 “假溢出” 问题。具体做法是在进行指针移动时，使用取模运算 % 来确保指针在数组范围内循环移动。例如，当 rear 指针到达数组末尾时，再进行入队操作，rear 指针会回到数组开头。

循环队列的基本操作

1、初始化队列

初始化队列通常是将队列的头指针和尾指针都置为 0，表示队列为空。

int InitQueue(SqQueue &Q) {
    Q = new Queue;
    if (!Q->data)
        exit(OVERFLOW);
    Q->front = Q->rear = 0;
    return OK;
}

该函数为队列分配内存空间，如果分配失败则退出程序。将队列的头指针 front 和尾指针 rear 都初始化为 0，代表队列为空。

2、队列长度计算

在循环队列中，计算队列长度不能简单地用 rear - front，因为 rear 可能小于 front。正确的计算方法是 (rear - front + MAXQSIZE) % MAXQSIZE，其中 MAXQSIZE 是队列的最大容量。

int QueueLen(SqQueue Q) {
    return (Q->rear - Q->front + MAXQSIZE) % MAXQSIZE;
}

3、入队操作

入队操作时，首先要检查队列是否已满。在循环队列中，判断队列已满的条件是 (rear + 1) % MAXQSIZE == front。如果队列未满，则将元素添加到 rear 指针指向的位置，并将 rear 指针向后移动一位（使用取模运算确保循环）。

int EnQueue(SqQueue &Q, Person e) {
    if ((Q->rear + 1) % MAXQSIZE == Q->front) {
        return ERROR;
    }
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MAXQSIZE;
    return OK;
}

4、判断队列是否为空

通过比较头指针和尾指针是否相等来判断队列是否为空：

int QueueEmpty(SqQueue &Q) {
    return Q->front == Q->rear;
}

如果头指针和尾指针相等，说明队列为空，返回 OK，否则返回 ERROR。

5、出队操作

出队操作时，首先要检查队列是否为空。判断队列是否为空的条件是 front == rear。如果队列不为空，则取出 front 指针指向的元素，并将 front 指针向后移动一位（同样使用取模运算确保循环）。

int DeQueue(SqQueue &Q, Person &e) {
    if (Q->front == Q->rear) {
        return ERROR;
    }
    e = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXQSIZE;
    return OK;
}

6、循环队列判断队列已满的方法

1）牺牲一个存储单元

牺牲数组中的一个存储单元，使得队列满的判断条件为 (rear + 1) % MAX_SIZE == front。其中，rear 是队列的尾指针，front 是队列的头指针，MAX_SIZE 是数组的最大容量。

在循环队列中，若不预留空位，队列满和队列空时都会出现 rear == front 的情况，这会让程序无法区分队列当前的状态。而预留一个空位后，队列满的条件就变为 (rear + 1) % MAX_SIZE == front，队列空的条件依旧是 rear == front，这样就能清晰区分两种状态了。

#include <iostream>
#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int front;
    int rear;
} CircularQueue;

// 判断循环队列是否已满
bool isFull(CircularQueue q) {
    return (q.rear + 1) % MAX_SIZE == q.front;
}

int main() {
    CircularQueue q = {0, 0, 0};
    if (isFull(q)) {
        std::cout << "循环队列已满" << std::endl;
    } else {
        std::cout << "循环队列未满" << std::endl;
    }
    return 0;
}

在上述代码中，isFull 函数通过 (q.rear + 1) % MAX_SIZE == q.front 来判断循环队列是否已满。

2）使用额外的计数器

使用一个额外的计数器 count 来记录队列中的元素个数。当 count 等于 MAX_SIZE 时，表示队列已满。

#include <iostream>
#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int front;
    int rear;
    int count;
} CircularQueue;

// 判断循环队列是否已满
bool isFull(CircularQueue q) {
    return q.count == MAX_SIZE;
}

int main() {
    CircularQueue q = {0, 0, 0, 0};
    if (isFull(q)) {
        std::cout << "循环队列已满" << std::endl;
    } else {
        std::cout << "循环队列未满" << std::endl;
    }
    return 0;
}

在上述代码中，isFull 函数通过比较 count 和 MAX_SIZE 来判断循环队列是否已满。

这道题的代码如下：

int QueueLen(SqQueue Q)//队列长度
{
    return (Q->rear-Q->front+MAXQSIZE)%MAXQSIZE;
}
int EnQueue(SqQueue &Q, Person e)//加入队列
{
    if(Q->front==(Q->rear+1)%MAXQSIZE)
        return ERROR;
    Q->data[Q->rear]=e;
    Q->rear=(Q->rear+1)%MAXQSIZE;
    return OK;
}
int QueueEmpty(SqQueue &Q)//队列是否为空
{
    if(Q->rear==Q->front)
        return OK;
    return ERROR;
}
int DeQueue(SqQueue &Q, Person &e)//出队列
{
    if(QueueEmpty(Q))
        return ERROR;
    e=Q->data[Q->front];
    Q->front=(Q->front+1)%MAXQSIZE;
    return OK;
}
void DancePartner(Person dancer[], int num)//配对舞伴
{
    for(int i=0;i<num;i++)
    {
        if(dancer[i].sex=='F')
        {
            EnQueue(Fdancers,dancer[i]);
        }else{
            EnQueue(Mdancers,dancer[i]);
        }
    }
    Person male,female;
    while(!QueueEmpty(Mdancers)&&!QueueEmpty(Fdancers))
    {
        DeQueue(Mdancers,male);
        DeQueue(Fdancers,female);
        cout<<female.name<<"  "<<male.name<<endl;
    }
}