[已解决]求助关于 如何分开对链表数据排序

ssg

人造人 发表于 2018-5-3 23:54
把代码发完整
^_^

只需实现x==1那里的排序就行，剩下的选项2我自己参考着写

ssg

人造人 发表于 2018-5-3 23:54
把代码发完整
^_^

把这部分代码删除了吧

人造人

ssg 发表于 2018-5-4 07:56
可以写专业1  专业2    班级写1班，2班这样，比较简洁

好主意
^_^

人造人

debug 版本已经完成
我还需要花些时间，修改一下，把输入数据改成动态输入，而不是使用info_tab

1. #include <iostream>
   
2. #include <vector>
   
3. #include <string>
   
4. #include <algorithm>
   
5. 
   
6. // 本科生
   
7. // debug版本
   
8. struct UndergraduateDebug
   
9. {
   
10.         int                num;                        // 学号
    
11.         std::string        name;                        // 姓名
    
12.         std::string        sex1;                        // 性别
    
13.         std::string        profession;                // 专业
    
14.         std::string        classroom;                // 班级
    
15.         int                Undergraduate_math;        // 本科生 高数
    
16.         int                Undergraduate_English;        // 本科生 英语
    
17.         int                Undergraduate_Cscore;        // 本科生 c语言
    
18.         int                TotalScore;                // 总成绩
    
19.         int                Classrank;                // 班级排名
    
20.         int                Schoolrank;                // 校排名
    
21. };
    
22. 
    
23. 
    
24. // 本科生
    
25. struct Undergraduate
    
26. {
    
27.         int                num;                        // 学号
    
28.         std::string        name;                        // 姓名
    
29.         std::string        sex1;                        // 性别
    
30.         int                Undergraduate_math;        // 本科生 高数
    
31.         int                Undergraduate_English;        // 本科生 英语
    
32.         int                Undergraduate_Cscore;        // 本科生 c语言
    
33.         int                TotalScore;                // 总成绩
    
34.         int                Classrank;                // 班级排名
    
35.         int                Schoolrank;                // 校排名
    
36. };
    
37. 
    
38. // 班级
    
39. struct Classroom
    
40. {
    
41.         std::string        classroom_name;                // 班级名
    
42.         std::vector<Undergraduate> u;                // 本科生
    
43. };
    
44. 
    
45. // 专业
    
46. struct Profession
    
47. {
    
48.         std::string        profession_name;        // 专业名
    
49.         std::vector<Classroom> c;                // 班级
    
50. };
    
51. 
    
52. // 学校
    
53. struct School
    
54. {
    
55.         std::string        school_name;                // 校名
    
56.         std::vector<Profession> pro;                // 专业
    
57. };
    
58. 
    
59. // 录入数据
    
60. void InputDataDebug(School &dest, const std::vector<UndergraduateDebug> &src)        // debug版本
    
61. {
    
62.         for(auto iterator = src.begin(); iterator != src.end(); ++iterator)
    
63.         {
    
64.                 // 确定专业
    
65.                 std::vector<Profession>::iterator i = dest.pro.end();
    
66.                 for(auto iter = dest.pro.begin(); iter != dest.pro.end(); ++iter)
    
67.                 {
    
68.                         if(iterator->profession == iter->profession_name)
    
69.                         {
    
70.                                 i = iter;
    
71.                                 break;
    
72.                         }
    
73.                 }
    
74. 
    
75.                 // 没有就加一个
    
76.                 if(i == dest.pro.end())
    
77.                 {
    
78.                         // 在添加时确保专业是有序的
    
79.                         for(auto iter = dest.pro.begin(); iter != dest.pro.end(); ++iter)
    
80.                         {
    
81.                                 if(iter->profession_name > iterator->profession)
    
82.                                 {
    
83.                                         i = dest.pro.insert(iter, Profession({iterator->profession, std::vector<Classroom>()}));
    
84.                                         break;
    
85.                                 }
    
86.                         }
    
87. 
    
88.                         // i 任然等于dest.pro.end()，添加到最后
    
89.                         if(i == dest.pro.end())
    
90.                         {
    
91.                                 dest.pro.push_back(Profession({iterator->profession, std::vector<Classroom>()}));
    
92.                                 i = dest.pro.end() - 1;
    
93.                         }
    
94.                 }
    
95. 
    
96.                 // 确定班级
    
97.                 std::vector<Classroom>::iterator j = i->c.end();
    
98.                 for(auto iter = i->c.begin(); iter != i->c.end(); ++iter)
    
99.                 {
    
100.                         if(iterator->classroom == iter->classroom_name)
     
101.                         {
     
102.                                 j = iter;
     
103.                                 break;
     
104.                         }
     
105.                 }
     
106. 
     
107.                 // 没有就加一个
     
108.                 if(j == i->c.end())
     
109.                 {
     
110.                         // 在添加时确保班级是有序的
     
111.                         for(auto iter = i->c.begin(); iter != i->c.end(); ++iter)
     
112.                         {
     
113.                                 if(iter->classroom_name > iterator->classroom)
     
114.                                 {
     
115.                                         j = i->c.insert(iter, Classroom({iterator->classroom, std::vector<Undergraduate>()}));
     
116.                                         break;
     
117.                                 }
     
118.                         }
     
119. 
     
120.                         // j 任然等于i->c.end()，添加到最后
     
121.                         if(j == i->c.end())
     
122.                         {
     
123.                                 i->c.push_back(Classroom({iterator->classroom, std::vector<Undergraduate>()}));
     
124.                                 j = i->c.end() - 1;
     
125.                         }
     
126.                 }
     
127. 
     
128.                 // 确定学生在班级中的位置
     
129.                 std::vector<Undergraduate>::iterator k = j->u.end();
     
130.                 int TotalScore = iterator->Undergraduate_math + iterator->Undergraduate_English + iterator->Undergraduate_Cscore;
     
131.                 for(auto iter = j->u.begin(); iter != j->u.end(); ++iter)
     
132.                 {
     
133.                         if(iter->TotalScore < TotalScore)
     
134.                         {
     
135.                                 k = iter;
     
136.                                 break;
     
137.                         }
     
138.                 }
     
139. 
     
140.                 Undergraduate u;
     
141.                 u.num = iterator->num;
     
142.                 u.name = iterator->name;
     
143.                 u.sex1 = iterator->sex1;
     
144.                 u.Undergraduate_math = iterator->Undergraduate_math;
     
145.                 u.Undergraduate_English = iterator->Undergraduate_English;
     
146.                 u.Undergraduate_Cscore = iterator->Undergraduate_Cscore;
     
147.                 u.TotalScore = TotalScore;        // 上面已经计算过了
     
148.                 u.Classrank = 0;                // 暂时填0
     
149.                 u.Schoolrank = 0;                // 暂时填0
     
150. 
     
151.                 j->u.insert(k, u);
     
152.         }
     
153. }
     
