第7周中级练习(dehuiwf)

1指针实现向量的内积计算（10分）
题目内容：

两个向量a = [a1, a2,…, an]和b = [b1, b2,…, bn]的内积定义为：

a·b=a1b1+a2b2+……+an*bn

编写函数，使用指针实现两个向量的内积的计算。要求函数中不出现下标运算。

编写主函数，分别输入两个向量，均以-9999为结束标志，维数相同。调用函数计算内积，在主函数中输出。向量为实数向量，维数不超过100。

输入格式：

两行用空格隔开的实数，每行以-9999为结束标志。

输出格式：

一个实数。

输入样例：

1 2 3 -9999

4 5 6 -9999

输出样例：

32

//指针实现向量的内积计算
#include<iostream>
using namespace std;
double product(double a[],double b[]);
int main()
{
	double a[100];
	double b[100];
	cin >> a[0];
	int i = 0;
	while (a[i] != -9999)
	{
		i++;
		cin >> a[i];
	}
	i = 0;
	cin >> b[0];
	while (b[i] != -9999)
	{
		i++;
		cin >> b[i];
	}
	cout << product(a, b) << endl;
	return 0;
}
double product(double a[], double b[])
{
	double sum = 0;
	double* p = a, * q = b;
	while (*p != -9999)
	{
		sum += (*p) * (*q);
		q++;
		p++;
	}
	return sum;
}

2使用指针的插入排序（10分）
题目内容：

编写函数，使用指针对一维整型数组进行插入排序。要求函数中不出现下标运算。

编写主函数，输入若干整数，以-9999为结束标志。调用函数排序，在主函数中输出。元素总个数不超过100个。

输入格式：

若干用空格隔开的整数，以-9999为结束标志。

输出格式：

用空格隔开的从小到大排序的整数，用空格隔开，末尾无空格。

输入样例：

20 4 3 10 34 -9999

输出样例：

3 4 10 20 34

//使用指针的插入排序
#include<iostream>
using namespace std;
void sort(int *,int);
int main()
{
	int a[100];
	int i = 0;
	for (i = 0; i < 101; i++)
	{
		cin >> a[i];
		if (a[i] == -9999)
			break;
	}//此时数组有i个元素
	sort(a,i);
	cout << a[0];
	for (int j = 1; j < i; j++)
		cout << " " << a[j];
	return 0;
}
void sort(int* arr, int len)
{
	int tmp;
	int i;
	int j;
	for (i = 1; i < len; i++)
	{
		tmp = arr[i];
		for (j = i - 1; j >= 0 && arr[j] > tmp; j--)
		{
			arr[j + 1] = arr[j];
		}
		arr[j + 1] = tmp;
	}
}

3指针实现成绩排序（10分）
题目内容：

编写函数，使用指针对学生成绩单进行冒泡排序，从小到大。成绩单的内容包括学号和成绩，学号和成绩都是整数，成绩相同时学号小的在前。要求函数中不出现下标运算。

编写主函数，输入若干学生的学号和成绩，以0 0 为结束标志。调用函数排序，在主函数中输出。学生总人数不超过100个。

输入格式：

若干行，每行是一个学生的学号和成绩，用空格隔开。以最后一行是0 0 ,为结束标志。

输出格式：

若干行，按成绩从大到小排序的名单。每行是一个学生的学号和成绩，用一个空格隔开。

输入样例：

1 81

2 62

3 67

0 0

输出样例：

2 62

3 67

1 81

//指针实现成绩排序
#include<iostream>
using namespace std;
struct STU {
	int num;
	int grade;
};
void sort( STU a[]);
int main()
{
	STU a[101];
	cin >> a[0].num >> a[0].grade;
	int i = 0;
	while (a[i].num != 0 || a[i].grade != 0)
	{
		i++;
		cin >> a[i].num >> a[i].grade;
	}
	sort(a);
	for (int j = 0; j < i; j++)
		cout << a[j].num << " " << a[j].grade << endl;
	return 0;
}
void sort(STU a[])
{
	bool flag;
	do {
		struct STU* p = a;
		 flag = 0;
		while ((p + 1)->num != 0 && (p + 1)->grade != 0)
		{
			if ((p->grade > (p + 1)->grade) || ((p->grade == (p + 1)->grade) && (p->num > (p + 1)->num)))
			{
				STU  temp = *p;
				*p = *(p + 1);
				*(p + 1) = temp;
				flag = 1;
			}
			p++;
		}
	} while (flag);
}

4计算函数在某点的近似导数（10分）
题目内容：

设函数在x的近似导数为：

                                           ,其中δ=0.001

编写计算函数在某点近似导数的通用函数。

编写主函数，输入自变量x的值，调用函数名，计算sin(x),cos(x),sin(x)+cos(x)在该点的近似导数。数据类型用double。

输入格式：

一个实数

输出格式：

三个实数，用空格隔开。

输入样例：

1.57

输出样例：

0.000796327 -1 -0.999203

//计算函数在某点的近似导数
#include<iostream>
#include<cmath>
#define N 0.001
using namespace std;
double f_(double (*f)(double), double x)
{
 return ((*f)(x + N) -	 (*f)(x - N)) / 2 / N;
}
double sc(double x)
{
 return sin(x) + cos(x);
}
int main()
{
 double x;
 double (*pf)(double);
 cin >> x;
 pf = sin;
 cout << f_(pf, x) << " ";
 pf = cos;
 cout << f_(pf, x) << " ";
 pf = sc;
 cout << f_(pf, x) << endl;
 return 0;
}

5计算函数在指定区间的近似积分（10分）
题目内容：

设函数在区间[a,b]的近似积分公式为：

其中δ=（b-a）/n，n=100。

编写计算函数在某区间近似积分的通用函数，积分计算使用上述公式。

编写主函数，输入积分区间a,b，调用函数，计算sin(x),cos(x),sin(x)+cos(x)在[a,b]的近似积分。数据类型用double。

输入格式：

两个实数，表示积分区间。

输出格式：

三个实数，用空格隔开，表示三个函数在指定区间的积分近似值。

输入样例：

0 3.14

输出样例：

1.99981 0.0329925 2.0328

//计算函数在指定区间的近似积分
#include<iostream>
#include<cmath>
using namespace std;
#define N 100
double f_(double (*f)(double), double a, double b)
{
	double delta = (b - a) / N;
	double sum = 0;
	for (int i = 0; i <= N - 1; i++)
		sum += delta * (*f)(a + i * delta);
	return sum;
}
double sc(double x)
{
	return sin(x) + cos(x);
}
int main()
{
	double a, b;
	double (*pf)(double);
	cin >> a >> b;
	pf = sin;
	cout << f_(pf, a, b) << " ";
	pf = cos;
	cout << f_(pf, a, b) << " ";
	pf = sc;
	cout << f_(pf, a, b) << endl;
	return 0;
}