C语言程序设计实验第六次上机实验报告.docx
《C语言程序设计实验第六次上机实验报告.docx》由会员分享，可在线阅读，更多相关《C语言程序设计实验第六次上机实验报告.docx（42页珍藏版）》请在冰豆网上搜索。
C语言程序设计实验第六次上机实验报告
7.第六次实验
C语言程序设计实验报告
专业计算机科学与技术班级信安1302班日期2014.5.24成绩
实验组别第6次实验指针实验&结构与联合实验指导教师
学生姓名学号同组人姓名
实验名称指针实验&结构与联合实验
7.1实验目的
1.熟练掌握指针的说明、赋值、使用。
2.掌握用指针引用数组的元素，熟悉指向数组的指针的使用。
3.熟练掌握字符数组与字符串的使用，掌握指针数组及字符指针数组的用法。
4.掌握指针函数与函数指针的用法。
5.掌握带有参数的main函数的用法。
6.熟悉和掌握结构的说明和引用,结构的指针，结构数组，以及函数中使用结构的方法。
7.掌握动态储存分配函数的用法，掌握自引用结构和单向链表的创建，遍历，结点的增删，查找等操作。
8.了解字段结构和联合的用法。
7.2实验内容
（一）设计一个函数reverse（a,n），将一维数组a的值逆置。
如，逆置前，A：
20、10、90、59、60、80、70，
逆置后，A：
70、80、60、59、90、10、20。
源程序如下：
shangji6\chengxu29
#include
voidsort（int*a,intn）;
intmain（）
{
intx[100],n,i,*p=x;
printf（"entern:
"）;
scanf（"%d",&n）;
printf（"enternumbers:
"）;
for（i=0;iscanf（"%d",p+i）;
sort（x,n）;
for（i=0;iprintf（"%4d",*（p+i））;
return0;
}
voidsort（int*a,intn）
{
inti,j,t;
for（i=0;i{
for（j=0;j{
t=*（a+j）;*（a+j）=*（a+j+1）;*（a+j+1）=t;
}
}
}
实验步骤：
1.定义一个数组存放数据，实现数据的输入和存储。
2.定义一个子函数进行排序，用把数据两两交换来实现。
调试及编译过程：
测试数据：
任意选取一组数据：
出现的不足及修改：
无运行结果：
出现预期的结果。
（二）设计一个函数BubbleSort（a,n），采用冒泡排序算法，实现一维数组的整数进行排序的功能。
源程序如下：
shangji6\chengxu30
#include
voidBubbleSort（int*a,intn）;
intmain（）
{
inta[100],n,i;
printf（"entern:
"）;
scanf（"%d",&n）;
printf（"enternumbers:
"）;
for（i=0;iscanf（"%d",&a[i]）;
BubbleSort（a,n）;
for（i=0;iprintf（"%6d",a[i]）;
return0;
}
voidBubbleSort（int*a,intn）
{
intt,*p=a,i,j;
for（i=0;i{
for（j=0;j{
if（*（p+j）>*（p+j+1））
{
t=*（p+j）;*（p+j）=*（p+j+1）;*（p+j+1）=t;
}
}
}
}
实验步骤：
1.定义数组实现数据的输入和存放。
2.定义一个子函数实现数据的冒泡法排序。
调试及编译过程：
测试数据：
任意选取一组数据（按从小到大顺序排列）
测试数据：
任意选取一组数据（按任意顺序排列）
出现的不足及修改：
无运行结果：
出现预期的结果。
（三）设计一个一个函数find（a,n,x），实现对在一个数组的整数进行查找功能。
如果给定值x在数组a中，返回其所在的位置（即下标值），否则返回-1。
源程序如下：
shangji6\chengxu31
#include
intfind（int*a,intn,intx）;
intmain（）
{
inta[100],n,x,i;
printf（"entern:
"）;
scanf（"%d",&n）;
printf（"enternumbers:
"）;
for（i=0;iscanf（"%d",（a+i））;
printf（"enterx:
"）;
scanf（"%d",&x）;
if（find（a,n,x）==-1）
printf（"notfound!
"）;
else
printf（"thenumberis%d",find（a,n,x））;
return0;
}
intfind（int*a,intn,intx）
{
inti,*p=a;
for（i=0;i{
if（*（p+i）==x）
return（i）;
}
return（-1）;
}
实验步骤：
1.定义一个数组实现数据的输入和存放。
2.定义一个子函数实现查找的功能并在主函数中调用该函数。
调试及编译过程
测试数据：
任意选取一组数据，后来输入的数能被找到
测试数据：
任意选取一组数据（后来输入的数不能被找到）
出现的不足及修改：
无运行结果：
出现预期的结果
（四）输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。
如果有多对数字的和等于输入的数字，输出任意一对即可。
例如，输入数组1、2、4、7、11、15和数字15。
由于4+11=15，因此，输出4和11。
源程序如下：
shangji6\chengxu32
#include
intmain（）
{
inta[100],n,x,i,j;
printf（"entern:
"）;
scanf（"%d",&n）;
printf（"enternumbers:
"）;
for（i=0;iscanf（"%d",a+i）;
printf（"enterx:
"）;
scanf（"%d",&x）;
for（i=0;i{
for（j=0;j{
if（*（a+i）+*（a+j）==x）
{
printf（"%d+%d=%d",*（a+i）,*（a+j）,x）;
return0;
}
}
}
return0;
}
实验步骤：
1．定义一个数组实现数据的输入和存放。
2．用两层循环逐一检验，遇到满足条件的即输出。
调试及编译过程：
测试数据：
任意选取一组数据：
出现的不足及修改：
无运行结果：
出现预期的结果。
（五）检验并打印魔方矩阵
在下面的5×5阶魔方矩阵中，每一行、每一列、每一对角线上的元素之和都是相等的，试编写程序将任意5×5阶矩阵中的元素存储到一个二维整型数组中，然后检验其是否为魔方矩阵，并将其按如下格式显示到屏幕上。
17
24
1
8
15
23
5
7
14
16
4
6
13
20
22
10
12
19
21
3
11
18
25
2
9
源程序如下：
shangji6\chengxu33
#include
intmain（）
{
inta[5][5],i,j,s=0,s1=0,s2,s3;
printf（"enternumbers:
"）;
for（i=0;i<5;i++）
{
for（j=0;j<5;j++）
{
scanf（"%d",*（a+i）+j）;
}
}
for（i=0;i<5;i++）
{
for（j=0;j<5;j++）
{
printf（"%4d",*（*（a+i）+j））;
}
printf（"\n"）;
}
for（i=0;i<5;i++）
s+=*（*（a+i）+i）;
for（i=0;i<5;i++）
s1+=*（*（a+i）+4-i）;
if（s==s1）
{
for（i=0;i<5;i++）
{
s2=0;
for（j=0;j<5;j++）
{
s2+=*（*（a+i）+j）;
}
if（!
（s2==s））
{
printf（"not!
"）;
return0;
}
}
for（i=0;i<5;i++）
{
s3=0;
for（j=0;j<5;j++）
s3+=*（*（a+j）+i）;
}
if（!
（s3==s））
{
printf（"not!
"）;
return0;
}
}
else
printf（"not!
"）;
return0;
}
实验步骤：
1.定义数组实现数据的输入和存放。
2.分别对二维矩阵的行列主次对角线进行求和运算，判断是否为魔方矩阵。
调试及编译过程：
测试数据：
输入一组魔方矩阵的数据
出现的不足及修改：
无运行结果：
输出预期结果。
（六）编写一个函数swap（x,y），分别采用3种不同的算法实现两个变量值的交换功能。
源程序1如下：
shangji6\chengxu34shangji6\chengxu34`shangji6\chengxu34``
#include
voidswap（int*x,int*y）;
intmain（）
{
inta,b;
scanf（"%d%d",&a,&b）;
swap（&a,&b）;
printf（"%d\t%d",a,b）;
return0;
}
voidswap（int*x,int*y）
{
intt;
t=*x;
*x=*y;
*y=t;
}
源程序2如下：
#include
voidswap（int*a,int*b）;
intmain（）
{
intx,y;
scanf（"%d%d",&x,&y）;
swap（&x,&y）;
printf（"%d\t%d",x,y）;
return0;
}
voidswap（int*x,int*y）
{
*x=（*x）+（*y）;
*y=（*x）-（*y）;
*x=（*x）-（*y）;
}
源程序3如下：
#include
voidswap（int*x,int*y）;
intmain（）
{
intx,y;
scanf（"%d%d",&x,&y）;
swap（&x,&y）;
printf（"%d\t%d",x,y）;
return0;
}
voidswap（int*x,int*y）
{
*x=*x^*y;
*y=*x^*y;
*x=*x^*y;
}
实验步骤：
1．选取三种合适的方法进行交换。
2．因为要用到子函数，于是将这三种方法中的参数均改为指针操作。
调试及编译过程：
测试数据：
任意选取一组数据
测试数据：
将以上数据交换输入
出现的不足及修改：
无运行结果：
出现预期的结果。
（七）设计一个计算MAX{a,b}的程序，要求a和b，以命令行中参数形式给出。
源程序如下：
shangji6\chengxu35
#include
intmain（intargc,char*argv[]）
{
inta=atoi（argv[1]）;
intb=atoi（argv[2]）;
if（a>b）printf（"%d",a）;
elseprintf（"%d",b）;
return0;
}
实验步骤：
直接进行比较并输出较大值
调试及编译过程：
测试数据：
任意选取一组数据
测试数据：
交换上面两数
出现的不足及修改：
刚开始没有将字符型换成整型导致错误，后来使用atoi函数解决。
运行结果：
改正后输出预期的结果。
（八）设计一个函数create（L），其功能是建立一个“先进后出”的链表。
源程序如下：
shangji6\chengxu36
#include
#include
structList{
inti;
structList*next;
};
typedefstructListmylist;
intmain（intargc,constchar*argv[]）
{
structList*h=NULL;
mylist*p;
h=（mylist*）malloc（sizeof（mylist））;
h->i=0;
h->next=NULL;
intn;
scanf（"%d",&n）;
while（n）{
inttemp;
scanf（"%d",&temp）;
p=（mylist*）malloc（sizeof（mylist））;
p->i=temp;
p->next=h;
h=p;
--n;
}
while（h&&（h->i!
=0））
{
printf（"%8d\t",h->i）;
h=h->next;
}
return0;
}
实验步骤：
1.定义结构型的变量，创建链表。
2.循环定义链表的起点和终点，定义结构的数据域。
3.输出。
调试及编译结果：
测试数据：
任意选取一组数据
测试数据：
将上述数据反向输入
出现的不足及修改：
无运行结果：
输出预期的结果。
（九）设计一个函数insert（L,i,e），其功能是在链表L中的第i个元素之间插入新元素e。
源程序如下：
shangji6\chengxu37
#include
#include
#include
structList{
inti;
structList*next;
};
typedefstructListmylist;
mylist*insert（mylist*L,inti,inte）{
mylist*pri=L;
intj;
for（j=1;jpri=pri->next;
}
mylist*p=（mylist*）malloc（sizeof（mylist））;
p->i=e;
p->next=pri->next;
pri->next=p;
returnL;
}
intmain（intargc,constchar*argv[]）
{
structList*h=NULL;
intinsert_number,locate;
printf（"enterthenumberyouwanttoinsertin:
"）;
scanf（"%d",&insert_number）;
printf（"enterthelocateyouwanttoinsert:
"）;
scanf（"%d",&locate）;
mylist*p;
h=（mylist*）malloc（sizeof（mylist））;
h->i=0;
h->next=NULL;
intn;
printf（"enterthenumberoflist:
"）;
scanf（"%d",&n）;
while（n）{
inttemp;
scanf（"%d",&temp）;
p=（mylist*）malloc（sizeof（mylist））;
p->i=temp;
p->next=h;
h=p;
--n;
}
h=insert（h,locate,insert_number）;
mylist*temp=h;
while（temp&&（temp->i!
=0））{
printf（"%d",temp->i）;
temp=temp->next;
}
return0;
}
实验步骤:
1.根据上一个实验写出创建链表的过程。
2.定义子函数进行数据的插入，在此过程中，将要插入的数放入一个新的结构性变量中，并将此结构性变量的指针域指向原链表中的插入位置，使链表按原顺序继续下去。
调试及编译过程：
测试数据：
任意选取一组数据
测试数据：
任意选取一组数据
出现的不足及修改：
无运行结果：
出现预期的结果。
（十）设计一个函数delete（L,i），其功能是删除在链表L中的第i个元素。
源程序如下：
shangji6\chengxu38
#include
#include
#include
structList{
inti;
structList*next;
};
typedefstructListmylist;
mylist*insert（mylist*L,inti）{
mylist*pri=L;
intj;
for（j=1;jpri=pri->next;
}
pri->next=pri->next->next;
returnL;
}
intmain（intargc,constchar*argv[]）
{
structList*h=NULL;
intlocate;
printf（"enterthelocateyouwanttodelete:
"）;
scanf（"%d",&locate）;
mylist*p;
h=（mylist*）malloc（sizeof（mylist））;
h->i=0;
h->next=NULL;
intn;
printf（"enterthenumberoflist:
"）;
scanf（"%d",&n）;
while（n）{
inttemp;
scanf（"%d",&temp）;
p=（mylist*）malloc（sizeof（mylist））;
p->i=temp;
p->next=h;
h=p;
--n;
}
h=insert（h,locate）;
mylist*temp=h;
while（temp&&（temp->i!
=0））{
printf（"%d",temp->i）;
temp=temp->next;
}
return0;
}
实验步骤：
1.根据第一个创建链表的程序创建链表。
2.定义一个子函数完成删除第i个元素的功能。
调试及编译过程：
测试数据：
任意选取一组数据
测试数据：
任意选取一组数据
出现的不足及修改：
无运行结果：
出现预期的结果。
（十一）设计一个程序，利用链表输出约瑟夫环的结果序列。
注释：
约瑟夫环是一个数学的应用问题：
已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。
从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
源程序如下：
shangji6\chengxu39
#include
#include
structlist{
intdata;
structlist*next;
};
structlist*create（intn）
{
inti=1;
structlist*head=NULL,*tail;
head=（structlist*）malloc（sizeof（structlist））;
head->data=i;
tail=head;
while（n-1）
{
tail->next=（structlist*）malloc（sizeof（structlist））;
tail=tail->next;
tail->data=++i;
n--;
}
tail->next=head;
returnhead;
};
intmain（）
{
intn,m,t=0,k=0;
structlist*mylist=NULL,*mylist1=NULL;
printf（"enterthenumberofpeople:
\n"）;
scanf（"%d",&n）;
printf（"enterm:
\n"）;
scanf（"%d",&m）;
mylist=create（n）;
mylist1=mylist;
while（t!
=n-1）
{
k++;
if（k==m）
{
mylist1->next=mylist1->next->next;
t++;
k=0;
}
mylist1=mylist;
mylist=mylist->next;
}
printf（"thelastnumberis%d",mylist->data）;
return0;
}
实验步骤：
1.创建链表，将链表中各部分的数据域分别设为1,2,…n，其中n又键盘端输入。
2.输入人数和需要删除的数，用到上一个程序的思想，在将要删除的数前，将上一个指针直接指向下一个而不指向该数。
调试及编译过程：
测试数据：
任意输入一组数据
测试数据：
任意输入一组数据
出现的不足及修改：
刚开始没有注意到若直接在删除的过程中采用一个变量进行处理，则实际上去掉的是该数的下一个数，因此在修改的过程中加上了另外一个变量，使后来加上的变量指向当前变量的前一个，利用它进行删除工作，而当前变量仍起到控制循环的作用。
运行结果：
修改后能输出预期的结果。
（十二）设计一个程序完成文件的复制（COPY）功能。
源程序如下：
shangji6\chengxu40
#include
#include
intmain（）
{
charc;
FILE*fin,*fout;
fout=fopen（"out.txt","w+"）;
fin=fopen（"in.txt","r+
升级会员 