154. 
     
155. 
     
156. bool Compare(const std::vector<Undergraduate>::iterator &a, const std::vector<Undergraduate>::iterator &b)
     
157. {
     
158.         return a->TotalScore > b->TotalScore;
     
159. }
     
160. 
     
161. std::string AlignString(std::string s, int length)
     
162. {
     
163.         while(s.length() != length)
     
164.                 s.push_back(' ');
     
165. 
     
166.         return s;
     
167. }
     
168. void DebugPrint(School &s)
     
169. {
     
170. #if 1
     
171.         int length = 15;
     
172. 
     
173.         std::cout << AlignString("校名：", length) << s.school_name << std::endl;
     
174.         for(auto i = s.pro.begin(); i != s.pro.end(); ++i)
     
175.         {
     
176.                 std::cout << "-------------------------" << std::endl;
     
177.                 std::cout << AlignString("专业名：", length) << i->profession_name << std::endl;
     
178.                 std::cout << "-------------------------" << std::endl;
     
179.                 for(auto j = i->c.begin(); j != i->c.end(); ++j)
     
180.                 {
     
181.                         std::cout << "*************************" << std::endl;
     
182.                         std::cout << AlignString("班级名：", length) << j->classroom_name << std::endl;
     
183.                         for(auto k = j->u.begin(); k != j->u.end(); ++k)
     
184.                         {
     
185.                                 std::cout << AlignString("学号：", length)                << k->num << std::endl;
     
186.                                 std::cout << AlignString("姓名：", length)                << k->name << std::endl;
     
187.                                 std::cout << AlignString("性别：", length)                << k->sex1 << std::endl;
     
188.                                 std::cout << AlignString("本科生 高数：", length)        << k->Undergraduate_math << std::endl;
     
189.                                 std::cout << AlignString("本科生 英语：", length)        << k->Undergraduate_English << std::endl;
     
190.                                 std::cout << AlignString("本科生 c语言：", length)        << k->Undergraduate_Cscore << std::endl;
     
191.                                 std::cout << AlignString("总成绩：", length)                << k->TotalScore << std::endl;
     
192.                                 std::cout << AlignString("班级排名：", length)                << k->Classrank << std::endl;
     
193.                                 std::cout << AlignString("校排名：", length)                << k->Schoolrank << std::endl;
     
194.                                 std::cout << std::endl;
     
195.                         }
     
196.                         std::cout << std::endl;
     
197.                 }
     
198.         }
     
199. #else
     
200.         // 另一种输出，按校级排名输出
     
201.         std::vector<std::vector<Undergraduate>::iterator> tmp;
     
202.         for(auto i = s.pro.begin(); i != s.pro.end(); ++i)
     
203.         {
     
204.                 for(auto j = i->c.begin(); j != i->c.end(); ++j)
     
205.                 {
     
206.                         for(auto k = j->u.begin(); k != j->u.end(); ++k)
     
207.                         {
     
208.                                 tmp.push_back(k);
     
209.                         }
     
210.                 }
     
211.         }
     
212. 
     
213.         // 排序
     
214.         std::sort(tmp.begin(), tmp.end(), Compare);
     
215. 
     
216.         int length = 15;
     
217.         for(auto iter = tmp.begin(); iter != tmp.end(); ++iter)
     
218.         {
     
219.                 std::cout << AlignString("学号：", length) << (*iter)->num << std::endl;
     
220.                 std::cout << AlignString("姓名：", length) << (*iter)->name << std::endl;
     
221.                 std::cout << AlignString("性别：", length) << (*iter)->sex1 << std::endl;
     
222.                 std::cout << AlignString("本科生 高数：", length) << (*iter)->Undergraduate_math << std::endl;
     
223.                 std::cout << AlignString("本科生 英语：", length) << (*iter)->Undergraduate_English << std::endl;
     
224.                 std::cout << AlignString("本科生 c语言：", length) << (*iter)->Undergraduate_Cscore << std::endl;
     
225.                 std::cout << AlignString("总成绩：", length) << (*iter)->TotalScore << std::endl;
     
226.                 std::cout << AlignString("班级排名：", length) << (*iter)->Classrank << std::endl;
     
227.                 std::cout << AlignString("校排名：", length) << (*iter)->Schoolrank << std::endl;
     
228.                 std::cout << std::endl;
     
229.         }
     
230. #endif
     
231. }
     
