天津大学C++上机考试复习题Word格式文档下载.docx
《天津大学C++上机考试复习题Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《天津大学C++上机考试复习题Word格式文档下载.docx（14页珍藏版）》请在冰豆网上搜索。
inti,j,k;
for（i=1;
n;
k=x[i];
j=i;
//把待排序元素存入中间变量，设置插入指针j
while（k<
x[j-1]&
&
j>
0）{
x[j]=x[j-1];
//后移
j--;
x[j]=k;
//插入
2.定义一个二维数组a并用下列数据初始化。
输入一个数，在数组中进行顺序查找，找到时输出该数的下标，否则输出“没有找到”（用查找函数intseqsearch（inta[][6],intx,int&
m,int&
n）完成）。
编写一个直接选择排序函数voidselect（intx[],intm,intn）对每一行元素排序，输出排序后的数组。
//两种传递二维数组的方式
intseqsearch（inta[][6],intx,int&
n）;
//顺序查找函数，二维数组作形参，6不可省略！
voidselect（intx[],intm,intn）;
//直接选择排序。
一维数组作形参，因需处理二维数组，故要传递行列数mn
inta[4][6]={{12,34,38,20,82,17},
{30,18,25,13,56,21},
{45,39,15,24,19,32},
{11,76,40,41,64,43},
};
inti,j,x,m,n;
输入需查找的数：
cin>
>
x;
if（seqsearch（a,x,m,n））cout<
（i,j）="
m<
"
n<
endl<
//注意：
形参是二维数组，须用数组名a作实参
elsecout<
没有找到\n\n"
select（a[0],4,6）;
//调用排序函数，降阶处理：
采用一维形式处理二维数组。
（因此须用一维数组名a[0]作实参）
//由于一次性传递整个数组，故效率高，是处理二维数组更为普遍的方式。
要求对数组有较深入的了解。
voidselect（intx[],intm,intn）{
inth,i,j,k,t;
for（h=0;
h<
m;
h++）{//h为需处理的行数（把数组x看作一行一行一字排开一维数组）
n-1;
i++）{//直接选择排序算法，对一行（n个数）排序
k=i;
//设置交换指针k
for（j=i+1;
j++）
if（x[j]<
x[k]）k=j;
//记录最小值元素的下标
t=x[i];
x[i]=x[k];
x[k]=t;
//与待排序元素x[i]交换
x+=n;
//降阶处理的要点：
由于数组名x是指针（变量），使它指向下一行。
n）{//顺序查找函数（挨个比较），找到返回1，否则返回0，下标由引用返回
inti,j,ok=0;
4&
!
ok;
i++）//双重循环条件：
找到一个即停止循环，否则一直找到底
if（a[i][j]==x）{
ok=1;
m=i;
n=j;
break;
//找到！
置ok为1，并记录下标。
注意：
函数中的mn是主函数中mn的引用（在不同函数中可以同名）
returnok;
//如没找到，ok保持为0
3.定义一个二维数组a并用下列数据初始化。
编写冒泡排序函数voidbubble（intx[],intn，float&
av）对每一行元素排序，并计算每行元素的平均值。
在main函数中输出原数组、按行输出排序后的数组及平均值。
把平均值存到一个一维数组aver中）
voidbubble（intx[],intn,float&
av）;
inti,j;
floataver[4]={0};
i++）bubble（a[i],6,aver[i]）;
//注意3个实参：
a[i],6是数组名和长度，传递二维数组的一行，
//aver[i]是数组元素（相当于简单变量），地址传给引用形参av
aver[i]<
voidbubble（intx[],intn,float&
av）{//一维数组冒泡排序函数
inti=0,j,k=1,t;
while（k）{//冒泡算法
k=0;
//设置逆序标志k（同时也是循环条件，1为有逆序，0为无逆序）
n-1-i;
j++）
if（x[j]>
x[j+1]）{//出现逆序
k=1;
t=x[j];
x[j]=x[j+1];
x[j+1]=t;
//重置k，交换逆序数对
i++;
i++）av+=x[i];
//同时计算每行的平均值并由av回传
av=av/n;
4.定义一个二维数组inta[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}。
定义函数intlsum（intx[],intn,int&
sum）返回每行元素之和并求所有元素之和，要求该函数中使用静态局部变量s存储二维数组总和。
按行输出数组及每行之和，最后输出总和。
定义数组voidexch（intx[][4],intn）其功能是转置该数组并作如上操作。
iomanip.h>
intlsum（intx[],int,int&
）;
//求和函数，返回每行之和。
voidexch（intx[][4],int）;
//转置函数
inta[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
inti,j,sum;
sum=0;
setw（3）<
a[i][j];
setw（7）<
lsum（a[i],4,sum）;
total:
sum<
exch（a,4）;
//这句必须吗？
intlsum（intx[],intn,int&
sum）{
inti,t=0;
statics;
//静态变量记录总和
if（!
sum）s=0;
//等价于sum==0，去掉这句行吗？
t+=x[i];
s+=x[i];
sum=s;
//总和由引用sum返回
returnt;
voidexch（intx[][4],intn）{
inti,j,t;
i++）
for（j=i;
j++）if（i==j）continue;
else{
t=x[i][j];
x[i][j]=x[j][i];
x[j][i]=t;
5.编写求组合的程序，在主函数中输入任意两个正整数n，m求其组合。
使用递归函数求阶乘。
longfact（intx）;
intc,m,n,t;
m>
if（m<
n）{
t=m;
m=n;
n=t;
c=fact（m）/fact（n）/fact（m-n）;
Comb（"
"
）="
c<
longfact（intx）{
longf;
if（x==0）f=1;
elsef=x*fact（x-1）;
returnf;
6.定义一个整型数组a[]={11,27,19,23,15,27,19,11,13,13,13,17}，并且定义一个函数，intdel（intx[],int&
m），该函数的功能为删除数组中所有重复的元素，并返回所删除元素的个数。
输出原数组，和删除后的数组，分别用一行四位宽度输出，并输出所删除元素的个数c。
intdel（intx[],int&
m）;
inta[]={11,27,19,23,15,27,19,11,13,13,13,17};
inti,n=12,c=0;
setw（4）<
a[i];
c=del（a,n）;
elementsdeleted.\n\n"
m）{//删除相同元素函数，返回删除个数，由于有元素的删除，所以数组长度m要相应改变，并回传
inti,j,k,c=0;
//算法：
用x[i]与后面的元素逐个比较x[j]，有相同元素，则由j开始将后面的元素逐个前移（删除x[j]）
m-1;
if（x[i]==x[j]）{
x[j]<
//显示删除的元素
for（k=j;
k<
k++）x[k]=x[k+1];
//数组长m度减1，比较指针j减1（因为循环语句中j++）使之指在原处，计数器c加1
m--;
c++;
returnc;
7.在一个有序整型数组{2,4,6,8,10,12,14,16,18}中，输入一个数k，如果是奇数，则插入，插入后数组仍保持有序。
编写二分查找函数intbisearch（inta[],intn,intb）返回一个任意输入整数a的下标。
要求输出原数组，插入后的数组，分别用一行四位宽度输出。
并输出所查找数的下标，若没找到则输出“该数不存在”。
intbisearch（inta[],intn,intb）;
intx[20]={2,4,6,8,10,12,14,16,18};
//因为要插入数据，数组定义要比实际数据大
intn=9,i,j,k,a;
x[i];
do{
请输入一个数:
k;
}while（k%2==0）;
i=n;
x[i-1]&
i>
0）{//插入方法：
k从最后一个数开始比较，小则把数组元素后移
x[i]=x[i-1];
i--;
//i为插入指针（下标）
x[i]=k;
n++;
//插入，不要忘记数组长度增加！
输入待查找的整数：
a;
if（（j=bisearch（x,n,a））>
=0）cout<
该数下标为：
j<
该数不存在！
intbisearch（inta[],intn,intb）{//二分查找函数：
要求待查序列必须是排序好的！
intl=0,h=n-1,m;
while（l<
=h）{//循环条件：
低边界小于等于高边界
m=（l+h）/2;
//二分
if（a[m]==b）break;
elseif（b<
a[m]）h=m-1;
//待查数据在低区，左移高边界
elsel=m+1;
//待查数据在高区，右移低边界
if（l>
h）return-1;
//没找到，返回-1（不存在的下标）
elsereturnm;
//找到，返回该数下标
8.在主函数中定义一个字符串“WearelearningC++language.C++isuseful.”并显示。
输入一个字符串（如“Fortran95”）替换句中的“C++”。
定义函数voidexch（char*）将其倒序。
输出替换及倒序后的字符串。
使用指针操作完成倒序运算。
//字符串的操作练习，并熟悉常用字符串函数的用法
string.h>
voidexch（char*）;
chars0[80]="
WearelearningC++language.C++isuseful."
charst[80],s1[20],*sp;
intn,i;
s0<
输入一个字符串:
cin.getline（s1,20）;
//输入字符串的方式（可含空格）
n=strlen（s1）;
//测定输入字符串的长度（字符数）
for（i=0,sp=s0;
*sp;
i++,sp++）//工作指针sp指向初始字符串s0逐个字符查找"
C++"
（子字符串）
if（strncmp（sp,"
3）==0）{//找到，（sp所指字串前3个字符为"
）
strcpy（st,sp+3）;
//把"
后面的内容复制到数组st（保护起来）
strcpy（sp,s1）;
//用输入的字符串s1替换"
及其以后的内容，sp也可写为s0+i
sp+=n-1;
i+=n-1;
//把指针以及下标值置于替换后字符串尾部
strcat（sp,st）;
//把保存在st中原字符串的其余部分再复制回来，完成一次替换。
继续如上过程替换后面的"
exch（s0）;
voidexch（char*str）{//倒序函数
char*p,*q,c;
p=str;
q=p+strlen（str）-1;
//工作指针p指向字符串str首字符，q指向尾字符
while（p<
q）{
c=*p;
*p=*q;
*q=c;
p++;
q--;
9.定义一个字符串常量，并判断该字符串是否为“回文”。
定义一个顺序栈charst[]，编写入栈、出栈函数（voidpush（char*st,charc,int&
top）,charpop（char*st,int&
top），利用栈结构的性质完成该判断。
//堆栈：
一种数据结构，规定只能在一端进行插入和删除数据（类似子弹夹），最后入栈的元素最先出栈
voidpush（char*st,charc,int&
top）;
charpop（char*st,int&
char*p="
madam"
*q=p,s[20];
intt=-1;
//设置空栈指针（数组下标）
while（*q）{//把指针q所指字符逐个压入堆栈s中
push（s,*q,t）;
q++;
q=p;
//重要！
重置指针q
q;
while（t>
=0&
*q==pop（s,t））q++;
//正向*q，逆向pop（s,t）逐个字符比较字符串，若完全相同（至t<
0）则为回文
if（t<
0）cout<
是回文!
\n"
不是回文!
top）{//入栈函数
top++;
//栈顶指针（栈顶元素的下标）上移
st[top]=c;
//将字符c压入栈中（入栈一个元素）
top）{//出栈函数，返回栈顶元素
charc=st[top];
//栈顶元素初始化c
top--;
//栈顶指针下移，（出栈一个元素）
10.输出1900–2100的所有闰年，要求每年7位宽度（每行10年）。
输入一个日期：
年（1900–2100）、月、日，求该日期为本年的第几天。
编写返回每月天数的函数，并对输入的年、月、日进行合理性检测。
intmd（int,int）;
inlineintly（intyear）{return（year%400==0||year%4==0&
year%100!
=0）;
inty,m,d,yd,i,k=1;
for（i=1900;
=2100;
if（ly（i））{
i;
if（k++%10==0）cout<
cout<
\n请输入年、月、日（yyyymmdd）：
y>
d;
}while（!
（y>
=1900&
y<
=2100&
m>
0&
m<
13&
d>
d<
=md（y,m）））;
//输入合法性检测
yd=d;
//当月的天数
i++）yd+=md（y,i）;
//累加前几个月的天数
是"
y<
年的第"
yd<
天\n"
intmd（intyear,intmonth）{//返回任意一个月份的天数
intn;
switch（month）{
case4:
case6:
case9:
case11:
n=30;
case2:
if（ly（year））n=29;
elsen=28;
default:
n=31;
returnn;
升级会员 