实验三（引用和结构体）

A. OOP 交换（指针+引用）

题目描述

首先使用传递指针参数的函数swap1()实现两数据的交换，

再使用传递引用参数的函数swap2()实现两数据的交换

输入

见样例

输出

见样例

 

#include<iostream>
using namespace std;

void swap1(int *p1,int *p2);
void swap2(int &r1,int &r2);
int main()
{
    int a,b;
    cin>>a>>b;
    swap1(&a,&b);
    cout<<"swap1:"<<a<<" "<<b<<endl;
    swap2(a,b);
    cout<<"swap2:"<<a<<" "<<b<<endl;
    return 0;
}
void swap1(int *p1,int *p2)
{
    int t;
    t=*p1,*p1=*p2,*p2=t;
}
void swap2(int &r1,int &r2)
{
    int t;
    t=r1,r1=r2,r2=t;
}

B. 三数论大小（引用）

题目描述

输入三个整数，然后按照从大到小的顺序输出数值。

要求：定义一个函数，无返回值，函数参数是三个整数参数的引用，例如int &a, int &b, int &c。在函数内通过引用方法来对三个参数进行排序。主函数调用这个函数进行排序。

要求：不能直接对三个整数进行排序，必须通过函数而且是引用的方法。

输入

第一行输入t表示有t个测试实例

第二行起，每行输入三个整数

输入t行

输出

每行按照从大到小的顺序输出每个实例，三个整数之间用单个空格隔开

 

#include<iostream>
using namespace std;
void sort(int &a,int &b,int &c);
int main()
{
    int j,k,l,t;
    cin>>t;
    while(t--)
    {
        cin>>j>>k>>l;
        sort(j,k,l);
        cout<<j<<" "<<k<<" "<<l<<endl;
    }
 } 
void sort(int &a,int &b,int &c)
{
    int t;
    if(a<b)
        t=a,a=b,b=t;
    if(b<c)
        t=b,b=c,c=t;
    if(a<b)
        t=a,a=b,b=t;
}

C. 求最大值最小值（引用）

题目描述

