北京工业大学计算机软件基础实验指导书.docx

北京工业大学计算机软件基础实验指导书.docx

《北京工业大学计算机软件基础实验指导书.docx》由会员分享，可在线阅读，更多相关《北京工业大学计算机软件基础实验指导书.docx（106页珍藏版）》请在冰豆网上搜索。

北京工业大学计算机软件基础实验指导书

试验一：

线性表的设计与实现

ExperimentNo.1:

TheDesignandImplementationofLinearList

实验学时：

2

实验类型：

设计

先修课程：

<<程序设计基础>>、<<计算机文化基础>>

适用专业：

电子信息类自动化专业、电子信息工程、通信工程

一、实验目的

1.掌握用程序开发环境上机调试线性表的基本方法；

2.掌握线性表的基本操作（插入、删除、查找）以及线性表合并等运算采用顺序存储结构和链接式存储结构时的不同实现方法。

二、实验内容

1.线性表基本操作的实现；

2.一元多项式的简单计算；

3.约瑟夫环游戏的两种实现方法对比。

三、实验要求

1.“线性表基本操作的实现”部分

[问题说明]当在线性表的顺序存储结构上的第i个位置上插入一个元素时，必须先将线性表中第i个位置之后的所有元素依此后移一个位置，以便腾空一个位置，再把新元素插入到该位置。

如果要删除第i个元素时，则必须把第i个元素之后的所有元素向前移一个位置。

当采用链结式存储结构时，通过修改第i个结点前后的地址指针来实现插入与删除，并释放被删除结点的内存。

[基本要求]生成线性表时，可在键盘上读取元素，用顺序存储结构和链接式存储结构实现。

2.“一元多项式的简单计算”部分

[问题说明]设计一个一元多项式简单计算器。

[基本要求]一元多项式简单计算器的基本功能为：

输入并建立多项式；输出多项式；两个多项式相加减、相乘，建立并输出多项式。

3.“约瑟夫环游戏的两种实现方法对比”部分

[问题说明]设有n个人围坐成一圈，现从某个人开始报数，数到m的人出列，接着从出列的下一个人开始重新报数，数到m的人又出列，如此下去，直到所有的人都出列为止。

[基本要求]选择单项循环链表作为存储结构模拟整个过程，并依次输出出列人的编号；选择数组作为存储结构模拟整个过程，并依次输出出列人的编号；对同一问题，比较数据结构不同时，同一算法的不同实现及效率。

四、实验装置

PC机一台，含WindowsXP以上操作系统，装有TurbocC2.0、Win-TC或VisualC++6.0程序开发环境。

五、实验步骤

1.“线性表基本操作的实现”部分

1）进入C语言开发环境；

2）装入样本程序shiyan11.c或输入自己编写的程序；

3）阅读样本程序；如果学生有自己编写的完成同样功能的程序，则调试自己的程序；

4）

c,C......CreateList/*建表*/

i,I......Insert/*插入元素到指定位置*/

d,D......Delete/*删出指定位置的元素*/

q,Q......Quit/*退出*/

Yourchoice:

编译并运行样本程序；显示屏上出现：

选择上面4个功能进行测试。

例如：

选择“CreateList”功能，键入：

c<回车>，

Pleaseinputtotalnumberofdataitem

键入5<回车>

data[1]=1<回车>

data[2]=2<回车>

data[3]=3<回车>

data[4]=4<回车>

data[5]=5<回车>

Pressanykeytocontinue

<回车>

程序显示：

程序返回显示主菜单：

c,C......CreateList

i,I......Insert

d,D......Delete

q,Q......Quit

Yourchoice:

I<回车>

Inputthedatatobeinserted:

88<回车>

Inputthepoistiontobeinserted:

（1--5）:

2<回车>

data[1]=1data[2]=88data[3]=2data[4]=3data[5]=4

data[6]=5

Pressanykeytocontinue

<回车>

程序返回显示主菜单：

c,C......CreateList

i,I.....Insert

d,D......Delete

q,Q......Quit

Yourchoice:

d<回车>

Inputtheindex_Noofdatatobedeleted

（1---6）:

2<回车>