232. // ********************************************************************************************
     
233. 
     
234. 
     
235. // 排名
     
236. void Rank(School &s)
     
237. {
     
238.         // 处理班级排名
     
239.         // 学生在班级中已经是有序的
     
240.         for(auto i = s.pro.begin(); i != s.pro.end(); ++i)
     
241.         {
     
242.                 for(auto j = i->c.begin(); j != i->c.end(); ++j)
     
243.                 {
     
244.                         int count = 0;
     
245.                         for(auto k = j->u.begin(); k != j->u.end(); ++k)
     
246.                         {
     
247.                                 k->Classrank = ++count;
     
248.                         }
     
249.                 }
     
250.         }
     
251. 
     
252.         // 处理校级排名
     
253.         // 我也没有什么好办法^_^
     
254.         std::vector<std::vector<Undergraduate>::iterator> tmp;
     
255.         for(auto i = s.pro.begin(); i != s.pro.end(); ++i)
     
256.         {
     
257.                 for(auto j = i->c.begin(); j != i->c.end(); ++j)
     
258.                 {
     
259.                         for(auto k = j->u.begin(); k != j->u.end(); ++k)
     
260.                         {
     
261.                                 tmp.push_back(k);
     
262.                         }
     
263.                 }
     
264.         }
     
265. 
     
266.         // 排序
     
267.         std::sort(tmp.begin(), tmp.end(), Compare);
     
268. 
     
269.         // 填序号就可以了
     
270.         int count = 0;
     
271.         for(auto iter = tmp.begin(); iter != tmp.end(); ++iter)
     
272.         {
     
273.                 (*iter)->Schoolrank = ++count;
     
274.         }
     
275. }
     
276. 
     
277. int main()
     
278. {
     
279.         // 学号我就不管了，有重复也不管了，^_^
     
280.         std::vector<UndergraduateDebug> info_tab =
     
281.         {
     
282.                 {0, "学生1", "女", "专业3", "班级2", 70, 50, 20, 0, 0, 0},
     
283.                 {1, "学生2", "男", "专业1", "班级3", 99, 45, 80, 0, 0, 0},
     
284.                 {2, "学生3", "男", "专业2", "班级1", 30, 20, 80, 0, 0, 0},
     
285.                 {3, "学生4", "男", "专业2", "班级2", 20, 40, 60, 0, 0, 0},
     
286.                 {4, "学生5", "女", "专业1", "班级1", 10, 58, 70, 0, 0, 0},
     
287.                 {5, "学生6", "女", "专业3", "班级3", 55, 60, 90, 0, 0, 0},
     
288.                 {6, "学生7", "男", "专业1", "班级1", 75, 57, 62, 0, 0, 0},
     
289.                 {7, "学生8", "女", "专业3", "班级2", 75, 52, 18, 0, 0, 0},
     
290.                 {8, "学生9", "男", "专业1", "班级3", 97, 89, 55, 0, 0, 0},
     
291.                 {9, "学生10", "男", "专业2", "班级1", 35, 21, 88, 0, 0, 0},
     
292.                 {10, "学生11", "男", "专业2", "班级2", 13, 18, 64, 0, 0, 0},
     
293.                 {11, "学生12", "女", "专业1", "班级1", 19, 59, 53, 0, 0, 0},
     
294.                 {12, "学生13", "女", "专业3", "班级3", 59, 51, 52, 0, 0, 0},
     
295.                 {13, "学生14", "男", "专业1", "班级1", 70, 68, 30, 0, 0, 0}
     
296.         };
     
297.        
     
298.         School s = {"校名", std::vector<Profession>()};
     
299.         InputDataDebug(s, info_tab);
     
300.         Rank(s);
     
301.         DebugPrint(s);
     
302. 
     
303.         return 0;
     
304. }
     

复制代码

ssg

人造人 发表于 2018-5-5 11:59
debug 版本已经完成
我还需要花些时间，修改一下，把输入数据改成动态输入，而不是使用info_tab

