else
{
if（m==k-1||m==k）f=1;
else
{
for（i=0;i<=k-2;i++）temp[i]=0;
temp[k-1]=1;temp[k]=1;
for（i=k+1,j=0;i<=m;i++,j++）
{
temp[i]=2*temp[i-1]-temp[j];
}f=temp[m];
}
}returnOK;
}
1.18③假设有A、B、C、D、E五个高等院校进行田径对抗赛，各院校的单项成绩均以存入计算机并构成一张表，表中每一行的形式为项目名称性别校名成绩得分
编写算法，处理上述表格，以统计各院校的男、女总分和团体总分，并输出。
要求实现下列函数：
voidScores（ResultType*result,ScoreType*score）;
/*求各校的男、女总分和团体总分,并依次存入数组score*/
/*假设比赛结果已经储存在result[]数组中,*/
/*并以特殊记录{"",male,'',"",0}（域scorce=0）*/
/*表示结束*/
相关数据类型定义如下：
typedefenum{female,male}Sex;
typedefstruct{
char*sport;//项目名称
Sexgender;//性别（女：
female；男：
male）
charschoolname;//校名为'A','B','C','D'或'E'
char*result;//成绩
intscore;//得分（7,5,4,3,2或1）
}ResultType;
typedefstruct{
intmalescore;//男子总分
intfemalescore;//女子总分
inttotalscore;//男女团体总分
}ScoreType;
voidScores（ResultType*result,ScoreType*score）
/*求各校的男、女总分和团体总分,并依次存入数组score*/
/*假设比赛结果已经储存在result[]数组中,*/
/*并以特殊记录{"",male,'',"",0}（域scorce=0）*/
/*表示结束*/
{inti,j;
for（j=0;result[j].score!
=0;j++）
{
i=result[j].schoolname-65;
if（result[j].gender==male）score[i].malescore+=result[j].score;
Elsescore[i].femalescore+=result[j].score;
score[i].totalscore=score[i].malescore+score[i].femalescore;
}}
◆1.19④试编写算法，计算i!
×2^i的值并存入数组a[0..ARRSIZE-1]的第i-1个分量中（i=1,2,…,n）。
假设计算机中允许的整数最大值为MAXINT，则当n>ARRSIZE或对某个k（1≤k≤n）使k!
×2^k>MAXINT时，应按出错处理。
注意选择你认为较好的出错处理方法。
要求实现下列函数：
StatusSeries（intARRSIZE,inta[]）;
/*求i!
*2^i序列的值并依次存入长度为ARRSIZE的数组a；*/
/*若所有值均不超过MAXINT，则返回OK，否则返回OVERFLOW*/
StatusSeries（intARRSIZE,inta[]）
/*求i!
*2^i序列的值并依次存入长度为ARRSIZE的数组a；*/
/*若所有值均不超过MAXINT，则返回OK，否则返回OVERFLOW*/
{inti,k,sum;
for（i=i;i<=ARRSIZE;i++）
{sum=1;
for（k=i;k>=1;k--）sum*=k;
a[i-1]=sum*pow（2,i）;
if（a[i-1]>MAXINT）returnOVERFLOW;
}returnOK;
}
◆1.20④试编写算法求一元多项式P（x）=a0+a1x+a2x^2+...+anx^n的值P（x0），并确定算法中每一语句的执行次数和整个算法的时间复杂度。
注意选择你认为较好的输入和输出方法。
要求实现下列函数：
floatPolynomial（intn,inta[],floatx0）;
/*求一元多项式的值P（x0）。
*/
/*数组a的元素a[i]为i次项的系数，i=0,1,...,n*/
floatPolynomial（intn,inta[],floatx）
/*求一元多项式的值P（x）。
*/
/*数组a的元素a[i]为i次项的系数，i=0,...,n*/
{
inti;floatj=1.0,P=a[0];
for（i=1;i<=n;i++）{j*=x;P+=a[i]*j;}
returnP;
}
◆2.11②设顺序表L中的数据元素递增有序。
试写一算法，将x插入到L的适当位置上，并保持该表的有序性。
要求实现下列函数：
voidInsertOrderList（SqList&L,ElemTypex）
/*在有序的顺序表L中保序插入数据元素x*/
顺序表类型定义如下：
typedefstruct{
ElemType*elem;
intlength;
intlistsize;
}SqList;
voidInsertOrderList（SqList&L,ElemTypex）
//在有序的顺序表L中保序插入数据元素x
{
inti=0,j;
if（L.length==0）{L.elem[0]=x;L.length++;}
else
{
while（ifor（j=L.length;j>i;j--）L.elem[j]=L.elem[j-1];
L.elem[i]=x;L.length++;
}
}
◆2.12③设A=（a1,…,am）和B=（b1,…,bn）均为有序顺序表，A'和B'分别为A和B中除去最大共同前缀后的子表（例如，A=（x,y,y,z,x,z），B=（x,y,y,z,y,x,x,z），则两者中最大的共同前缀为（x,y,y,z），在两表中除去最大共同前缀后的子表分别为A'=（x,z）和B'=（y,x,x,z））。
若A'=B'=空表，则A=B；若A'=空表，而B'≠空表，或者两者均不为空表，且A'的首元小于B'的首元，则AB。
试写一个比较A和B大小的算法。
（注意：
在算法中，不要破坏原表A和B，也不一定先求得A'和B'才进行比较）。
要求实现下列函数：
charCompare（SqListA,SqListB）;
/*比较顺序表A和B,*/
/*返回'<',若A/*'=',若A=B;*/
/*'>',若A>B*/
顺序表类型定义如下：
typedefstruct{
ElemType*elem;
intlength;
intlistsize;
}SqList;
charCompare（SqListA,SqListB）
//比较顺序表A和B,
//返回'<',若A//'=',若A=B;
//'>',若A>B
{
inti;
if（A.length==0&&B.length==0）return'=';
if（A.length==0&&B.length!
=0）return'<';
if（A.length!
=0&&B.length==0）return'>';
else
{
for（i=0;A.elem[i]==B.elem[i]&&iif（A.elem[0]if（A.elem[0]>B.elem[0]）return'>';
if（i==A.length&&i==B.length）return'=';
else
{
if（i==A.length）return'<';
else
{if（i==B.length）return'>';
else
{if（A.elem[i]';
}
}
}
}}
2.13②试写一算法在带头结点的单链表结构上实现线性表操作Locate（L,x）。
实现下列函数：
LinkListLocate（LinkListL,ElemTypex）;
//If'x'inthelinkedlistwhoseheadnodeispointed
//by'L',thenreturnpointerpointingnode'x',
//otherwisereturn'NULL'
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
LinkListLocate（LinkList&L,ElemTypex）
//If'x'inthelinkedlistwhoseheadnodeispointed
//by'L',thenreturnpointerhapointingnode'x',
//otherwisereturn'NULL'
{
LNode*p=L->next;
while（p）
{
if（p->data==x）returnp;elsep=p->next;
}returnNULL;
}
2.14②试写一算法在带头结点的单链表结构上实现线性表
操作Length（L）。
实现下列函数：
intLength（LinkListL）;
//Returnthelengthofthelinkedlist
//whoseheadnodeispointedby'L'
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
intLength（LinkListL）
//Returnthelengthofthelinkedlist
//whoseheadnodeispointedby'L'
{
inti=0;LNode*p=L->next;
while（p）{p=p->next;i++;}returni;
}
2.16③已知指针la和lb分别指向两个无头结点单链表中的首元结点。
下列算法是从表la中删除自第i个元素起共len个元素后，将它们插入到表lb中第i个元素之前。
试问
此算法是否正确?
若有错，则请改正之。
实现下列函数：
StatusDeleteAndInsertSub（LinkList&la,LinkList&lb,inti,intj,intlen）;
//la和lb分别指向两个单链表中第一个结点，*/
/*本算法是从la表中删去自第i个元素起共len个元素，*/
/*并将它们插入到lb表中第j个元素之前，*/
/*若lb表中只有j-1个元素，则插在表尾。
*/
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
StatusDeleteAndInsertSub（LinkList&la,LinkList&lb,inti,intj,intlen）
//la和lb分别指向两个单链表中第一个结点，*/
/*本算法是从la表中删去自第i个元素起共len个元素，*/
/*并将它们插入到lb表中第j个元素之前，*/
/*若lb表中只有j-1个元素，则插在表尾。
*/
{
LNode*p,*q,*s,*prev;
intk;
if（i<=0||j<=0||len<=0）returnERROR;
p=la;k=1;prev=NULL;
while（p&&k{prev=p;p=p->next;++k;}
if（!
p）returnERROR;q=p;k=1;
while（q&&knext;k++;}
if（!
q）returnERROR;
if（!
prev）la=q->next;
elseprev->next=q->next;
if（j==1）{q->next=lb;lb=p;}
else
{
s=lb;
k=1;
while（s&&knext;++k;}
if（!
s）returnERROR;
q->next=s->next;
s->next=p;
returnOK;
}returnOK;
}
◆2.19③已知线性表中的元素以值递增有序排列，并以单链表作存储结构。
试写一高效的算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素）同时释放被删结点空间，并分析你的算法的时间复杂度（注意：
mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。
实现下列函数：
voidDeleteSome（LinkList&L,ElemTypemink,ElemTypemaxk）;
/*Deletealltheelementswhichvalueisbetweenminkand*/
/*maxkfromthesinglesortedLinkListwithheadpointerL.*/
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
voidDeleteSome（LinkList&L,ElemTypemink,ElemTypemaxk）
/*Deletealltheelementswhichvalueisbetweenminkand*/
/*maxkfromthesinglesortedLinkListwithheadpointerL.*/
{
LNode*p=L,*q=L->next;
while（q）
{
if（q->data>mink&&q->datanext=q->next;free（q）;q=p->next;}
else{q=q->next;p=p->next;}
}
}
2.20②同2.19题条件，试写一高效的算法，删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同）同时释放被删结点空间，并分析你的算法的时间复杂度。
实现下列函数：
voidPurge（LinkList&L）;
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
voidPurge（LinkList&L）
{
LNode*p,*d=L->next,*q;
while（d）
{
p=d;q=p->next;
while（q）
{
if（q->data==d->data）
{p->next=q->next;free（q）;q=p->next;}
else
{p=p->next;q=q->next;}
}
d=d->next;
}
}
◆2.21③试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表（a1,a2,…,an）
逆置为（an,an-1,…,a1）。
实现下列函数：
voidInverse（SqList&L）;
顺序表类型定义如下：
typedefstruct{
ElemType*elem;
intlength;
intlistsize;
}SqList;
voidInverse（SqList&L）
{ElemTypetemp;inti;
for（i=0;i<（L.length+1）/2;++i）
{
temp=L.elem[i];
L.elem[i]=L.elem[L.length-i-1];
L.elem[L.length-i-1]=temp;
}
}
◆2.22③试写一算法，对单链表实现就地逆置。
实现下列函数：
voidInverse（LinkList&L）;
/*对带头结点的单链表L实现就地逆置*/
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
voidInverse（LinkList&L）
/*对带头结点的单链表L实现就地逆置*/
{
LNode*p=L->next,*q;L->next=NULL;
while（p）
{
q=p->next;
p->next=L->next;
L->next=p;
p=q;
}
}
2.23③设线性表A=（a1,...,am）,B=（b1,...,bn），试写一个按下列规则合并A、B为线性表C的算法，即使得C=（a1,b1,...,am,bm,bm+1,...,bn）当m≤n时；或者C=（a1,b1,...,an,bn,an+1,...,am）当m＞n时。
线性表A、B和C均以单链表作存储结构，且C表利用A表和B表中的结点空间构成。
注意：
单链表的长度值m和n均未显式存储。
实现下列函数：
voidMerge（LinkListha,LinkListhb,LinkList&hc）
/*依题意，合并带头结点的单链表ha和hb为hc*/
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
voidMerge（LinkListha,LinkListhb,LinkList&hc）
/*依题意，合并带头结点的单链表ha和hb为hc*/
{
LNode*pa,*pb,*pc;
pa=ha->next;
pb=hb->next;
pc=ha;
if（!
pa）hc=hb;
if（!
pb）hc=ha;
else
{
do{
pc->next=pa;
pc=pc->next;
pa=pa->next;
pc->next=pb;
pc=pc->next;
pb=pb->next;
}while（pa&&pb）;
if（pb==NULL）pc->next=pa;
elsepc->next=pb;
hc=ha;
}
}
2.26④假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合（即同一表中的元素值各不相同），现要求另辟空间构成一个线性表C，其元素为A和B中元素的交集，且表C中的元素也依值递增有序排列。
试对单链表编写求C的算法。
实现下列函数：
voidIntersect（LinkList&hc,LinkListha,LinkListhb）;
单链表类型定义如下：
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
voidIntersect（LinkList&hc,LinkListha,LinkListhb）
{
LNode*p=ha->next,*q=hb->next,*pc,*sub;
sub=（LNode*）malloc（sizeof（LNode））;
hc=sub;pc=sub;
while（p&&q）
{
if（p->data==q->data）
{
sub=（LNode*）malloc（sizeof（LNode））;
pc->next=sub;
pc=pc->next;
pc->data=p->data;
p=p->next;
q=q->next;
}
else{
if（p->datadata）p=p->next;
elseq=q->n
升级会员 