[已解决]舞伴问题

君苏依寂

代码如下，运行结果错误，DancePartner.txt是文本，内容是
鄢雪棱 F
高欣雅 F
张甜源 F
许丹丹 F
冉小溪 F
周如意 F
胡思琪 F
蒋雅琪 F
金城武 M
吴彦祖 M
王思聪 M
古天乐 M
周杰伦 M
李敏浩 M
李钟硕 M
马小云 M
张智霖 M
王力宏 M
齐小云 F
王明均 M

1. #include<iostream>
   
2. #include<fstream>
   
3. #include<string>
   
4. #define MAXQSIZE 100//队列可能达到的最大长度
   
5. #define OK 1
   
6. #define ERROR 0
   
7. #define OVERFLOW -2
   
8. using namespace std;
   
9. 
   
10. typedef struct {
    
11.         char name[20]; //姓名
    
12.         char sex; //性别，'F'表示女性，'M'表示男性
    
13. } Person;
    
14. 
    
15. //- - - - - 队列的顺序存储结构- - - - -
    
16. typedef struct {
    
17.         Person *base; //队列中数据元素类型为Person
    
18.         int front; //头指针
    
19.         int rear; //尾指针
    
20.         int qsize;
    
21. } SqQueue;
    
22. 
    
23. SqQueue Mdancers, Fdancers; //分别存放男士和女士入队者队列
    
24. 
    
25. int InitQueue(SqQueue &Q) {//构造一个空队列Q
    
26.         Q.base = new Person[MAXQSIZE]; //为队列分配一个最大容量为MAXSIZE的数组空间
    
27.         if (!Q.base)
    
28.                 exit( OVERFLOW); //存储分配失败
    
29.         Q.front = Q.rear = 0; //头指针和尾指针置为零，队列为空
    
30.         Q.qsize = 0;
    
31.         return OK;
    
32. }
    
33. 
    
34. int EnQueue(SqQueue &Q, Person e) {//插入元素e为Q的新的队尾元素
    
35.         if ((Q.rear + 1) % MAXQSIZE == Q.front) //尾指针在循环意义上加1后等于头指针，表明队满
    
36.                 return ERROR;
    
37.         Q.base[Q.rear] = e; //新元素插入队尾
    
38.         Q.rear = (Q.rear + 1) % MAXQSIZE; //队尾指针加1
    
39.         Q.qsize ++;
    
40.         return OK;
    
41. }
    
42. 
    
43. int QueueEmpty(SqQueue &Q) {
    
44.         if (Q.front == Q.rear) //队空
    
45.                 return OK;
    
46.         else
    
47.                 return ERROR;
    
48. }
    
49. 
    
50. int DeQueue(SqQueue &Q, Person &e)//删除Q的队头元素，用e返回其值
    
51. {
    
52.         if (Q.front == Q.rear)
    
53.                 return ERROR; //队空
    
54.         e = Q.base[Q.front]; //保存队头元素
    
55.         Q.front = (Q.front + 1) % MAXQSIZE; //队头指针加1
    
56.         return OK;
    
57. }
    
58. 
    
59. Person GetHead(SqQueue Q) {//返回Q的队头元素，不修改队头指针
    
60.         if (Q.front != Q.rear) //队列非空
    
61.                 return Q.base[Q.front]; //返回队头元素的值，队头指针不变
    
62. }
    
63. 
    
64. //算法3.23　舞伴问题填写完整
    
65. void DancePartner(Person dancer[], int num) {//结构数组dancer中存放跳舞的男女，num是跳舞的人数。
    
66. //当一个队列空，另一个不空时，输出队头等待者的名字       
    
67.         SqQueue Man,Woman;
    
68.         Person p;
    
69.         InitQueue(Man);
    
70.         InitQueue(Woman);
    
71.         for(int i=0;i<num;i++)
    
72.         {
    
73.                 p=dancer[i];
    
74.             if(p.sex=='M')
    
75.                 EnQueue(Man,p);
    
76.                 else
    
77.                 EnQueue(Woman,p);       
    
78.         }
    
79.         cout<<"请输入几首歌:"<<endl;
    
80.         int n;
    
81.         int j=1;
    
82.         cin >>n;
    
83.         //cout<<"本次跳舞的组合是："<<endl;
    
84.         cout<<"女士在前，男士在后。。。"<<endl;
    
85.        
    
86.         while(n--){
    
87.                 cout<<"本次是第"<<j++<<"次:"<<endl;
    
88.                
    
89.                 while(!QueueEmpty(Man))  
    
90.         {  
    
91.             if(QueueEmpty(Woman))  
    
92.                 DeQueue(Woman,p);  
    
93.             DeQueue(Man,p);
    
94.                         cout<<p.name<<" ";
    
95.             DeQueue(Woman,p);
    
96.                         cout<<p.name<<endl;
    
97.             
    
98.         }  
    
99.         Man.front=(Man.front+1)%Man.qsize;   
    
100.         if(QueueEmpty(Woman))  
     
101.                 DeQueue(Woman,p);  
     
102.         p = GetHead(Woman);
     
103.                 printf("第一个出场的未配对者的姓名：%s\n",p.name);   
     
104.         
     
105.                
     
106.                
     
107.          
     
108. }
     
109. 
     
110. 
     
111. }
     
