严蔚敏《数据结构c语言版习题集》答案第五章 数组和广义表文库.docx
《严蔚敏《数据结构c语言版习题集》答案第五章 数组和广义表文库.docx》由会员分享，可在线阅读，更多相关《严蔚敏《数据结构c语言版习题集》答案第五章 数组和广义表文库.docx（19页珍藏版）》请在冰豆网上搜索。
严蔚敏《数据结构c语言版习题集》答案第五章数组和广义表文库
第五章数组和广义表
5.18
voidRSh（intA[n],intk）//把数组A的元素循环右移k位,只用一个辅助存储空间
{
for（i=1;i<=k;i++）
if（n%i==0&&k%i==0）p=i;//求n和k的最大公约数p
for（i=0;i{j=i;l=（i+k）%n;temp=A[i];while（l!=i）{A[j]=temp;temp=A[l];A[l]=A[j];j=l;l=（j+k）%n;}//循环右移一步A[i]=temp;}//for}//RSh分析:要把A的元素循环右移k位,则A[0]移至A[k],A[k]移至A[2k]......直到最终回到A[0].然而这并没有全部解决问题,因为有可能有的元素在此过程中始终没有被访问过,而是被跳了过去.分析可知,当n和k的最大公约数为p时,只要分别以A[0],A[1],...A[p-1]为起点执行上述算法,就可以保证每一个元素都被且仅被右移一次,从而满足题目要求.也就是说,A的所有元素分别处在p个"循环链"上面.举例如下:n=15,k=6,则p=3.第一条链:A[0]->A[6],A[6]->A[12],A[12]->A[3],A[3]->A[9],A[9]->A[0].第二条链:A[1]->A[7],A[7]->A[13],A[13]->A[4],A[4]->A[10],A[10]->A[1].第三条链:A[2]->A[8],A[8]->A[14],A[14]->A[5],A[5]->A[11],A[11]->A[2].恰好使所有元素都右移一次.虽然未经数学证明,但作者相信上述规律应该是正确的.5.19voidGet_Saddle（intA[m][n]）//求矩阵A中的马鞍点{for（i=0;i{for（min=A[i][0],j=0;jif（A[i][j]for（j=0;jif（A[i][j]==min）//判断这个（些）最小值是否鞍点{for（flag=1,k=0;kif（minif（flag）printf（"Foundasaddleelement!\nA[%d][%d]=%d",i,j,A[i][j]）;}}//for}//Get_Saddle5.20本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.5.21voidTSMatrix_Add（TSMatrixA,TSMatrixB,TSMatrix&C）//三元组表示的稀疏矩阵加法{C.mu=A.mu;C.nu=A.nu;C.tu=0;pa=1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
j=i;l=（i+k）%n;temp=A[i];
while（l!
=i）
A[j]=temp;
temp=A[l];
A[l]=A[j];
j=l;l=（j+k）%n;
}//循环右移一步
A[i]=temp;
}//for
}//RSh
分析:
要把A的元素循环右移k位,则A[0]移至A[k],A[k]移至A[2k]......直到最终回到A[0].然而这并没有全部解决问题,因为有可能有的元素在此过程中始终没有被访问过,而是被跳了过去.分析可知,当n和k的最大公约数为p时,只要分别以A[0],A[1],...A[p-1]为起点执行上述算法,就可以保证每一个元素都被且仅被右移一次,从而满足题目要求.也就是说,A的所有元素分别处在p个"循环链"上面.举例如下:
n=15,k=6,则p=3.
第一条链:
A[0]->A[6],A[6]->A[12],A[12]->A[3],A[3]->A[9],A[9]->A[0].
第二条链:
A[1]->A[7],A[7]->A[13],A[13]->A[4],A[4]->A[10],A[10]->A[1].
第三条链:
A[2]->A[8],A[8]->A[14],A[14]->A[5],A[5]->A[11],A[11]->A[2].
恰好使所有元素都右移一次.
虽然未经数学证明,但作者相信上述规律应该是正确的.
5.19
voidGet_Saddle（intA[m][n]）//求矩阵A中的马鞍点
for（i=0;i{for（min=A[i][0],j=0;jif（A[i][j]for（j=0;jif（A[i][j]==min）//判断这个（些）最小值是否鞍点{for（flag=1,k=0;kif（minif（flag）printf（"Foundasaddleelement!\nA[%d][%d]=%d",i,j,A[i][j]）;}}//for}//Get_Saddle5.20本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.5.21voidTSMatrix_Add（TSMatrixA,TSMatrixB,TSMatrix&C）//三元组表示的稀疏矩阵加法{C.mu=A.mu;C.nu=A.nu;C.tu=0;pa=1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
for（min=A[i][0],j=0;jif（A[i][j]for（j=0;jif（A[i][j]==min）//判断这个（些）最小值是否鞍点{for（flag=1,k=0;kif（minif（flag）printf（"Foundasaddleelement!\nA[%d][%d]=%d",i,j,A[i][j]）;}}//for}//Get_Saddle5.20本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.5.21voidTSMatrix_Add（TSMatrixA,TSMatrixB,TSMatrix&C）//三元组表示的稀疏矩阵加法{C.mu=A.mu;C.nu=A.nu;C.tu=0;pa=1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
if（A[i][j]for（j=0;jif（A[i][j]==min）//判断这个（些）最小值是否鞍点{for（flag=1,k=0;kif（minif（flag）printf（"Foundasaddleelement!\nA[%d][%d]=%d",i,j,A[i][j]）;}}//for}//Get_Saddle5.20本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.5.21voidTSMatrix_Add（TSMatrixA,TSMatrixB,TSMatrix&C）//三元组表示的稀疏矩阵加法{C.mu=A.mu;C.nu=A.nu;C.tu=0;pa=1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
for（j=0;jif（A[i][j]==min）//判断这个（些）最小值是否鞍点{for（flag=1,k=0;kif（minif（flag）printf（"Foundasaddleelement!\nA[%d][%d]=%d",i,j,A[i][j]）;}}//for}//Get_Saddle5.20本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.5.21voidTSMatrix_Add（TSMatrixA,TSMatrixB,TSMatrix&C）//三元组表示的稀疏矩阵加法{C.mu=A.mu;C.nu=A.nu;C.tu=0;pa=1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
if（A[i][j]==min）//判断这个（些）最小值是否鞍点
for（flag=1,k=0;kif（minif（flag）printf（"Foundasaddleelement!\nA[%d][%d]=%d",i,j,A[i][j]）;}}//for}//Get_Saddle5.20本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.5.21voidTSMatrix_Add（TSMatrixA,TSMatrixB,TSMatrix&C）//三元组表示的稀疏矩阵加法{C.mu=A.mu;C.nu=A.nu;C.tu=0;pa=1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
if（minif（flag）printf（"Foundasaddleelement!\nA[%d][%d]=%d",i,j,A[i][j]）;}}//for}//Get_Saddle5.20本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.5.21voidTSMatrix_Add（TSMatrixA,TSMatrixB,TSMatrix&C）//三元组表示的稀疏矩阵加法{C.mu=A.mu;C.nu=A.nu;C.tu=0;pa=1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
if（flag）
printf（"Foundasaddleelement!
\nA[%d][%d]=%d",i,j,A[i][j]）;
}
}//Get_Saddle
5.20
本题难度极大,故仅探讨一下思路.这一题的难点在于,在多项式的元数m未知的情况下,如何按照降幂次序输出各项.可以考虑采取类似于层序遍历的思想,从最高次的项开始,依次对其每一元的次数减一,入一个队列.附设访问标志visited以避免重复.
5.21
voidTSMatrix_Add（TSMatrixA,TSMatrixB,TSMatrix&C）//三元组表示的稀疏矩阵加法
C.mu=A.mu;C.nu=A.nu;C.tu=0;
pa=1;pb=1;pc=1;
for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法
while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
while（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ce=A.data[pa].e+B.data[pb].e;if（ce）//和不为0{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=ce;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}else{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=A.data[pa].j;C.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{C.data[pc].i=x;C.data[pc].j=B.data[pb].j;C.data[pc].e=B.data[pb].e;pb++;pc++;}}//forC.tu=pc;}//TSMatrix_Add5.22voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上{for（i=1;i<=A.tu;i++）A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置pa=MAXSIZE-A.tu+1;pb=1;pc=1;for（x=1;x<=A.mu;x++）//对矩阵的每一行进行加法{while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
while（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素
if（A.data[pa].j==B.data[pb].j）
ce=A.data[pa].e+B.data[pb].e;
if（ce）//和不为0
C.data[pc].i=x;
C.data[pc].j=A.data[pa].j;
C.data[pc].e=ce;
pa++;pb++;pc++;
}//if
elseif（A.data[pa].j>B.data[pb].j）
C.data[pc].j=B.data[pb].j;
C.data[pc].e=B.data[pb].e;
pb++;pc++;
else
C.data[pc].e=A.data[pa].e
pa++;pc++;
}//while
while（A.data[pa]==x）//插入A中剩余的元素（第x行）
while（B.data[pb]==x）//插入B中剩余的元素（第x行）
C.tu=pc;
}//TSMatrix_Add
5.22
voidTSMatrix_Addto（TSMatrix&A,TSMatrixB）//将三元组矩阵B加到A上
for（i=1;i<=A.tu;i++）
A.data[MAXSIZE-A.tu+i]=A.data[i];/把A的所有元素都移到尾部以腾出位置
pa=MAXSIZE-A.tu+1;pb=1;pc=1;
while（A.data[pa].iwhile（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
while（B.data[pb].iwhile（A.data[pa].i==x&&B.data[pb].i==x）//行列值都相等的元素{if（A.data[pa].j==B.data[pb].j）{ne=A.data[pa].e+B.data[pb].e;if（ne）//和不为0{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=ne;pa++;pb++;pc++;}}//ifelseif（A.data[pa].j>B.data[pb].j）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}else{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}}//whilewhile（A.data[pa]==x）//插入A中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=A.data[pa].j;A.data[pc].e=A.data[pa].epa++;pc++;}while（B.data[pb]==x）//插入B中剩余的元素（第x行）{A.data[pc].i=x;A.data[pc].j=B.data[pb].j;A.data[pc].e=B.data[pb].e;pb++;pc++;}}//forA.tu=pc;for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
ne=A.data[pa].e+B.data[pb].e;
if（ne）//和不为0
A.data[pc].i=x;
A.data[pc].j=A.data[pa].j;
A.data[pc].e=ne;
A.data[pc].j=B.data[pb].j;
A.data[pc].e=B.data[pb].e;
A.data[pc].e=A.data[pa].e
A.tu=pc;
for（i=A.tu;i}//TSMatrix_Addto5.23typedefstruct{intj;inte;}DSElem;typedefstruct{DSElemdata[MAXSIZE];intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置intmu,nu,tu;}DSMatrix;//二元组矩阵类型StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e{for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
}//TSMatrix_Addto
5.23
typedefstruct{
intj;
inte;
}DSElem;
DSElemdata[MAXSIZE];
intcpot[MAXROW];//这个向量存储每一行在二元组中的起始位置
intmu,nu,tu;
}DSMatrix;//二元组矩阵类型
StatusDSMatrix_Locate（DSMatrixA,inti,intj,int&e）//求二元组矩阵的元素A[i][j]的值e
for（s=cpot[i];s=j;s++）;//注意查找范围if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]{e=A.data[s];returnOK;}returnERROR;}//DSMatrix_Locate5.24typedefstruct{intseq;//该元素在以行为主序排列时的序号inte;}SElem;typedefstruct{SElemdata[MAXSIZE];intmu,nu,tu;}SMatrix;//单下标二元组矩阵类型StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e{s=i*A.nu+j+1;p=1;while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
=j;s++）;//注意查找范围
if（A.data[s].i==i&&A.data[s].j==j）//找到了元素A[i][j]
e=A.data[s];
returnOK;
returnERROR;
}//DSMatrix_Locate
5.24
intseq;//该元素在以行为主序排列时的序号
}SElem;
SElemdata[MAXSIZE];
}SMatrix;//单下标二元组矩阵类型
StatusSMatrix_Locate（SMatrixA,inti,intj,int&e）//求单下标二元组矩阵的元素A[i][j]的值e
s=i*A.nu+j+1;p=1;
while（A.data[p].seqif（A.data[p].seq==s）//找到了元素A[i][j]{e=A.data[p].e;returnOK;}returnERROR;}//SMatrix_Locate5.25typedefenum{0,1}bool;typedefstruct{intmu,nu;intelem[MAXSIZE];boolmap[mu][nu];}BMMatrix;//用位图表示的矩阵类型voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法{C.mu=A.mu;C.nu=A.nu;pa=1;pb=1;pc=1;for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
if（A.data[p].seq==s）//找到了元素A[i][j]
e=A.data[p].e;
}//SMatrix_Locate
5.25
typedefenum{0,1}bool;
intmu,nu;
intelem[MAXSIZE];
boolmap[mu][nu];
}BMMatrix;//用位图表示的矩阵类型
voidBMMatrix_Add（BMMatrixA,BMMatrixB,BMMatrix&C）//位图矩阵的加法
C.mu=A.mu;C.nu=A.nu;
for（i=0;ifor（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
for（j=0;j{if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0{C.elem[pc]=A.elem[pa]+B.elem[pb];C.map[i][j]=1;pa++;pb++;pc++;}elseif（A.map[i][j]&&!B.map[i][j]）{C.elem[pc]=A.elem[pa];C.map[i][j]=1;pa++;pc++;}elseif（!A.map[i][j]&&B.map[i][j]）{C.elem[pc]=B.elem[pb];C.map[i][j]=1;pb++;pc++;}}}//BMMatrix_Add5.26voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵{for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
if（A.map[i][j]&&B.map[i][j]&&（A.elem[pa]+B.elem[pb]））//结果不为0
C.elem[pc]=A.elem[pa]+B.elem[pb];
C.map[i][j]=1;
elseif（A.map[i][j]&&!
B.map[i][j]）
C.elem[pc]=A.elem[pa];
elseif（!
A.map[i][j]&&B.map[i][j]）
C.elem[pc]=B.elem[pb];
}//BMMatrix_Add
5.26
voidPrint_OLMatrix（OLMatrixA）//以三元组格式输出十字链表表示的矩阵
for（i=0;i{if（A.rhead[i]）for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表printf（"%d%d%d\n",i,p->j,p->e;}}//Print_OLMatrix5.27voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上{for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针for（i=1;i<=A.mu;i++）{pa=A.rhead[i];pb=B.rhead[i];pre=NULL;while（pb）{if（pa==NULL||pa->j>pb->j）//新插入一个结点{p=（OLNode*）malloc（sizeof（OLNode））;if（!pre）A.rhead[i]=p;elsepre->right=p;p->right=pa;pre=p;p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中if（!A.chead[p->j]）{A.chead[p->j]=p;p->down=NULL;}else{while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;p->down=cp[p->j]->down;cp[p->j]->down=p;}cp[p->j]=p;//插入列链表中}//ifelseif（pa->jj）{pre=pa;pa=pa->right;}//pa右移一步elseif（pa->e+pb->e）{pa->e+=pb->e;pre=pa;pa=pa->right;pb=pb->right;}//直接相加else{if（!pre）A.rhead[i]=pa->right;elsepre->right=pa->right;p=pa;pa=pa->right;//从行链表中删除if（A.chead[p->j]==p）A.chead[p->j]=cp[p->j]=p->down;elsecp[p->j]->down=p->down;//从列链表中删除free（p）;}//else}//while}//for}//OLMatrix_Add分析:本题的具体思想在课本中有详细的解释说明.5.28voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导{for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）{if（p->tag）Mul（p->hp,p->exp）;elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上p->exp--;}pre->tp=NULL;if（p）free（p）;//删除可能存在的常数项}//MPList_PianDaovoidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x{for（p=L;p;p=p->tp）{if（!p->tag）p->coef*=x;elseMul（p->hp,x）;}}//Mul5.29voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法{C=（MPLNode*）malloc（sizeof（MPLNode））;if（!A->tag&&!B->tag）//原子项,可直接相加{C->coef=A->coef+B->coef;if（!C->coef）{free（C）;C=NULL;}}//ifelseif（A->tag&&B->tag）//两个多项式相加{p=A;q=B;pre=NULL;while（p&&q）{if（p->exp==q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;MPList_Add（A->hp,B->hp,C->hp）;pre->tp=C;pre=C;p=p->tp;q=q->tp;}elseif（p->exp>q->exp）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=A->hp;pre->tp=C;pre=C;p=p->tp;}else{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=B->hp;pre->tp=C;pre=C;q=q->tp;}}//whilewhile（p）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=p->exp;C->hp=p->hp;pre->tp=C;pre=C;p=p->tp;}while（q）{C=（MPLNode*）malloc（sizeof（MPLNode））;C->exp=q->exp;C->hp=q->hp;pre->tp=C;pre=C;q=q->tp;}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题}//elseifelseif（A->tag&&!B->tag）//多项式和常数项相加{x=B->coef;for（p=A;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}//否则新建常数项,下同}//elseifelse{x=A->coef;for（p=B;p->tp->tp;p=p->tp）;if（p->tp->exp==0）p->tp->coef+=x;if（!p->tp->coef）{free（p->tp）;p->tp=NULL;}else{q=（MPLNode*）malloc（sizeof（MPLNode））;q->coef=x;q->exp=0;q->tag=0;q->tp=NULL;p->tp=q;}}//else}//MPList_Add5.30intGList_Getdeph（GListL）//求广义表深度的递归算法{if（!L->tag）return0;//原子深度为0elseif（!L）return1;//空表深度为1m=GList_Getdeph（L->ptr.hp）+1;n=GList_Getdeph（L->ptr.tp）;returnm>n?m:n;}//GList_Getdeph5.31voidGList_Copy（GListA,GList&B）//复制广义表的递归算法{if（!A->tag）//当结点为原子时,直接复制{B->tag=0;B->atom=A->atom;}else//当结点为子表时{B->tag=1;if（A->ptr.hp）{B->ptr.hp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.hp,B->ptr.hp）;}//复制表头if（A->ptr.tp）{B->ptr.tp=malloc（sizeof（GLNode））;GList_Copy（A->ptr.tp,B->ptr.tp）;}//复制表尾}//else}//GList_Copy5.32intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0{//广义表相等可分三种情况:if（!A&&!B）return1;//空表是相等的if（!A->tag&&!B->tag&&A->atom==B->atom）return1;//原子的值相等if（A->tag&&B->tag）if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））return1;//表头表尾都相等return0;}//GList_Equal5.33voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次{if（!A）return;if（!A->tag）printf（"%d%d\n",A->atom,layer）;else{GList_PrintElem（A->ptr.hp,layer+1）;GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次}}//GList_PrintElem5.34voidGList_Reverse（GListA）//递归逆转广义表A{if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转{D=C->ptr.hp;A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾GList_Reverse（A->ptr.hp）;GList_Reverse（A->ptr.tp）;//逆转表头和表尾}}//GList_Reverse5.35StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针{scanf（"%c",&ch）;if（ch==''）{L=NULL;scanf（"%c",&ch）;if（ch!='）'）returnERROR;returnOK;}L=（GList）malloc（sizeof（GLNode））;L->tag=1;if（isalphabet（ch））//输入是字母{p=（GList）mallo
if（A.rhead[i]）
for（p=A.rhead[i];p;p=p->right）//逐次遍历每一个行链表
printf（"%d%d%d\n",i,p->j,p->e;
}//Print_OLMatrix
5.27
voidOLMatrix_Add（OLMatrix&A,OLMatrixB）//把十字链表表示的矩阵B加到A上
for（j=1;j<=A.nu;j++）cp[j]=A.chead[j];//向量cp存储每一列当前最后一个元素的指针
for（i=1;i<=A.mu;i++）
pa=A.rhead[i];pb=B.rhead[i];pre=NULL;
while（pb）
if（pa==NULL||pa->j>pb->j）//新插入一个结点
p=（OLNode*）malloc（sizeof（OLNode））;
if（!
pre）A.rhead[i]=p;
elsepre->right=p;
p->right=pa;pre=p;
p->i=i;p->j=pb->j;p->e=pb->e;//插入行链表中
A.chead[p->j]）
A.chead[p->j]=p;
p->down=NULL;
while（cp[p->j]->down）cp[p->j]=cp[p->j]->down;
p->down=cp[p->j]->down;
cp[p->j]->down=p;
cp[p->j]=p;//插入列链表中
elseif（pa->jj）
pre=pa;
pa=pa->right;
}//pa右移一步
elseif（pa->e+pb->e）
pa->e+=pb->e;
pre=pa;pa=pa->right;
pb=pb->right;
}//直接相加
pre）A.rhead[i]=pa->right;
elsepre->right=pa->right;
p=pa;pa=pa->right;//从行链表中删除
if（A.chead[p->j]==p）
A.chead[p->j]=cp[p->j]=p->down;
elsecp[p->j]->down=p->down;//从列链表中删除
free（p）;
}//else
}//OLMatrix_Add
本题的具体思想在课本中有详细的解释说明.
5.28
voidMPList_PianDao（MPList&L）//对广义表存储结构的多元多项式求第一变元的偏导
for（p=L->hp->tp;p&&p->exp;pre=p,p=p->tp）
if（p->tag）Mul（p->hp,p->exp）;
elsep->coef*=p->exp;//把指数乘在本结点或其下属结点上
p->exp--;
pre->tp=NULL;
if（p）free（p）;//删除可能存在的常数项
}//MPList_PianDao
voidMul（MPList&L,intx）//递归算法,对多元多项式L乘以x
for（p=L;p;p=p->tp）
p->tag）p->coef*=x;
elseMul（p->hp,x）;
}//Mul
5.29
voidMPList_Add（MPListA,MPListB,MPList&C）//广义表存储结构的多项式相加的递归算法
C=（MPLNode*）malloc（sizeof（MPLNode））;
A->tag&&!
B->tag）//原子项,可直接相加
C->coef=A->coef+B->coef;
C->coef）
free（C）;
C=NULL;
elseif（A->tag&&B->tag）//两个多项式相加
p=A;q=B;pre=NULL;
while（p&&q）
if（p->exp==q->exp）
C->exp=p->exp;
MPList_Add（A->hp,B->hp,C->hp）;
pre->tp=C;pre=C;
p=p->tp;q=q->tp;
elseif（p->exp>q->exp）
C->hp=A->hp;
p=p->tp;
C->exp=q->exp;
C->hp=B->hp;
q=q->tp;
while（p）
C->hp=p->hp;
while（q）
C->hp=q->hp;
}//将其同次项分别相加得到新的多项式,原理见第二章多项式相加一题
}//elseif
elseif（A->tag&&!
B->tag）//多项式和常数项相加
x=B->coef;
for（p=A;p->tp->tp;p=p->tp）;
if（p->tp->exp==0）p->tp->coef+=x;//当多项式中含有常数项时,加上常数项
p->tp->coef）
free（p->tp）;
p->tp=NULL;
q=（MPLNode*）malloc（sizeof（MPLNode））;
q->coef=x;q->exp=0;
q->tag=0;q->tp=NULL;
p->tp=q;
}//否则新建常数项,下同
x=A->coef;
for（p=B;p->tp->tp;p=p->tp）;
if（p->tp->exp==0）p->tp->coef+=x;
}//MPList_Add
5.30
intGList_Getdeph（GListL）//求广义表深度的递归算法
L->tag）return0;//原子深度为0
L）return1;//空表深度为1
m=GList_Getdeph（L->ptr.hp）+1;
n=GList_Getdeph（L->ptr.tp）;
returnm>n?
m:
n;
}//GList_Getdeph
5.31
voidGList_Copy（GListA,GList&B）//复制广义表的递归算法
A->tag）//当结点为原子时,直接复制
B->tag=0;
B->atom=A->atom;
else//当结点为子表时
B->tag=1;
if（A->ptr.hp）
B->ptr.hp=malloc（sizeof（GLNode））;
GList_Copy（A->ptr.hp,B->ptr.hp）;
}//复制表头
if（A->ptr.tp）
B->ptr.tp=malloc（sizeof（GLNode））;
GList_Copy（A->ptr.tp,B->ptr.tp）;
}//复制表尾
}//GList_Copy
5.32
intGList_Equal（GListA,GListB）//判断广义表A和B是否相等,是则返回1,否则返回0
{//广义表相等可分三种情况:
A&&!
B）return1;//空表是相等的
B->tag&&A->atom==B->atom）return1;//原子的值相等
if（A->tag&&B->tag）
if（GList_Equal（A->ptr.hp,B->ptr.hp）&&GList_Equal（A->ptr.tp,B->ptr.tp））
return1;//表头表尾都相等
return0;
}//GList_Equal
5.33
voidGList_PrintElem（GListA,intlayer）//递归输出广义表的原子及其所在层次,layer表示当前层次
A）return;
A->tag）printf（"%d%d\n",A->atom,layer）;
GList_PrintElem（A->ptr.hp,layer+1）;
GList_PrintElem（A->ptr.tp,layer）;//注意尾表与原表是同一层次
}//GList_PrintElem
5.34
voidGList_Reverse（GListA）//递归逆转广义表A
if（A->tag&&A->ptr.tp）//当A不为原子且表尾非空时才需逆转
D=C->ptr.hp;
A->ptr.tp->ptr.hp=A->ptr.hp;A->ptr.hp=D;//交换表头和表尾
GList_Reverse（A->ptr.hp）;
GList_Reverse（A->ptr.tp）;//逆转表头和表尾
}//GList_Reverse
5.35
StatusCreate_GList（GList&L）//根据输入创建广义表L,并返回指针
scanf（"%c",&ch）;
if（ch==''）
L=NULL;
if（ch!
='）'）returnERROR;
L=（GList）malloc（sizeof（GLNode））;
L->tag=1;
if（isalphabet（ch））//输入是字母
p=（GList）mallo
copyright@ 2008-2022 冰豆网网站版权所有
经营许可证编号:鄂ICP备2022015515号-1
升级会员 