好厉害，大佬学c多少年了，羡慕嫉妒恨

人造人

ssg 发表于 2018-5-5 12:59
好厉害，大佬学c多少年了，羡慕嫉妒恨

5年
^_^

ssg

人造人 发表于 2018-5-5 13:16
5年
^_^

我看了半天没看懂你的c++

人造人

ssg 发表于 2018-5-5 18:08
我看了半天没看懂你的c++

^_^

人造人

ssg 发表于 2018-5-5 18:08
我看了半天没看懂你的c++

哪里不懂？

ssg

人造人 发表于 2018-5-5 18:13
哪里不懂？

添加专业那些

ssg

人造人 发表于 2018-5-5 18:13
哪里不懂？

.end()  是什么意思

人造人

ssg 发表于 2018-5-5 18:53
.end()  是什么意思

C++迭代器iterator

1. #include <iostream>
   
2. #include <vector>
   
3. 
   
4. int main()
   
5. {
   
6.         std::vector<int> v = {1, 2, 3, 4, 5};
   
7.         for(auto iter = v.begin(); iter != v.end(); ++iter)
   
8.         {
   
9.                 std::cout << *iter << std::endl;
   
10.         }
    
11.         return 0;
    
12. }
    

复制代码

人造人

动态输入的版本 “完成了”
只完成了动态输入部分，其他部分没有完成，也不会被完成了
^_^

1. #include <iostream>
   
2. #include <vector>
   
3. #include <string>
   
4. #include <algorithm>
   
5. #include <windows.h>
   
6. 
   
7. // 本科生
   
8. struct Undergraduate
   
9. {
   
10.         int                num;                        // 学号
    
11.         std::string        name;                        // 姓名
    
12.         std::string        sex1;                        // 性别
    
13.         int                Undergraduate_math;        // 本科生 高数
    
14.         int                Undergraduate_English;        // 本科生 英语
    
15.         int                Undergraduate_Cscore;        // 本科生 c语言
    
16.         int                TotalScore;                // 总成绩
    
17.         int                Classrank;                // 班级排名
    
18.         int                Schoolrank;                // 校排名
    
19. };
    
20. 
    
21. // 班级
    
22. struct Classroom
    
23. {
    
24.         std::string        classroom_name;                // 班级名
    
25.         std::vector<Undergraduate> u;                // 本科生
    
26. };
    
27. 
    
28. // 专业
    
29. struct Profession
    
30. {
    
31.         std::string        profession_name;        // 专业名
    
32.         std::vector<Classroom> c;                // 班级
    
33. };
    
34. 
    
35. // 学校
    
36. struct School
    
37. {
    
38.         std::string        school_name;                // 校名
    
39.         std::vector<Profession> pro;                // 专业
    
40. };
    
41. 
    
42. //// 录入数据
    
43. //void InputDataDebug(School &dest, const std::vector<UndergraduateDebug> &src)        // debug版本
    
44. //{
    
45. //        for(auto iterator = src.begin(); iterator != src.end(); ++iterator)
    
46. //        {
    
47. //                // 确定专业
    
48. //                std::vector<Profession>::iterator i = dest.pro.end();
    
49. //                for(auto iter = dest.pro.begin(); iter != dest.pro.end(); ++iter)
    
50. //                {
    
51. //                        if(iterator->profession == iter->profession_name)
    
52. //                        {
    
53. //                                i = iter;
    
54. //                                break;
    
55. //                        }
    
56. //                }
    
57. //
    
58. //                // 没有就加一个
    
59. //                if(i == dest.pro.end())
    
60. //                {
    
61. //                        // 在添加时确保专业是有序的
    
62. //                        for(auto iter = dest.pro.begin(); iter != dest.pro.end(); ++iter)
    
63. //                        {
    
64. //                                if(iter->profession_name > iterator->profession)
    
65. //                                {
    
66. //                                        i = dest.pro.insert(iter, Profession({iterator->profession, std::vector<Classroom>()}));
    
67. //                                        break;
    
68. //                                }
    
69. //                        }
    
70. //
    
71. //                        // i 任然等于dest.pro.end()，添加到最后
    
72. //                        if(i == dest.pro.end())
    
73. //                        {
    
74. //                                dest.pro.push_back(Profession({iterator->profession, std::vector<Classroom>()}));
    
75. //                                i = dest.pro.end() - 1;
    
76. //                        }
    
77. //                }
    
78. //
    
79. //                // 确定班级
    
80. //                std::vector<Classroom>::iterator j = i->c.end();
    
81. //                for(auto iter = i->c.begin(); iter != i->c.end(); ++iter)
    
82. //                {
    
83. //                        if(iterator->classroom == iter->classroom_name)
    
84. //                        {
    
85. //                                j = iter;
    
86. //                                break;
    
87. //                        }
    
88. //                }
    
89. //
    
90. //                // 没有就加一个
    
91. //                if(j == i->c.end())
    
92. //                {
    
93. //                        // 在添加时确保班级是有序的
    