112. 
     
113. 
     
114. 
     
115. Person dancer[MAXQSIZE];
     
116. int main() {
     
117.         int i = 0;
     
118.         fstream file;
     
119.         file.open("DancePartner.txt");
     
120.         if (!file) {
     
121.                 cout << "错误！未找到文件！\n\n" << endl;
     
122.                 exit( ERROR);
     
123.         }
     
124.         while (!file.eof()) {
     
125.                 file >> dancer[i].name >> dancer[i].sex;
     
126.                 i++;
     
127.         }
     
128.         DancePartner(dancer, i - 1);
     
129.        
     
130.         return 0;
     
131. }

复制代码

最佳答案

月排行榜 / 总排行榜

人造人

2021-10-21 21:10:43

题目

跳转到最佳答案楼层

人造人

题目

君苏依寂

人造人 发表于 2021-10-22 11:32
题目

如果男队和女队人数不等,输出一轮舞曲后不空队剩余的人数和名单；
可循环n次不同人结伴,输出结伴情况

人造人

君苏依寂 发表于 2021-10-22 12:49
如果男队和女队人数不等,输出一轮舞曲后不空队剩余的人数和名单；
可循环n次不同人结伴,输出结伴情况

完整的题目

君苏依寂

人造人 发表于 2021-10-22 13:35
完整的题目

没了，就这两个要求，题干是舞伴问题

君苏依寂

人造人 发表于 2021-10-22 13:35
完整的题目

这就是完整的题目

君苏依寂

人造人 发表于 2021-10-22 13:35
完整的题目

谢谢你，我自己改改吧，不麻烦你了

人造人

君苏依寂 发表于 2021-10-22 14:01
这就是完整的题目

这怎么可能是完整的题目？
我要的是这个，你的题目不完整，是要别人去百度找你的问题的题目吗？
下面这个题目我找了挺久的，你自己贴出来不是更好？

1. 问题叙述
   
2. 假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。现要求写一算法模拟上述舞伴配对问题。
   
3. 
   
4. 【问题分析】
   
5. 先入队的男士或女士亦先出队配成舞伴。因此该问题具体有典型的先进先出特性，可用队列作为算法的数据结构。
   
6. 在算法中，假设男士和女士的记录存放在一个数组中作为输入，然后依次扫描该数组的各元素，并根据性别来决定是进入男队还是女队。当这两个队列构造完成之后，依次将两队当前的队头元素出队来配成舞伴，直至某队列变空为止。此时，若某队仍有等待配对者，算法输出配对的结果和此队列中等待者的人数及排在队头的等待者的名字，他（或她）将是下一轮舞曲开始时第一个可获得舞伴的人。

复制代码

1. #include <fstream>
   
2. #include <iostream>
   
3. #include <string>
   
4. 
   
5. #define MAXQSIZE 100 //队列可能达到的最大长度
   
6. #define OK 1
   
7. #define ERROR 0
   
8. #define OVERFLOW -2
   
9. 
   
10. using namespace std;
    
11. 
    
12. typedef struct {
    
13.     char name[20]; //姓名
    
14.     char sex;      //性别，'F'表示女性，'M'表示男性
    
15. } Person;
    
16. 
    
17. //- - - - - 队列的顺序存储结构- - - - -
    
18. typedef struct {
    
19.     Person *base; //队列中数据元素类型为Person
    
20.     int front;    //头指针
    
21.     int rear;     //尾指针
    
22.     int qsize;
    
23. } SqQueue;
    
24. 
    
25. // 你程序中没有使用这两个
    
26. //SqQueue Mdancers, Fdancers; //分别存放男士和女士入队者队列
    
27. 
    
28. int InitQueue(SqQueue &Q) { //构造一个空队列Q
    
29.     Q.base = new Person[MAXQSIZE]; //为队列分配一个最大容量为MAXSIZE的数组空间
    
30.     if(!Q.base)
    
31.         exit(OVERFLOW);   //存储分配失败
    
32.     Q.front = Q.rear = 0; //头指针和尾指针置为零，队列为空
    
33.     Q.qsize = 0;
    
34.     return OK;
    
35. }
    
36. 
    
37. // 释放函数一定一定一定一定一定要写
    
38. void queue_deinit(SqQueue &q) {
    
39.     delete [] q.base;
    
40. }
    
41. 
    
42. int EnQueue(SqQueue &Q, Person e) { //插入元素e为Q的新的队尾元素
    
43.     if((Q.rear + 1) % MAXQSIZE ==
    
44.        Q.front) //尾指针在循环意义上加1后等于头指针，表明队满
    
45.         return ERROR;
    
46.     Q.base[Q.rear] = e;               //新元素插入队尾
    
47.     Q.rear = (Q.rear + 1) % MAXQSIZE; //队尾指针加1
    
48.     Q.qsize++;
    
49.     return OK;
    
50. }
    
51. 
    
