#include<iostream>
#include<string>
using namespace std;
class score {
public:
score()
{
times = 2;
cout << "默认学生为2" << endl;
}
score(int times1)
{
times = times1;
cout << "自定学生人数" << endl;
}
~score()
{
cout << "~score" << endl;
}
void inputscore()
{
for (int i = 0; i < times; i++)
{
cout << "输入学生姓名" << endl;
cin >> name[i];
cout << "输入科目A成绩" << endl;
cin >> grade[i][0];
cout << "输入科目B成绩" << endl;
cin >> grade[i][1];
cout << "输入科目C成绩" << endl;
cin >> grade[i][2];
}
}
void showscore()
{
for (int i = 0; i < times; i++)
{
cout << "学生姓名是" << name[i] << endl;
cout << "科目A成绩是" << grade[i][0] << endl;
cout << "科目B成绩是" << grade[i][1] << endl;
cout << "科目C成绩是" << grade[i][2] << endl;
}
}
void showStuAvgScore()
{
//float avg = 0;
for (int i = 0; i < times; i++)
{
float avg = 0;
for (int j = 0; j <= 2; j++)
{
avg = avg + grade[i][j];
}
avg = avg / 3;
cout << name[i] << "同学的平均值是" << avg << endl;
}
}
void showSubAvgScore()
{
float avgA = 0;
float avgB = 0;
float avgC = 0;
for (int i = 0; i < times; i++)
{
avgA = avgA + grade[i][0];
avgB = avgB + grade[i][1];
avgC = avgC + grade[i][2];
}
avgA = avgA / times;
avgB = avgB / times;
avgC = avgC / times;
cout << "科目A的平均分是" << avgA << endl;
cout << "科目B的平均分是" << avgB << endl;
cout << "科目C的平均分是" << avgC << endl;
}
void sortSub()
{
float temp;
for (int i = 0; i <= 2; i++)
{
for (int j = 1; j < times; j++)
{
if (grade[j][i] > grade[j - 1][i])
{
temp = grade[j][i];
grade[j][i] = grade[j - 1][i];
grade[j - 1][i] = temp;
}
}
for (int j = 0; j < times; j++)
{
cout << grade[j][i] << " ";
}
cout << endl;
}
}
private:
float grade[100][100];
int times;
string name[100];
};
int main()
{
score x;
x.inputscore();
x.showscore();
x.showStuAvgScore();
x.showSubAvgScore();
x.sortSub();
}代码如上！
代码实现情况为
?
.冒泡法排序：
从第一个和第二个开始比较，如果第一个比第二个大，则交换位置，然后比较第二个和第三个，逐渐往后
经过第一轮后最大的元素已经排在最后，所以重复上述操作的话第二大的则会排在倒数第二的位置。
那重复上述操作n-1次即可完成排序，因为最后一次只有一个元素所以不需要比较。
代码实现如下：
void score::sortSub()
?? ?{
?? ??? ?float temp;
?? ??? ?for (int i = 0; i <= 2; i++)
?? ??? ?{
?? ??? ??? ?for (int j = 1; j < times; j++)
?? ??? ??? ?{
?? ??? ??? ??? ?if (grade[j][i] > grade[j - 1][i])
?? ??? ??? ??? ?{
?? ??? ??? ??? ??? ?temp = grade[j][i];
?? ??? ??? ??? ??? ?grade[j][i] = grade[j - 1][i];
?? ??? ??? ??? ??? ?grade[j - 1][i] = temp;
?? ??? ??? ??? ?}
?
?? ??? ??? ?}
?? ??? ??? ?for (int j = 0; j < times; j++)
?? ??? ??? ?{
?? ??? ??? ??? ?cout << grade[j][i] << " ";
?? ??? ??? ?}
?? ??? ??? ?cout << endl;
? ? ? ? 冒泡排序是一种简单直接暴力的排序算法，每一轮比较可能多个元素移动位置，而元素位置的互换是需要消耗资源的，所以这是一种偏慢的排序算法，仅适用于对于含有较少元素的数列进行排序。
? ? ? 稳定性：我们从代码中可以看出只有前一个元素大于后一个元素才可能交换位置，所以相同元素的相对顺序不可能改变，所以它是稳定排序。
? ? ? 比较性：因为排序时元素之间需要比较，所以是比较排序。
? ? ? 时间复杂度：因为它需要双层循环n*(n-1))，所以平均时间复杂度为O(n^2)。
? ? ? 空间复杂度：只需要常数个辅助单元，所以空间复杂度为O(1)，我们把空间复杂度为O(1)的排序成为原地排序（in-place）。
原文链接：https://blog.csdn.net/CTO_51/article/details/8852971
?原文链接：https://blog.csdn.net/LbinBB/article/details/89231346
原文链接：https://blog.csdn.net/LbinBB/article/details/89231346