94. //                        for(auto iter = i->c.begin(); iter != i->c.end(); ++iter)
    
95. //                        {
    
96. //                                if(iter->classroom_name > iterator->classroom)
    
97. //                                {
    
98. //                                        j = i->c.insert(iter, Classroom({iterator->classroom, std::vector<Undergraduate>()}));
    
99. //                                        break;
    
100. //                                }
     
101. //                        }
     
102. //
     
103. //                        // j 任然等于i->c.end()，添加到最后
     
104. //                        if(j == i->c.end())
     
105. //                        {
     
106. //                                i->c.push_back(Classroom({iterator->classroom, std::vector<Undergraduate>()}));
     
107. //                                j = i->c.end() - 1;
     
108. //                        }
     
109. //                }
     
110. //
     
111. //                // 确定学生在班级中的位置
     
112. //                std::vector<Undergraduate>::iterator k = j->u.end();
     
113. //                int TotalScore = iterator->Undergraduate_math + iterator->Undergraduate_English + iterator->Undergraduate_Cscore;
     
114. //                for(auto iter = j->u.begin(); iter != j->u.end(); ++iter)
     
115. //                {
     
116. //                        if(iter->TotalScore < TotalScore)
     
117. //                        {
     
118. //                                k = iter;
     
119. //                                break;
     
120. //                        }
     
121. //                }
     
122. //
     
123. //                Undergraduate u;
     
124. //                u.num = iterator->num;
     
125. //                u.name = iterator->name;
     
126. //                u.sex1 = iterator->sex1;
     
127. //                u.Undergraduate_math = iterator->Undergraduate_math;
     
128. //                u.Undergraduate_English = iterator->Undergraduate_English;
     
129. //                u.Undergraduate_Cscore = iterator->Undergraduate_Cscore;
     
130. //                u.TotalScore = TotalScore;        // 上面已经计算过了
     
131. //                u.Classrank = 0;                // 暂时填0
     
132. //                u.Schoolrank = 0;                // 暂时填0
     
133. //
     
134. //                j->u.insert(k, u);
     
135. //        }
     
136. //}
     
137. 
     
138. // 录入数据
     
139. void InputData(School &s, const std::string profession_name, const std::string classroom_name, const Undergraduate &u)
     
140. {
     
141.         // 确定专业
     
142.         std::vector<Profession>::iterator i = s.pro.end();
     
143.         for(auto iter = s.pro.begin(); iter != s.pro.end(); ++iter)
     
144.         {
     
145.                 if(profession_name == iter->profession_name)
     
146.                 {
     
147.                         i = iter;
     
148.                         break;
     
149.                 }
     
150.         }
     
151. 
     
152.         // 没有就加一个
     
153.         if(i == s.pro.end())
     
154.         {
     
155.                 // 在添加时确保专业是有序的
     
156.                 for(auto iter = s.pro.begin(); iter != s.pro.end(); ++iter)
     
157.                 {
     
158.                         if(iter->profession_name > profession_name)
     
159.                         {
     
160.                                 i = s.pro.insert(iter, Profession{profession_name, std::vector<Classroom>()});
     
161.                                 break;
     
162.                         }
     
163.                 }
     
164. 
     
165.                 // i 任然等于dest.pro.end()，添加到最后
     
166.                 if(i == s.pro.end())
     
167.                 {
     
168.                         s.pro.push_back(Profession{profession_name, std::vector<Classroom>()});
     
169.                         i = s.pro.end() - 1;
     
170.                 }
     
171.         }
     
172. 
     
173.         // 确定班级
     
174.         std::vector<Classroom>::iterator j = i->c.end();
     
175.         for(auto iter = i->c.begin(); iter != i->c.end(); ++iter)
     
176.         {
     
177.                 if(classroom_name == iter->classroom_name)
     
178.                 {
     
179.                         j = iter;
     
180.                         break;
     
181.                 }
     
182.         }
     
183. 
     
184.         // 没有就加一个
     
185.         if(j == i->c.end())
     
186.         {
     
187.                 // 在添加时确保班级是有序的
     
188.                 for(auto iter = i->c.begin(); iter != i->c.end(); ++iter)
     
189.                 {
     
190.                         if(iter->classroom_name > classroom_name)
     
191.                         {
     
192.                                 j = i->c.insert(iter, Classroom{classroom_name, std::vector<Undergraduate>()});
     
193.                                 break;
     
194.                         }
     
195.                 }
     
196. 
     
197.                 // j 任然等于i->c.end()，添加到最后
     
198.                 if(j == i->c.end())
     
199.                 {
     
200.                         i->c.push_back(Classroom{classroom_name, std::vector<Undergraduate>()});
     
201.                         j = i->c.end() - 1;
     
202.                 }
     
203.         }
     
204. 
     
205.         // 确定学生在班级中的位置
     
206.         std::vector<Undergraduate>::iterator k = j->u.end();
     
207.         for(auto iter = j->u.begin(); iter != j->u.end(); ++iter)
     
208.         {
     
209.                 if(iter->TotalScore < u.TotalScore)
     
210.                 {
     
211.                         k = iter;
     
212.                         break;
     
213.                 }
     
214.         }
     
215. 
     
216.         j->u.insert(k, u);
     
217. }
     