data[1]=1data[2]=2data[3]=3data[4]=4data[5]=5

2.“一元多项式的简单计算”部分

1）进入C语言开发环境；

2）装入样本程序shiyan12.c或输入自己编写的程序；

3）阅读样本程序；如果学生有自己编写的完成同样功能的程序，则调试自己的程序；

4）编译并运行样本程序；显示屏上出现：

Inputthe1stpolynomial/*要求输入第一个多项式*/

inputcoefandexp（1,2）:

3,10<回车>

Inputcoefandexp:

4,8<回车>

Inputcoefandexp:

5,6<回车>

Inputcoefandexp:

6,4<回车>

Inputcoefandexp:

-2,2<回车>

Inputcoefandexp:

8,0<回车>

Inputcoefandexp:

0,0<回车>

Inputthe2ndpolynomial/*要求输入第二个多项式*/

inputcoefandexp（1,2）:

Inputcoefandexp:

4,7<回车>

Inputcoefandexp:

3,5<回车>

Inputcoefandexp:

2,2<回车>

Inputcoefandexp:

12,0<回车>

Inputcoefandexp:

0,0<回车>

the1stpolynomialis:

3,104,85,66,4-2,28,0

the2ndpolynomialis:

4,73,52,212,0

/*多项式相加的结果*/

theadditionofthetwopolynomialis:

3,104,84,75,63,56,420,0

/*多项式相乘的结果*/

themultiplicationofthetwopolynomialis:

12,1725,1532,136,1239,1144,1010,958,826,772,624,568,4-8,296,0

3.“约瑟夫环游戏的两种实现方法对比”部分

A.链式结构实现

1）进入C语言开发环境；

2）装入样本程序shiyan13.c或输入自己编写的程序；

3）阅读样本程序；如果学生有自己编写的完成同样功能的程序，则调试自己的程序；

4）编译并运行样本程序；显示屏上出现：

Inputthetotalnumberofpeople:

8<回车>

inputthenumberofpersonyouaretocall:

4<回车>

48521376thelastone:

6

B.顺序结构实现

1）进入C语言开发环境；

2）装入样本程序shiyan14.c或输入自己编写的程序；

3）阅读样本程序；如果学生有自己编写的完成同样功能的程序，则调试自己的程序；

4）编译并运行样本程序；显示屏上出现：

Johephasproblem

inputnumberofpeople,numbertocall,andstartnumber:

8,4,1

48521376.

六、实验数据及处理

将上述实验输入、输出数据根据所涉及的问题进行核对，对程序结果进行确认分析。

针对实验内容的各个问题，设计一至二组测试用例，对程序的正确性进行分析。

七、实验报告要求

1.对样本程序（或自己所设计的完成相应功能的程序）进行分析注释；

2.对测试数据及执行结果进行分析；

3.讨论程序的改进方法。

八、思考题

1.如何改进“约瑟夫环游戏”程序设计，使初始时入环的每一个人有“姓名”，“编号”等其它信息，出环的人打印出“姓名”。

2.如何实现两多项式的相减？

/*线性表的程序设计*/

#include

#include

#defineNull0

#defineMaxSize1024

typedefintDataType;

typedefstructnode{

DataTypedata[MaxSize];

intlast;

}SequenList;

voidPrintOut（SequenList*L）;

intDelete（SequenList*L,inti）;

voidCreateList（SequenList*L）;