52. int QueueEmpty(SqQueue &Q) {
    
53.     if(Q.front == Q.rear) //队空
    
54.         return OK;
    
55.     else
    
56.         return ERROR;
    
57. }
    
58. 
    
59. int DeQueue(SqQueue &Q, Person &e) //删除Q的队头元素，用e返回其值
    
60. {
    
61.     if(Q.front == Q.rear)
    
62.         return ERROR;                   //队空
    
63.     e = Q.base[Q.front];                //保存队头元素
    
64.     Q.front = (Q.front + 1) % MAXQSIZE; //队头指针加1
    
65.     return OK;
    
66. }
    
67. 
    
68. Person GetHead(SqQueue Q) {     //返回Q的队头元素，不修改队头指针
    
69.     if(Q.front != Q.rear)       //队列非空
    
70.         return Q.base[Q.front]; //返回队头元素的值，队头指针不变
    
71. 
    
72.     // 非空的时侯返回 Q.base[Q.front]
    
73.     // 空的时侯怎么办？
    
74.     // 你没写，我也不知道对于你的这个设计应该返回什么，那就直接退出吧
    
75.     exit(ERROR);
    
76. }
    
77. 
    
78. //算法3.23　舞伴问题填写完整
    
79. void DancePartner(Person dancer[],
    
80.                   int num) { //结构数组dancer中存放跳舞的男女，num是跳舞的人数。
    
81.     //当一个队列空，另一个不空时，输出队头等待者的名字
    
82.     SqQueue Man, Woman;
    
83.     Person p;
    
84.     InitQueue(Man);
    
85.     InitQueue(Woman);
    
86.     for(int i = 0; i < num; i++) {
    
87.         p = dancer[i];
    
88.         if(p.sex == 'M')
    
89.             EnQueue(Man, p);
    
90.         else
    
91.             EnQueue(Woman, p);
    
92.     }
    
93.     cout << "请输入几首歌:" << endl;
    
94.     int n;
    
95.     int j = 1;
    
96.     cin >> n;
    
97.     // cout<<"本次跳舞的组合是："<<endl;
    
98.     cout << "女士在前，男士在后。。。" << endl;
    
99. 
    
100.     /*
     
101.     while(n--) {
     
102.         cout << "本次是第" << j++ << "次:" << endl;
     
103. 
     
104.         while(!QueueEmpty(Man)) {
     
105. 
     
106.             // 队列空的时侯出对?
     
107.             if(QueueEmpty(Woman))
     
108.                 DeQueue(Woman, p);
     
109.             DeQueue(Man, p);
     
110.             cout << p.name << " ";
     
111.             DeQueue(Woman, p);
     
112.             cout << p.name << endl;
     
113.         }
     
114. 
     
115.         // 不要在 queue函数的外面使用 queue 函数的内部数据结构
     
116.         Man.front = (Man.front + 1) % Man.qsize;
     
117.         if(QueueEmpty(Woman))
     
118.             DeQueue(Woman, p);
     
119.         p = GetHead(Woman);
     
120.         printf("第一个出场的未配对者的姓名：%s\n", p.name);
     
121.     }
     
122.     */
     
123. 
     
124.     SqQueue a, b;
     
125.     InitQueue(a);
     
126.     InitQueue(b);
     
127.     while(n--) {
     
128.         cout << "本次是第" << j++ << "次:" << endl;
     
129.         while(!QueueEmpty(Man) && !QueueEmpty(Woman)) {
     
130.             DeQueue(Man, p);
     
131.             EnQueue(a, p);
     
132.             cout << p.name << " ";
     
133.             DeQueue(Woman, p);
     
134.             EnQueue(b, p);
     
135.             cout << p.name << endl;
     
136.         }
     
137.         SqQueue *remain = !QueueEmpty(Man) ? &Man : &Woman;
     
138.         p = GetHead(*remain);
     
139.         printf("第一个出场的未配对者的姓名：%s\n", p.name);
     
140.         while(!QueueEmpty(a)) {
     
141.             DeQueue(a, p);
     
142.             EnQueue(Man, p);
     
143.         }
     
144.         while(!QueueEmpty(b)) {
     
145.             DeQueue(b, p);
     
146.             EnQueue(Woman, p);
     
147.         }
     
148.     }
     
149. 
     
150.     queue_deinit(Man);
     
151.     queue_deinit(Woman);
     
152.     queue_deinit(a);
     
153.     queue_deinit(b);
     
154. }
     
155. 
     
156. Person dancer[MAXQSIZE];
     
157. 
     
158. int main() {
     
159.     int i = 0;
     
160.     fstream file;
     
161.     file.open("DancePartner.txt");
     
162.     if(!file) {
     
163.         cout << "错误！未找到文件！\n\n" << endl;
     
164.         exit(ERROR);
     
165.     }
     
166.     while(!file.eof()) {
     
167.         file >> dancer[i].name >> dancer[i].sex;
     
168.         i++;
     
169.     }
     
170.     file.close();       // 关闭一下最好
     
171.     DancePartner(dancer, i - 1);
     
172.     return 0;
     
173. }
     

复制代码