218. 
     
219. bool Compare(const std::vector<Undergraduate>::iterator &a, const std::vector<Undergraduate>::iterator &b)
     
220. {
     
221.         return a->TotalScore > b->TotalScore;
     
222. }
     
223. 
     
224. std::string AlignString(std::string s, int length)
     
225. {
     
226.         while(s.length() != length)
     
227.                 s.push_back(' ');
     
228. 
     
229.         return s;
     
230. }
     
231. void DebugPrint(School &s)
     
232. {
     
233. #if 1
     
234.         int length = 15;
     
235. 
     
236.         std::cout << AlignString("校名：", length) << s.school_name << std::endl;
     
237.         for(auto i = s.pro.begin(); i != s.pro.end(); ++i)
     
238.         {
     
239.                 std::cout << "-------------------------" << std::endl;
     
240.                 std::cout << AlignString("专业名：", length) << i->profession_name << std::endl;
     
241.                 std::cout << "-------------------------" << std::endl;
     
242.                 for(auto j = i->c.begin(); j != i->c.end(); ++j)
     
243.                 {
     
244.                         std::cout << "*************************" << std::endl;
     
245.                         std::cout << AlignString("班级名：", length) << j->classroom_name << std::endl;
     
246.                         for(auto k = j->u.begin(); k != j->u.end(); ++k)
     
247.                         {
     
248.                                 std::cout << AlignString("学号：", length)                << k->num << std::endl;
     
249.                                 std::cout << AlignString("姓名：", length)                << k->name << std::endl;
     
250.                                 std::cout << AlignString("性别：", length)                << k->sex1 << std::endl;
     
251.                                 std::cout << AlignString("本科生 高数：", length)        << k->Undergraduate_math << std::endl;
     
252.                                 std::cout << AlignString("本科生 英语：", length)        << k->Undergraduate_English << std::endl;
     
253.                                 std::cout << AlignString("本科生 c语言：", length)        << k->Undergraduate_Cscore << std::endl;
     
254.                                 std::cout << AlignString("总成绩：", length)                << k->TotalScore << std::endl;
     
255.                                 std::cout << AlignString("班级排名：", length)                << k->Classrank << std::endl;
     
256.                                 std::cout << AlignString("校排名：", length)                << k->Schoolrank << std::endl;
     
257.                                 std::cout << std::endl;
     
258.                         }
     
259.                         std::cout << std::endl;
     
260.                 }
     
261.         }
     
262. #else
     
263.         // 另一种输出，按校级排名输出
     
264.         std::vector<std::vector<Undergraduate>::iterator> tmp;
     
265.         for(auto i = s.pro.begin(); i != s.pro.end(); ++i)
     
266.         {
     
267.                 for(auto j = i->c.begin(); j != i->c.end(); ++j)
     
268.                 {
     
269.                         for(auto k = j->u.begin(); k != j->u.end(); ++k)
     
270.                         {
     
271.                                 tmp.push_back(k);
     
272.                         }
     
273.                 }
     
274.         }
     
275. 
     
276.         // 排序
     
277.         std::sort(tmp.begin(), tmp.end(), Compare);
     
278. 
     
279.         int length = 15;
     
280.         for(auto iter = tmp.begin(); iter != tmp.end(); ++iter)
     
281.         {
     
282.                 std::cout << AlignString("学号：", length) << (*iter)->num << std::endl;
     
283.                 std::cout << AlignString("姓名：", length) << (*iter)->name << std::endl;
     
284.                 std::cout << AlignString("性别：", length) << (*iter)->sex1 << std::endl;
     
285.                 std::cout << AlignString("本科生 高数：", length) << (*iter)->Undergraduate_math << std::endl;
     
286.                 std::cout << AlignString("本科生 英语：", length) << (*iter)->Undergraduate_English << std::endl;
     
287.                 std::cout << AlignString("本科生 c语言：", length) << (*iter)->Undergraduate_Cscore << std::endl;
     
288.                 std::cout << AlignString("总成绩：", length) << (*iter)->TotalScore << std::endl;
     
289.                 std::cout << AlignString("班级排名：", length) << (*iter)->Classrank << std::endl;
     
290.                 std::cout << AlignString("校排名：", length) << (*iter)->Schoolrank << std::endl;
     
291.                 std::cout << std::endl;
     
292.         }
     
293. #endif
     
294. }
     
295. // ********************************************************************************************
     
296. 
     
297. 
     
298. // 排名
     
299. void Rank(School &s)
     