intmain（）{

SequenListMyList,*L;

charcmd;

inti,t,x;

L=&MyList;

L->last=-1;

do{

do{

clrscr（）;

printf（"\n\tc,C......CreateList\n"）;

printf（"\n\ti,I.....Insert"）;

printf（"\n\td,D......Delete"）;

printf（"\n\tq,Q......Quit\n\tYourchoice:

"）;

cmd=getchar（）;

}while（（cmd!

='d'）&&（cmd!

='D'）&&（cmd!

='q'）&&（cmd!

='Q'）&&（cmd!

='i'）&&（cmd!

='I'）&&（cmd!

='c'）&&（cmd!

='C'））;

/*or:

while（（toupper（cmd）!

=’D’）&&（toupper（cmd）!

=’Q’）&&（toupper（cmd）!

=’I’）&&（toupper（cmd）!

=’C’））;*/

switch（cmd）{

case'c':

case'C':

CreateList（L）;

break;

case'i':

case'I':

printf（"\nInputthedatatobeinserted:

"）;

scanf（"%d",&x）;

printf（"\nInputthepoistiontobeinserted:

"）;

printf（"\n（1--%d）\n",（L->last+2））;

scanf（"%d",&i）;

Insert（L,x,i）;

PrintOut（L）;

getch（）;

break;

case'd':

case'D':

printf（"\nInputtheindex_Noofdatatobedeleted\n"）;

printf（"\n（1---%d）:

\n",（L->last+1））;

scanf（"%d",&i）;

Delete（L,i）;

PrintOut（L）;

getch（）;

break;

default:

break;

}

}while（（cmd!

='q'）&&（cmd!

='Q'））;

/*or:

while（（toupper（cmd）!

='Q'））;*/

}

intInsert（SequenList*L,DataTypex,inti）{

intj;

p=L;/*可以删去，本函数中所有的p均改为L.*/

if（p->last>=（MaxSize-1））{

printf（"\nOverflow!

"）;

returnNull;}

elseif（（i<1）||（i>（p->last+2）））{

printf（"rangeerror"）;

returnNull;}

else{

for（j=L->last;j>=i-1;j--）L->data[j+1]=L->data[j];

L->data[i-1]=x;

L->last=L->last+1;}

return

（1）;

}

voidPrintOut（SequenList*L）{

inti;

for（i=0;i<=L->last;i++）{

printf（"data[%d]=",i+1）;

printf（"%d\t",L->data[i]）;

if（（i!

=0）&&（（i%4）==0））printf（"\n"）;}

}/*PrintOut*/

intDelete（SequenList*L,inti）{

intj;

if（（i<1）||（i>L->last+1））{

printf（"rangeerror"）;

returnNull;}

else{

for（j=i;jlast+1;j++）L->data[j-1]=L->data[j];

L->last--;}

return

（1）;

}

voidCreateList（SequenList*L）{

intn,i;

intmydata;

printf（"\nPleaseinputtotalnumberofdataitem\n"）;

scanf（"%d",&n）;

for（i=0;i

printf（"data[%d]=",i+1）;

scanf（"%d",&mydata）;

L->data[i]=mydata;}

L->last=n-1;

printf（"\nPressanykeytocontinue\n"）;

getch（）;

}/*CreateList*/

/*一元多项式的相加、相乘的程序设计*/

#defineNull0

#defineTrue1

#defineFalse0

typedefstructpolyterm{

intcoef;

intexp;

structpolyterm*next;

}TERM;

TERM*reverse（TERM*q）;

voidpolyout（TERM*head）;

TERM*creatpoly（）{

TERM*head,*r,*s;

intm,n;

head=（TERM*）malloc（sizeof（TERM））;

printf（"inputcoefandexp（1,2）:

\n"）;

scanf（"%d,%d",&n,&m）;

r=head;

while（n）{

s=（TERM*）malloc（sizeof（TERM））;

s->coef=n;s->exp=m;

r->next=s;r=s;

printf（"\nInputcoefandexp:

\n"）;

scanf（"%d,%d",&n,&m）;}

r->next=Null;r=head;

head=head->next;free（r）;

return（head）;

}/*creatpoly*/

TERM*polyadd（TERM*ha,TERM*hb）{

TERM*hc,*p,*q,*s,*r;

intx;

p=ha;q=hb;

hc=（TERM*）malloc（sizeof（TERM））;

s=hc;

while（（p!

=Null）&&（q!

=Null））{

if（p->exp==q->exp）{/*coeficients*/

x=p->coef+q->coef;

if（x!

=0）{

r=（TERM*）malloc（sizeof（TERM））;

r->exp=p->exp;r->coef=x;

s->next=r;s=r;}

p=p->next;q=q->next;}

elseif（p->expexp）{

r=（TERM*）malloc（sizeof（TERM））;

r->coef=q->coef;r->exp=q->exp;

s->next=r;s=r;

q=q->next;}

else{/*p->exp>q->exp*/

r=（TERM*）malloc（sizeof（TERM））;

r->exp=p->exp;r->coef=p->coef;

s->next=r;s=r;

p=p->next;}

}

while（p!

=Null）{

r=（TERM*）malloc（sizeof（TERM））;

r->exp=p->exp;r->coef=p->coef;

s->next=r;s=r;

p=p->next;}

while（q!

=Null）{

r=（TERM*）malloc（sizeof（TERM））;

r->exp=q->exp;r->coef=q->coef;

s->next=r;s=r;

q=q->next;}

s->next=Null;

r=hc;

hc=hc->next;

free（r）;

return（hc）;

}/*polyadd*/