编写函数void find(int *num,int n,int &minIndex,int &maxIndex)，求数组num(元素为num[0]，num[1]，...，num[n-1]）中取最小值、最大值的元素下标minIndex,maxIndex（若有相同最值，取第一个出现的下标。）

输入n，动态分配n个整数空间，输入n个整数，调用该函数求数组的最小值、最大值下标。最后按样例格式输出结果。

改变函数find功能不计分。

输入

测试次数

每组测试数据一行：数据个数n，后跟n个整数

输出

每组测试数据输出两行，分别是最小值、最大值及其下标。具体格式见样例。多组测试数据之间以空行分隔。

#include<iostream>
using namespace std;
#include<cmath>
void find(int *num,int n,int &minIndex,int &maxIndex);

int main()
{
    int t,n,*a,i,minIndex,maxIndex;
    cin>>t;
    while(t--)
    {
        cin>>n;
        a=new int[n];
        for(i=0;i<n;i++)
            cin>>a[i];
        find(a,n,minIndex,maxIndex);
        cout<<"min="<<a[minIndex]<<" minIndex="<<minIndex<<endl;
        cout<<"max="<<a[maxIndex]<<" maxIndex="<<maxIndex<<endl;
        cout<<endl;
        delete []a;
    }
    return 1;
}
void find(int *num,int n,int &minIndex,int &maxIndex)
{
    int i;
    minIndex=maxIndex=0;
    for(i=1;i<n;i++)
    {
        if(num[i]>num[maxIndex])
            maxIndex=i;
        if(num[i]<num[minIndex])
            minIndex=i;
    }
}

 

D. 访问数组元素（引用）

题目描述

输入n，输入n个数，计算n个数的和并输出。

假设主函数定义如下，不可修改。请补齐put函数。

输入

测试次数

每组测试数据一行，正整数n（1~1000），后跟n个整数。

输出

每组测试数据输出一行，即n个整数的和。

 

#include<iostream>
using namespace std;
#include<cstring>

#define N 1000
int &put(int *num,int i);
int main()
{
    int num[N];
    int t,n,sum,i;
    cin>>t;
    while(t--)
    {
        cin>>n;
        for(i=0;i<n;i++)
            cin>>put(num,i);
        for(sum=0,i=0;i<n;i++)
            sum+=num[i];
        cout<<"sum="<<sum<<endl;
    }
    return 0;
}

int &put(int *num,int i)
{
    return num[i];
}

 

E. OOP 学生成绩排序(结构)

题目描述

有N个学生的数据，将学生数据按成绩由低到高排序，如果成绩相同则按姓名首字母序排序，如果首字母也相同则按照年龄排序，并输出N个学生排序后的信息。

输入

测试数据有多组，每组输入第一行有一个整数N（N<=1000），接下来的N行包括N个学生的数据。
每个学生的数据包括姓名（长度不超过100的字符串）、年龄（整型数）、成绩（小于等于100的正数）。

输出

将学生信息按成绩进行排序，成绩相同的则按姓名的字母序进行排序。
然后输出学生信息，按照如下格式：
姓名 年龄 成绩

#include<iostream>
using namespace std;
#include<algorithm>
#include<cstring>
struct student
{
    char name[20];
    int age,score;
};
int comp(student s1,student s2);
int main()
{
    int N,i;
    cin>>N;
    student *stu=new student[N];
    for(i=0;i<N;i++)
        cin>>stu[i].name>>stu[i].age>>stu[i].score;

    sort(stu,stu+N,comp);
    for(i=0;i<N;i++)
        cout<<stu[i].name<<" "<<stu[i].age<<" "<<stu[i].score<<endl;

    delete [] stu;
    return 0;
}

int comp(student s1,student s2)
{
    if(s1.score<s2.score)
        return 1;

    if(s1.score==s2.score && strcmp(s1.name,s2.name)<0)
        return 1;

    if(s1.score==s2.score && strcmp(s1.name,s2.name)==0 && s1.age>s2.age)
        return 1;

    return 0;
}

 

F. 分数四则运算(结构)

题目描述

分数的分子和分母可用一个结构类型来表示。

编写实现两个分数加(addFS)，减(subFS)，乘(mulFS)，除(divFS)的函数(要求计算结果分数是简化的)，以及打印一个分数(printFS)，计算两个整数最大公约数的函数(getGCD)。

注意：不能定义全局变量

输入

测试数据的组数 t

第一组第一个分数

第一组第二个分数

第二组第一个分数

第二组第二个分数

......

输出

第一组两个分数的和

第一组两个分数的差

第一组两个分数的积

第一组两个分数的商

第二组两个分数的和

第二组两个分数的差

第二组两个分数的积

第二组两个分数的商

......

#include<iostream>
using namespace std;
#include<cmath>
struct FS
{
    int fz,fm;
};
int gcd(int a,int b);
FS addFS(FS f1,FS f2);
FS subFS(FS f1,FS f2);
FS mulFS(FS f1,FS f2);
FS divFS(FS f1,FS f2);
void printFS(FS f);
int main()
{
    int t;
    FS f1,f2,f;
    char ch;
    cin>>t;
    while(t--)
    {
        cin>>f1.fz>>ch>>f1.fm;
        cin>>f2.fz>>ch>>f2.fm;
        f=addFS(f1,f2);
        printFS(f);
        f=subFS(f1,f2);
        printFS(f);
        f=mulFS(f1,f2);
        printFS(f);
        f=divFS(f1,f2);
        printFS(f);
        cout<<endl;
    }
    return 1;
}
int gcd(int a,int b)
{
    int r=a%b;
    while(r)
    {
        a=b;
        b=r;
        r=a%b;
    }
    return b;
}
FS addFS(FS f1,FS f2)
{
    FS f;
    f.fm=f1.fm*f2.fm;
    f.fz=f1.fz*f2.fm+f1.fm*f2.fz;
    int t=gcd(abs(f.fm),abs(f.fz));
    if(t!=1)
    {
        f.fm=f.fm/t;
        f.fz=f.fz/t;
    }
    return f;
}
FS subFS(FS f1,FS f2)
{
    FS f;
    int t;
    f.fm=f1.fm*f2.fm;
    f.fz=f1.fz*f2.fm-f2.fz*f1.fm;
    if((t=gcd(abs(f.fm),abs(f.fz)))!=1)
    {
        f.fm=f.fm/t;
        f.fz=f.fz/t;
    }
    return f;
}
FS mulFS(FS f1,FS f2)
{
    FS f;
    int t;
    f.fm=f1.fm*f2.fm;
    f.fz=f1.fz*f2.fz;
    if((t=gcd(abs(f.fm),abs(f.fz)))!=1)
    {
        f.fm=f.fm/t;
        f.fz=f.fz/t;
    }
    return f;
}
FS divFS(FS f1,FS f2)
{
    FS f;
    int t;
    f.fz=f1.fz*f2.fm;
    f.fm=f1.fm*f2.fz;
    if((t=gcd(abs(f.fm),abs(f.fz)))!=1)
    {
        f.fm=f.fm/t;
        f.fz=f.fz/t;
    }
    return f;
}
void printFS(FS f)
{
    if(f.fm*f.fz>0)
        cout<<abs(f.fz)<<"/"<<abs(f.fm)<<endl;
    else
        cout<<"-"<<abs(f.fz)<<"/"<<abs(f.fm)<<endl;
}

G. 扑克牌排序（结构体）

题目描述

自定义结构体表示一张扑克牌，包含类型——黑桃、红桃、梅花、方块、王；大小——2,3,4,5,6,7,8,9,10,J,Q,K,A,小王(用0表示）、大王（用1表示）。输入n，输入n张扑克牌信息，从大到小输出它们的排序结果。

假设扑克牌的排序规则是大王、小王为第一大、第二大，剩余52张扑克牌按照先花色后大小排序。

花色：黑桃>红桃>梅花>方块。

大小: A>K>Q>J>>10>9>...>2。

提示：百度sort函数、strstr函数使用。

输入

测试次数t

每组测试数据两行：

第一行：n，表示输入n张扑克牌

第二行：n张扑克牌信息，格式见样例

输出

对每组测试数据，输出从大到小的排序结果

#include<iostream>
using namespace std;
#include<algorithm>
#include<string>
struct card
{
	string face;
    int num;
};
bool compCard(card c1,card c2);
int main()
{
	string num[13]={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
	string type[6]={"方块","梅花","红桃","黑桃","小王","大王"};
	string str;
	card poker[54];
	int t,n,i,j;
	cin>>t;
	while(t--)
	{
		cin>>n;
		for(i=0;i<n;i++)
		{
			cin>>str;
			poker[i].face=str;
			poker[i].num=0;
			for(j=0;j<6;j++)
				if((int)str.find(type[j])!=-1)
				{	poker[i].num+=j*13;break;}
			for(j=0;j<13;j++)
				if((int)str.find(num[j])!=-1)
				{	poker[i].num+=j;break;}
		}
		sort(poker,poker+n,compCard);
		for(i=0;i<n-1;i++)
			cout<<poker[i].face<<" ";
		cout<<poker[i].face<<endl;
	}
	return 0;
}
bool compCard(card c1,card c2)
{
	return c1.num>c2.num;
}