300. {
     
301.         // 处理班级排名
     
302.         // 学生在班级中已经是有序的
     
303.         for(auto i = s.pro.begin(); i != s.pro.end(); ++i)
     
304.         {
     
305.                 for(auto j = i->c.begin(); j != i->c.end(); ++j)
     
306.                 {
     
307.                         int count = 0;
     
308.                         for(auto k = j->u.begin(); k != j->u.end(); ++k)
     
309.                         {
     
310.                                 k->Classrank = ++count;
     
311.                         }
     
312.                 }
     
313.         }
     
314. 
     
315.         // 处理校级排名
     
316.         // 我也没有什么好办法^_^
     
317.         std::vector<std::vector<Undergraduate>::iterator> tmp;
     
318.         for(auto i = s.pro.begin(); i != s.pro.end(); ++i)
     
319.         {
     
320.                 for(auto j = i->c.begin(); j != i->c.end(); ++j)
     
321.                 {
     
322.                         for(auto k = j->u.begin(); k != j->u.end(); ++k)
     
323.                         {
     
324.                                 tmp.push_back(k);
     
325.                         }
     
326.                 }
     
327.         }
     
328. 
     
329.         // 排序
     
330.         std::sort(tmp.begin(), tmp.end(), Compare);
     
331. 
     
332.         // 填序号就可以了
     
333.         int count = 0;
     
334.         for(auto iter = tmp.begin(); iter != tmp.end(); ++iter)
     
335.         {
     
336.                 (*iter)->Schoolrank = ++count;
     
337.         }
     
338. }
     
339. 
     
340. // 为了方便，就把所有函数挤在一个cpp文件了
     
341. // 这样好像并不“方便”，目前就这样了
     
342. 
     
343. //static void SetXY(int x, int y)
     
344. //{
     
345. //        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), COORD({(short)x, (short)y}));
     
346. //}
     
347. //
     
348. //static COORD GetXY()
     
349. //{
     
350. //        CONSOLE_SCREEN_BUFFER_INFO csbi;
     
351. //        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
     
352. //        return COORD{csbi.dwCursorPosition.X, csbi.dwCursorPosition.Y};
     
353. //}
     
354. //
     
355. //static void HideCursor()
     
356. //{
     
357. //        HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
     
358. //        CONSOLE_CURSOR_INFO cci;
     
359. //        GetConsoleCursorInfo(hOut, &cci);
     
360. //        cci.bVisible = false;
     
361. //        SetConsoleCursorInfo(hOut, &cci);
     
362. //}
     
363. 
     
364. //void DrawMenu()
     
365. //{
     
366. //        const int WINDOW_X = 180;
     
367. //        const int WINDOW_Y = 45;
     
368. //        const std::string menu_select[] =
     
369. //        {
     
370. //                "1.添加 --- 添加学生信息",
     
371. //                "2.删除 --- 删除学生信息",
     
372. //                "3.修改 --- 修改学生信息",
     
373. //                "4.查看 --- 查看学生信息"
     
374. //        };
     
375. //
     
376. //        for(int y = 0; y < WINDOW_Y - 1; ++y)
     
377. //        {
     
378. //                for(int x = 0; x < WINDOW_X; ++x)
     
379. //                {
     
380. //                        if(((y == 0) || (y == WINDOW_Y - 2)) || ((x == 0) || (x == WINDOW_X - 1)))
     
381. //                        {
     
382. //                                SetXY(x, y);
     
383. //                                std::cout.put('*');
     
384. //                        }
     
385. //                }
     
386. //        }
     
387. //
     
388. //
     
389. //}
     
390. 
     
391. int main()
     
392. {
     
393.         School s = {"校名", std::vector<Profession>()};
     
394.         int count = 5;
     
395.         while(count--)
     
396.         {
     
397.                 std::string profession_name;
     
398.                 std::string classroom_name;
     
399.                 Undergraduate u;
     
400.                 std::cout << "学号：";
     
401.                 std::cin >> u.num;
     
402.                 std::cout << "姓名：";
     
403.                 std::cin >> u.name;
     
404.                 std::cout << "性别：";
     
405.                 std::cin >> u.sex1;
     
406.                 std::cout << "专业：";
     
407.                 std::cin >> profession_name;
     
408.                 std::cout << "班级：";
     
409.                 std::cin >> classroom_name;
     
410.                 std::cout << "本科生 高数：";
     
411.                 std::cin >> u.Undergraduate_math;
     
412.                 std::cout << "本科生 英语：";
     
413.                 std::cin >> u.Undergraduate_English;
     
414.                 std::cout << "本科生 c语言：";
     
415.                 std::cin >> u.Undergraduate_Cscore;
     
416.                 u.TotalScore = u.Undergraduate_math + u.Undergraduate_English + u.Undergraduate_Cscore;
     
417.                 u.Classrank = 0;
     
418.                 u.Schoolrank = 0;
     
419. 
     
420.                 InputData(s, profession_name, classroom_name, u);
     
421.         }
     
422.         Rank(s);
     
423.         DebugPrint(s);
     
424. 
     
425.         //HideCursor();
     
426.         //DrawMenu();
     
427. 
     
428.         //// 学号我就不管了，有重复也不管了，^_^
     
429.         //std::vector<UndergraduateDebug> info_tab =
     
430.         //{
     
431.         //        {0, "学生1", "女", "专业3", "班级2", 70, 50, 20, 0, 0, 0},
     
432.         //        {1, "学生2", "男", "专业1", "班级3", 99, 45, 80, 0, 0, 0},
     
433.         //        {2, "学生3", "男", "专业2", "班级1", 30, 20, 80, 0, 0, 0},
     
434.         //        {3, "学生4", "男", "专业2", "班级2", 20, 40, 60, 0, 0, 0},
     
435.         //        {4, "学生5", "女", "专业1", "班级1", 10, 58, 70, 0, 0, 0},
     
436.         //        {5, "学生6", "女", "专业3", "班级3", 55, 60, 90, 0, 0, 0},
     
437.         //        {6, "学生7", "男", "专业1", "班级1", 75, 57, 62, 0, 0, 0},
     
438.         //        {7, "学生8", "女", "专业3", "班级2", 75, 52, 18, 0, 0, 0},
     
439.         //        {8, "学生9", "男", "专业1", "班级3", 97, 89, 55, 0, 0, 0},
     
440.         //        {9, "学生10", "男", "专业2", "班级1", 35, 21, 88, 0, 0, 0},
     
441.         //        {10, "学生11", "男", "专业2", "班级2", 13, 18, 64, 0, 0, 0},
     
442.         //        {11, "学生12", "女", "专业1", "班级1", 19, 59, 53, 0, 0, 0},
     
443.         //        {12, "学生13", "女", "专业3", "班级3", 59, 51, 52, 0, 0, 0},
     
444.         //        {13, "学生14", "男", "专业1", "班级1", 70, 68, 30, 0, 0, 0}
     
445.         //};
     
446.         //
     
447.         //School s = {"校名", std::vector<Profession>()};
     
448.         //InputDataDebug(s, info_tab);
     
449.         //Rank(s);
     
450.         //DebugPrint(s);
     
451. 
     
452.         return 0;
     
453. }
     