TERM*polymulti（TERM*f,TERM*g）{/*关于一元多项式相乘的程序*/

TERM*fp,*gp,*hp,*q,*h;

intmaxp,p,r,x;

maxp=f->exp+g->exp;

h=（TERM*）malloc（sizeof（TERM））;

hp=h;

g=reverse（g）;

for（r=maxp;r>=0;r--）{

x=0;fp=f;

gp=g;

while（（fp!

=Null）&&（gp!

=Null））{

p=fp->exp+gp->exp;

if（p>r）fp=fp->next;

elseif（pnext;

else{

x+=fp->coef*gp->coef;

fp=fp->next;

gp=gp->next;}

}/*endofwhile*/

if（x!

=0）{

q=（TERM*）malloc（sizeof（TERM））;

q->exp=r;q->coef=x;

q->next=Null;

hp->next=q;hp=q;}

}/*endoffor*/

hp=h;h=h->next;

free（hp）;

return（h）;

}

TERM*reverse（TERM*q）{

TERM*p1,*p2;

if（q!

=Null）{

p1=q->next;q->next=Null;

while（p1!

=Null）{

p2=p1->next;p1->next=q;

q=p1;p1=p2;

}/*endofwhile*/

}

return（q）;

}

voidpolyout（TERM*head）{

TERM*p,*q;

p=head;

/*p=head->next;*/

while（p!

=Null）{

printf（"%d,%d",p->coef,p->exp）;

p=p->next;}

printf（"\n"）;

}

voidmain（）{

TERM*ha,*hb,*hc,*p,*q,*h;

printf（"\nInputthe1stpolynomial"）;

ha=creatpoly（）;

printf（"\nInputthe2ndpolynomial"）;

hb=creatpoly（）;

printf（"\nthe1stpolynomialis:

"）;

polyout（ha）;

printf（"\nthe2ndpolynomialis:

"）;

polyout（hb）;

hc=polyadd（ha,hb）;

printf（"\ntheadditionofthetwopolynomialis:

"）;

polyout（hc）;

h=polymulti（ha,hb）;

printf（"\nthemultiplicationofthetwopolynomialis:

"）;

polyout（h）;

return;

}

/*约瑟夫环的程序设计*/

#include

#include

#defineNull0

typedefstructtagnode{

intnum;

structtagnode*next;

}LinkList;

LinkList*creat（intn）;

LinkList*select（LinkList*head,intm）;

LinkList*head=Null,*last;

intmain（）{

intn,m;

printf（"\nInputthetotalnumberofpeople:

\n"）;

scanf（"%d",&n）;

printf（"\ninputthenumberofpersonyouaretocall:

\n"）;

scanf（"%d",&m）;

head=creat（n）;

last=select（head,m）;

n=last->num;

printf（"thelastone:

%d\n",n）;

free（last）;

printf（"\nPressanykeytocontinue...\n"）;

getch（）;

return

（1）;

}/*main*/

LinkList*select（LinkList*head,intm）{

LinkList*p,*q;

inti,t,flag=0;

p=head;

t=1;

q=p;/*q--前趋指针,p--当前指针*/

do{

p=q->next;

t=t+1;

if（t%m==0）{/*报数到*/

printf（"%4d\t",p->num）;

if（q->next==q）{flag=1;break;}

q->next=p->next;

free（p）;

p=q;}

elseq=p;

}while（（q==p）||（flag==0））;

head=p;

return（head）;

}/*Selec