计算机软件技术基础2 天津大学离线考核题库及答案Word格式文档下载.docx
《计算机软件技术基础2 天津大学离线考核题库及答案Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《计算机软件技术基础2 天津大学离线考核题库及答案Word格式文档下载.docx（27页珍藏版）》请在冰豆网上搜索。
returnflag;
main（）
charstr[128];
printf（"
Pleaseinputastring:
"
）;
gets（str）;
if（fun（str））
Yes\n"
Else
No\n"
（三）
设A、B是两个线性表，其表中元素递增有序，长度分别为m和n。
试写一算法分别以顺序存储和链式存储将A和B归并成一个仍按元素值递增有序的线性表C。
顺序存储:
voidC_merge（SqListA,SqListB,SqList&
C）
{i=1;
j=1;
k=0;
while（A.elem[i]&
&
B.elem[j]）
{
if（A.elem[i]<
B.elem[j]）{C.elem[++k]=A.elem[i];
i++}
if（A.elem[i]>
B.elem[j]）{C.elem[++k]=B.elem[j];
j++}
if（A.elem[i]==B.elem[j]）
C.elem[++k]=A.elem[i];
C.elem[++k]=B.elem[j];
i++;
j++;
}
while（A.elem[i]）{C.elem[++k]=A.elem[i];
while（B.elem[j]）{C.elem[++k]=B.elem[j];
链式存储:
voidC_merge（LinkListA,LinkListB,LinkList&
C）{
LinkListq;
pa=A->
next;
pb=B->
pre=NULL;
while（pa||pb）{
if（!
pb||pa->
data>
pb->
data）
{pc=pa;
q=pa->
pa->
next=pre;
pa=q;
}
else{
pc=pb;
q=pb->
pb->
pb=q;
pre=pc;
C=A;
A->
next=pc;
（四）
设有一个带头结点的单链表，表中各数据元素为无序的正整数，编写下列2个函数。
（1）node*find_min_node（node*h）：
找出头指针h指向的单链表中数据值最小的结点，打印该结点的数据值，并返回该结点指针；
（2）voidswitch_next_node（node*p）：
若指针p指向的结点数据值为奇数，则将该结点与其直接后继结点的数值交换，若指针p指向的结点无后继结点或数据值为偶数，则不做任何操作；
Typedefstructnode{
intdata;
structnode*next;
}node;
Voidmain（）
node*head,*p;
head=create（）;
/*创建单链表*/
p=find_min_node（head）;
/*查找数据值最小的结点*/
switch_next_node（p）;
node*find_min_node（node*h）{
intmin;
node*p,*t;
if（h==NULL）
returnNULL;
p=h->
t=NULL;
min=p->
data;
while（p!
=NULL）{
if（p->
data<
min）{t=p;
p=p->
min=%d\n"
t->
data）;
returnt;
（1）voidswitch_next_node（node*p）{node*q;
intt;
q=p->
if（q==NULL||p->
data%2==0）return;
t=p->
p->
data=q->
q->
data=t;
第二组：
编程实现bubble（）函数，功能是：
对12个整数进行冒泡排序（要求排成升序）。
Main（）{inta[12];
intm，n，p;
for（m=0;
m<
=11;
m++）scanf（“%d”，&
a[m]）;
m++）
for（n=0;
n<
11-m;
n++）
if（a[n]>
a[n+1]）
{p=a[n];
a[n]=a[n+1];
a[n+1]=p;
printf（“%d”，a[m]）;
｝
1.编写函数intabsolute（intx），它的功能是：
计算并输出x的绝对值
math.h>
intabsolute（intx）;
intx,s;
scanf（"
%d"
&
x）;
s=absolute（x）;
%d\n"
s）;
intabsolute（intx）
ints=0;
if（x>
0）s=x;
elses=-x;
returns;
2.编写函数voidfun（），它的功能是：
计算并输出1+1/2+1/3+……+1/n，n由键盘输入
voidfun（）
{inti,n;
floats;
for（i=1;
i<
=n;
i++）
s+=1.0/i;
printf（“%f”,s）;
3.编写程序，计算并输出X3+X5
floatx,k=1,sum=0;
inti;
scanf（“%f”,&
=3;
k*=x;
sum+=k;
k=1;
=5;
j++）
printf（“%f”,sum）;
4.数学中，阶乘函数的递归定义为：
若n=0,n!
=1;
若n>
0,n!
=n*（n-1）!
;
编写程序，计算并输出n!
doublefun（intn）
if（n==0||n==1）return1;
elseif（n>
=2）returnn*fun（n-1）;
{intx;
scanf（“%d”,&
printf（“%lf”,fun（x））;
设指针la和lb分别指向两个不带头结点的单链表的首结点，设计从表la中删除第i个元素起共len个元素，并将这些元素插入到lb中第j个结点之前的算法。
StatusDeleteAndInsertSub（LinkedListla,LinkedListlb,inti,intj,intlen）{if（i<
0||j<
0||len<
0）returnINFEASIBLE;
p=la;
k=1;
pre=NULL;
while（p&
i）{pre=p;
k++;
if（!
p）returnINFEASIBLE;
q=p;
while（q&
len）{q=q->
q）returnINFEASIBLE;
pre）la=q->
elsepre->
next=q->
if（j=1）{q->
next=lb;
lb=p;
s=lb;
while（s&
j-1）{s=s->
s）returnINFEASIBLE;
next=s->
s->
next=p;
returnOK;
1.编写递归函数求1+2+3+„„+m的值。
doublefun（intm）
if（m==1）return1;
elsereturnfun（m-1）+m;
2.设指针la和lb分别指向两个不带头结点的单链表的首结点，设计从表la中删除第i个元素起共len个元素，并将这些元素插入到lb中第j个结点之前的算法。
第三组：
1.编写函数voidfun（），其功能是计算并输出100以内的偶数之和
inti,sum=0;
=100;
if（i%2==0）sum+=i;
printf（“%d”,sum）;
计算并输出100以内的所有素数
inti,j,k;
for（i=2;
100;
{for（j=2;
j<
（int）sqrt（i）+1;
if（i%j==0）break;
if（j==（int）sqrt（i）+1）printf（“%d”,i）;
3.编写程序，计算并输出5!
+6!
inti,k=1;
longsum=0;
k*=i;
=6;
printf（“%ld”,sum）;
4.编写程序，计算并输出（X3）2
floatx,k=1;
=2;
for（j=1;
printf（“%f”,k）;
给出用单链表存储多项式的结构，并编写一个按指数值递增次序输入所产生的多项式链表的过程
typedefstructPNode{intcoef；
intexp；
structPNode*next；
}*PLink；
PLinkCreatPoly（）{head=（PLink）malloc（sizeof（structPNode））；
r=head；
printf（”输入系数和指数：
”）；
scanf（&
n，&
m）；
while（n!
=0）{s=（Plink）malloc（sizeof（structPNode））；
coef=n；
exp=m；
r->
next=s；
r=s；
printf（”输入系数和指数:
”）；
}r->
next=NULL；
head=head—>
next；
returnhead；
1.单链表L是一个递减有序表，试写一高效算法，删除表中值大于min且小于max的结点（若表中有这样的结点），同时释放被删结点空间，这里min和max是两个给定的参数。
voidDeleteList（LinkListL,DataTypemin,DataTypemax）
{ListNode*p,*q,*s;
p=L;
while（p->
next&
next->
data<
=min）
q->
max）{
s=q;
q=q->
free（s）;
}p->
next=q;
2.编写一个算法将一个头结点指针为pa的单链表A分解成两个单链表A和B，其头结点指针分别为pa和pb，使得A链表中含有原链表A中序号为奇数的元素，而B链表中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。
voidSepList（ListNode*pSrc,ListNode**pLA,ListNode**pLB）
ListNode*pCur=pSrc;
ListNode*pA;
ListNode*pB;
*pLA=（ListNode*）malloc（sizeof（ListNode））;
*pLB=（ListNode*）malloc（sizeof（ListNode））;
pA=*pLA;
pB=*pLB;
while（pCur->
next!
=NULL）
pA->
next=pCur->
pCur->
pA=pA->
next=NULL;
if（pCur->
pB->
pB=pB->
free（pSrc）;
已知由单链表表示的线性表中，含有三类字符的数据元素（如：
字母字符、数字字符和其他字符），试编写算法构造三个以循环链表表示的线性表，使得每个表中只含有同一类的字符，且利用原表中的结点空间作为这三个表的结点空间，头结点可另辟空间。
voidSplit（LinkList&
lc,LinkList&
ld,LinkList&
lo,LinkListll）;
typedefstructLNode{ElemTypedata;
structLNode*next;
}LNode,*LinkList;
voidSplit（LinkList&
A,LinkList&
B,LinkList&
C,LinkListL）{LinkLists,p,q,r;
s=L->
A=（LinkList）malloc（sizeof（LNode））;
p=A;
B=（LinkList）malloc（sizeof（LNode））;
q=B;
C=（LinkList）malloc（sizeof（LNode））;
r=C;
while（s）{if（（s->
data>
='
a'
s->
z'
）||（s->
Z'
A'
））
{p->
next=s;
p=s;
}elseif（s->
0'
9'
）{q->
q=s;
}else{r->
r=s;
}s=s->
}//whilep->
next=A;
next=B;
r->
next=C;
第四组：
1．试用顺序表作为存储结构，实现将线性表（a0，a1，a2，„an-1）就地逆置的操作，所谓“就地”是指辅助空间为O
（1）。
voidreverse（inta[],intsize）
inttmp;
for（inti=0;
size/2;
++i）
tmp=a[i];
a[i]=a[size-1];
a[size-1]=tmp;
2．设顺序表L是一个递增（允许有相同的值）有序表，试写一算法将x插入L中，并使L仍为一个有序表。
voidInsertIncreaseList（Seqlist*L,Datatypex）
inti;
if（L->
length>
=ListSize）
Error（“overflow"
for（i=L->
length;
i>
0&
L->
data[i-1]>
x;
i--）
L->
data[i]=L->
data[i];
//比较并移动元素
data[i]=x;
L->
length++;
根据上题的单链表存储多项式的结构，编写一个过程实现两个多项式相加的运算。
stdlib.h>
malloc.h>
typedefintElemType;
/*单项链表的声明*/
typedefstructPolynNode{
intcoef;
//系数
intexpn;
//指数
structPolynNode*next;
}PolynNode,*PolynList;
/*正位序（插在表尾）输入n个元素的值，建立带表头结构的单链线性表*/
/*指数系数一对一对输入*/
voidCreatePolyn（PolynList&
L,intn）
inti;
PolynListp,q;
L=（PolynList）malloc（sizeof（PolynNode））;
//生成头结点
next=NULL;
q=L;
printf（"
成对输入%d个数据\n"
n）;
for（i=1;
i++）
{
p=（PolynList）malloc（sizeof（PolynNode））;
scanf（"
%d%d"
p->
coef,&
expn）;
//指数和系数成对输入
q=q->
//初始条件：
单链表L已存在
//操作结果:
依次对L的每个数据元素调用函数vi（）。
一旦vi（）失败,则操作失败
voidPolynTraverse（PolynListL,void（*vi）（ElemType,ElemType））
PolynListp=L->
while（p）
vi（p->
coef,p->
if（p->
next）
+"
//“+”号的输出，最后一项后面没有“+”
\n"
/*ListTraverse（）调用的函数（类型要一致）*/
voidvisit（ElemTypec,ElemTypee）
if（c!
=0）
%dX^%d"
c,e）;
//格式化输出多项式每一项
/*多项式相加，原理：
归并*/
/*参数：
两个已经存在的多项式*/
/*返回值：
归并后新的多项式的头结点*/
PolynListMergeList（PolynListLa,PolynListLb）
PolynListpa,pb,pc,Lc;
pa=La->
pb=Lb->
Lc=pc=La;
//用La的头结点作为Lc的头结点
while（pa&
pb）
if（pa->
expn<
expn）
pc->
next=pa;
//如果指数不相等，pc指针连上指数小的结点，
pc=pa;
pa=pa->
//指向该结点的指针后移
elseif（pa->
expn>
expn）
next=pb;
//pc指针连上指数小的结点，
pc=pb;
pb=pb->
升级会员 