复制代码

1. 学号：0
   
2. 姓名：姓名0
   
3. 性别：男
   
4. 专业：专业0
   
5. 班级：班级0
   
6. 本科生 高数：99
   
7. 本科生 英语：10
   
8. 本科生 c语言：30
   
9. 学号：1
   
10. 姓名：姓名1
    
11. 性别：女
    
12. 专业：专业1
    
13. 班级：班级0
    
14. 本科生 高数：10
    
15. 本科生 英语：2
    
16. 本科生 c语言：32
    
17. 学号：2
    
18. 姓名：姓名2
    
19. 性别：女
    
20. 专业：专业1
    
21. 班级：班级0
    
22. 本科生 高数：12
    
23. 本科生 英语：32
    
24. 本科生 c语言：34
    
25. 学号：3
    
26. 姓名：姓名3
    
27. 性别：男
    
28. 专业：专业0
    
29. 班级：班级0
    
30. 本科生 高数：12
    
31. 本科生 英语：45
    
32. 本科生 c语言：78
    
33. 学号：4
    
34. 姓名：姓名4
    
35. 性别：女
    
36. 专业：专业0
    
37. 班级：班级1
    
38. 本科生 高数：87
    
39. 本科生 英语：65
    
40. 本科生 c语言：43
    
41. 校名：         校名
    
42. -------------------------
    
43. 专业名：       专业0
    
44. -------------------------
    
45. *************************
    
46. 班级名：       班级0
    
47. 学号：         0
    
48. 姓名：         姓名0
    
49. 性别：         男
    
50. 本科生 高数：  99
    
51. 本科生 英语：  10
    
52. 本科生 c语言： 30
    
53. 总成绩：       139
    
54. 班级排名：     1
    
55. 校排名：       2
    
56. 
    
57. 学号：         3
    
58. 姓名：         姓名3
    
59. 性别：         男
    
60. 本科生 高数：  12
    
61. 本科生 英语：  45
    
62. 本科生 c语言： 78
    
63. 总成绩：       135
    
64. 班级排名：     2
    
65. 校排名：       3
    
66. 
    
67. 
    
68. *************************
    
69. 班级名：       班级1
    
70. 学号：         4
    
71. 姓名：         姓名4
    
72. 性别：         女
    
73. 本科生 高数：  87
    
74. 本科生 英语：  65
    
75. 本科生 c语言： 43
    
76. 总成绩：       195
    
77. 班级排名：     1
    
78. 校排名：       1
    
79. 
    
80. 
    
81. -------------------------
    
82. 专业名：       专业1
    
83. -------------------------
    
84. *************************
    
85. 班级名：       班级0
    
86. 学号：         2
    
87. 姓名：         姓名2
    
88. 性别：         女
    
89. 本科生 高数：  12
    
90. 本科生 英语：  32
    
91. 本科生 c语言： 34
    
92. 总成绩：       78
    
93. 班级排名：     1
    
94. 校排名：       4
    
95. 
    
96. 学号：         1
    
97. 姓名：         姓名1
    
98. 性别：         女
    
99. 本科生 高数：  10
    
100. 本科生 英语：  2
     
101. 本科生 c语言： 32
     
102. 总成绩：       44
     
103. 班级排名：     2
     
104. 校排名：       5
     
105. 
     
106. 
     
107. 请按任意键继续. . .

复制代码