一元多项式的加法，减法，乘法用到比较多的是插入，删除操作。所以一般选择单链表作为存储结构。每个结点分别有系数，指针作为数据域，以及指针域。

算法实现：

一.一元多项式加法：

1.建立多项式：尾插法建立一元多项式的链表，通过键盘输入多项式的系数和指数，以输入系数0为结束标志，并约定建立一元多项式链表时，总是按指数从小到大的顺序排列。

2.输出多项式：从单链表的第一项开始逐项读出系数和指数，按多项式的形式输出。

3.多项式相加：设La和Lb分别表示两个多项式。Lc表示和多项式。p,q，r分别表示指向单链表的当前项比较指数大小。

（1）若La->exp<Lb->exp,则结点p应是和多项式中的一项，将p复制到r，并使p后移。

（2）若La->exp = Lb->exp,则将两个结点中的系数相加，当和不为0时，La的系数域加上Lb的系数域作为Lc的系数域；若和为0，则和多项式中没有这一项，p,q后移。

（3）若La->exp > Lb->exp,则将结点q复制到Lc中，q后移。


二.一元多项式减法

算法：将减数多项式的所有系数先变为相反数，然后调用多项式相加的函数进行运算。


三.一元多项式乘法

两个多项式相乘，应该是第一个多项式中的每一项分别与第二个多项式相乘，将相乘得到的结果都存在第一个多项式中，再调用合并多项式的函数。我写的多项式相乘用到了两重循环，合并多项式也用到了两重循环。



小结：在这次代码实现中，主要还是基础的一些线性表的操作的练习，还可以进一步改良的地方就是可以在合并多项式这部分与多项式相加写成一个函数，这样可以减少代码量，代码的通用性更高。


附：源代码

#include<stdio.h>

#include<stdlib.h>



typedef struct NODE{

int coef; //系数

int exp; //指数

struct NODE *next;

}polynode,*Polylist;


int output_list(Polylist head);


Polylist Creat_list(){ //创建链表

Polylist head,rear,s;

head = (Polylist)malloc(sizeof(polynode));

rear = head;


while(1){

printf("input the coef,exp:\n");

s = (Polylist)malloc(sizeof(polynode));

scanf("%d", &s->coef);

if(!s->coef){

free(s);

break;

}

scanf("%d", &s->exp);

rear->next = s;

rear = s;

}

rear->next = NULL;

return (head);

}



Polylist add_list(Polylist head1,Polylist head2){ //多项式加法

Polylist p, q, s, head, tail; 

p = head1->next;

q = head2->next;

tail = head = (Polylist)malloc(sizeof(polynode));

while(p && q){

s = (Polylist)malloc(sizeof(polynode));

if(p->exp < q->exp){ //当P的指数小于Q的指数时

s->coef = p->coef;

s->exp = p->exp;

tail->next = s; 

tail = s;

tail ->next = NULL;

p = p->next;


}

else if(p->exp == q->exp){ //当指数相等时

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

s->exp = p->exp;

if (!s->coef){

free(s);

}

else{

tail->next = s; 

tail = s;

tail ->next = NULL;

}

p = p->next;

q = q->next;

}


else{ 

s->coef = q->coef;

s->exp = q->exp;

tail->next = s; 

tail = s;

tail ->next = NULL; 

q = q->next;

}

}

if(p)

tail->next = p;

else

tail->next = q;

return head;

}



Polylist sub_list(Polylist head1,Polylist head2){ //多项式减法

Polylist p ,head;

p = head2->next;

do{ 

p->coef = -p->coef;

p = p->next;

}while(p);

head =add_list(head1,head2);

return head; 

}




Polylist polyadd_list(Polylist head){ //合并多项式

Polylist p,q,m;

p = m = head->next;

while(p ->next ){

m = p;

q = p->next;

while(q){

if(q->exp == p->exp){ 

p->coef += q->coef;

m->next = q->next;

free(q);

q = m->next;

}

else{

m = q;

q = q->next;

}

}

p = p->next;

}

return head;

}



Polylist multi_list(Polylist head1,Polylist head2){ //多项式乘法

Polylist head,p,q,r,m;

head = r = (Polylist)malloc(sizeof(polynode));


for(p = head1->next;p != NULL;p = p->next)

{

for(q = head2->next;q != NULL;q = q->next)

{

m = (Polylist)malloc(sizeof(polynode));

m->coef = p->coef * q->coef;

m->exp = p->exp + q->exp;

r->next = m;

r = m;

}

}

r->next = NULL;

output_list(head);

polyadd_list(head);

return head;

}




int output_list(Polylist head){ //输出多项式

Polylist p;

int n = 1;

for(p = head->next;p !=NULL;p = p->next){

printf("第%d项：%d   %d   \n", n++,p->coef,p->exp);

}

return 0;

}


 

int main(){

Polylist head1,head2,head;

head1 = Creat_list();

head2 = Creat_list();


 

printf("多项式加法：\n");

    head =add_list(head1,head2);

output_list(head);


printf("多项式减法：\n");

head = sub_list(head1,head2); 

 output_list(head);

 


printf("多项式乘法：\n");

head = multi_list(head1,head2);

output_list(head);



return 0;

} 

一元多项式的乘法与加法运算（java顺序存储结构实现）
设计函数分别求两个一元多项式的乘积与和。

输入格式:

输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。
输出格式:

输出分2行，分别以指数递降方式输出 乘积多项式 以及 和多项式 非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。
import java.util.Scanner;

public class demo02 
{
	public static void main(String[] args) 
	{
		/**
			一元多项式的乘法与加法运算
			设计函数分别求两个一元多项式的乘积与和。
输入格式:
输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

输出格式:
输出分2行，分别以指数递降方式输出 乘积多项式 以及 和多项式 非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。
		*/

		Scanner scan = new Scanner(System.in);
		System.out.print("请输入第一行数字：");
		String str1 = scan.nextLine();
		String[] arr1 = str1.split(" ");
		int num1[] = new int[arr1.length];
		for(int i = 0; i<num1.length; i++){
			num1[i] = Integer.parseInt(arr1[i]);
		}
		System.out.print("请输入第二行数字：");
		String str2 = scan.nextLine();
		String[] arr2 = str2.split(" ");
		int num2[] = new int[arr2.length];
		for(int i = 0; i<num2.length; i++){
			num2[i] = Integer.parseInt(arr2[i]);
		}

		long startTime=System.currentTimeMillis();     //计时器
		/*
			一、线性存储结构
			做成数组形式
		*/
		int[] c = add(num1, num2);		//多项式之和
		System.out.print("合并同类项：");
		for (int i=0; i<c.length; i++ )
		{
			System.out.print(c[i]+" ");
		}

		int[] d = multi(num1,num2);		//多项式之积
		System.out.println("多项式乘积：");
		for (int i=0; i<d.length; i++ )
		{
			System.out.print(d[i]+" ");
		}

		
		long endTime=System.currentTimeMillis(); 
		long spentTime=(endTime-startTime);
		System.out.print("耗时："+spentTime+"ms");
		scan.close();
	}

	public static int[] add(int[] a, int[] b){
		/*顺序存储结构下的多项式之和
			以两个数组的长度之和构造一个新数组，将计算值放入新数组中
			使用same计算中间可能合并的项数
			如果无法合并时，将较大项放入到新数组中
		*/
		int[] c = new int[(a.length+b.length-1)];    //新建立数组
		int m = a[0];    //第一行的多项式项数
		int n = b[0];    //第二行的多项式项数
		int l = m+n;						   //新数组的项数
		int i=1, j=1, k=1;
		int same=0;
		while(i<=a[0] && j<=b[0]){
			if(a[2*i]<b[2*j]){
				c[2*k] = b[2*j];
				c[2*k -1] = b[2*j -1];
				j++;
				k++;
			}
			else if(a[2*i]>b[2*j]){
				c[2*k] = a[2*i];
				c[2*k -1] = a[2*i -1];
				i++;
				k++;
			}
			else if(a[2*i] == b[2*j]){
				if(a[2*i-1]+b[2*j-1] == 0){
					i++;
					j++;
					same = same+2;
				}else{
					c[2*k] = a[2*i];
					c[2*k-1] = a[2*i-1]+b[2*j-1];
					same = same+1;
					i++;
					j++;
					k++;
				}
			}
		}
		while(i<=a[0]){
			c[2*k] = a[2*i];
			c[2*k -1] = a[2*i -1];
			i++;
			k++;
		}
		while(j<=b[0]){
			c[2*k] = b[2*j];
			c[2*k -1] = b[2*j -1];
			j++;
			k++;
		}

		l = l-same;
		c[0]=l;
		return c;
	}

	public static int[] multi(int[] a, int[] b){
		/*
			求解两个多项式的乘积
			首先定义一个二维数组，行数为a[0]，列数为b[0]*2+1，记为数组c[][]，分别使用数组a的每一项去和b的每一项相乘，得到二维数组c
			将二维数组c的每一行看做一个多项式，运用多项式的加法add函数进行组合
		*/
		int[][] c = new int[a[0]][b[0]*2 + 1];
		int[] d = new int[a[0]*b[0]*2 + 1];
		int k=1;

		for(int i=1; i<a[0]; i++){
			c[i-1][0] = b[0];
			k=1;
			for(int j=1; j<b[0]; j++){
				c[i-1][2*k] = a[2*i] + b[2*j];	//指数项乘积
				c[i-1][2*k-1] = a[2*i-1] * b[2*j-1];	//系数项乘积
				k++;
			}
		}
		for(int i=0; i<c.length; i++){
			d = add(d, c[i]);
		}
		return d;
	}
}

用 C语言实现一元多项式的运算（相加，相减，相乘）

1.创建多项式时，无论指数项按什么顺序输入，输出均能实现以升幂顺序输出，且输入时有相同指数项时能够实现合并。

2.能够代入确切的X计算出最终多项式的值。


模块划分

本程序划分为9个模块，分别是:                                     

1.主函数模块                                                            2.LocateElem模块（定位排序）                                

3.CreatePolyn模块（创建多项式）                          4.AddPolyn模块（多项式相加）                               

5.PrintPolyn模块（打印多项式）                             6.SubPolyn模块（多项式相减）                               

7.Reverse模块（升幂，降幂）                                8.MultiplyPolyn模块（多项式相乘）                            

9.Calculate模块（代入X求值）

 

定义部分

#include<stdio.h>
#include<stdlib.h>
#include<math.h> 

#define LEN sizeof(Poly)

typedef struct term{
    float coef;        //系数 
    int expn;        //指数 
    struct term *next;
}Poly,*Link;
int LocateElem(Link p, Link s, Link &q); 
void CreatePolyn(Link &p,int m);    //创建多项式 
void PrintPolyn(Link p);            //打印多项式（表示）            
int cmp(Link a, Link b);
Link AddPolyn(Link pa, Link pb);    //多项式相加 
Link SubPolyn(Link pa, Link pb);    //多项式相减 
Link Reverse(Link p);                //逆置多项式 
Link MultiplyPolyn(Link A,Link B);    //多项式相乘 
void Calculate(Link p,float x);        //多项式求值 


主函数部分

int main()
{
    Link P1,P2,P3;    //多项式 
    int L1,L2;        //多项式长度 
    printf("                        -------------------------------------------------------------------\n");
    printf("                        |==================       一元多项式的运算       =================|\n");
    printf("                        |==================          1.相加（+）         =================|\n");
    printf("                        |==================          2.相减（-）         =================|\n");
    printf("                        |==================          3.相乘（*）         =================|\n");
    printf("                        -------------------------------------------------------------------\n\n");
    printf("请输入第一个多项式的项数：");
    scanf("%d",&L1);
    CreatePolyn(P1,L1);
    printf("第一个多项式为：");
    printf("P1(X)=");
    PrintPolyn(P1);
    printf("请输入第二个多项式的项数：");
    scanf("%d",&L2);
    CreatePolyn(P2,L2);
    printf("第二个多项式为：");
    printf("P2(X)=");
    PrintPolyn(P2); 
    printf("\n");
    
    printf("请输入要选择的运算(+ , - , *): ");
    char ch1;
    getchar();        //清除掉缓冲区的回车符 
    scanf("%c",&ch1);
    getchar();        //清除掉缓冲区的回车符
     switch(ch1){
         case '+':{
             printf("两个一元多项式相加：   ");
             printf("P1(X)+P2(X)=");
             P3=AddPolyn(P1, P2);
            PrintPolyn(P3);
         }break;
         case '-':{
             printf("两个一元多项式相减：   ");
             printf("P1(X)-P2(X)=");
             P3=SubPolyn(P1, P2);
            PrintPolyn(P3);
         }break;
         case '*':{
             printf("两个一元多项式相乘：   ");
             printf("P1(X)*P2(X)=");
             P3=MultiplyPolyn(P1, P2);
            PrintPolyn(P3);
         }break;
         default:printf("您输入了错误指令 %c ！",ch1); 
     }

    char ch2;
    printf("\n是否代入X进行求值？(Y/N): ");
    ch2=getchar();        //清除掉缓冲区的回车符  
    getchar();
    switch(ch2){
        case 'Y':{
            float x;
            printf("\n请输入多项式中X的值：");
            scanf("%f",&x); 
            Calculate(P3,x);
            break;    
        }
        case 'N':break;
        default:printf("你输入了错误指令 %c ！",ch2); 
    } 
    return 0;
}


创建多项式部分

int LocateElem(Link p, Link s, Link &q){
/*
遍历链表p，每一个结点与s比较指数，
若相同,q指向相同指数项的结点，返回1，
若不相同，根据s所指指数大小在链表p中的位置来确定q的指向结点，返回0 
*/ 
    Link p1 = p->next;
    Link p2 = p;
    while(p1){
        if(s->expn > p1->expn){
            p1 = p1->next;
            p2 = p2->next;
        }else if(s->expn == p1->expn){
            q = p1; 
            return 1;
        }else{
            q = p2;
            return 0;
        }
    }
    if(!p1){
        q = p2;
        return 0;
    }
}

void CreatePolyn(Link &p,int m) 
/*
创建带头结点的链表(多项式) 
且无论按什么顺序输入，或是有相同指数项
最终在多项式中都是升幂顺序！ 
*/
{
    Link s,q;
    int i;
    p=(Link)malloc(LEN);
    p->next=NULL;
    for(i=0;i<m;i++)
    {
        s=(Link)malloc(LEN);
        printf("输入系数和指数（以空格隔开）:");
        scanf("%f %d", &s->coef, &s->expn);
        if(!LocateElem(p, s, q)){    //若没有相同指数项，则链入 
            s->next = q->next;
            q->next = s;
        }else{                        //若有相同指数项，则系数相加                        
            q->coef+=s->coef;
        }
    }
}


打印多项式部分

void PrintPolyn(Link p)
//打印显示多项式 
{
    Link s;
    s = p->next;
    while(s)
    {
            printf(" %.2f X^%d", s->coef, s->expn);
            s = s->next;
            if(s!=NULL)  
                if(s->coef>=0) printf(" +");
                //若下一项系数为正，则打印'+',否则不打印 
    }
    printf("\n");
}


多项式相加，相减部分

int cmp(Link a, Link b)
//比较两结点指数大小，根据情况返回不同值 
{
    if (a->expn<b->expn) return  -1;
    else if(a->expn == b->expn) return  0;
    else return 1;
}

Link AddPolyn(Link pa, Link pb)//pa,pb均指向头结点 
//两个多项式相加得一个新多项式，并且返回新多项式的头结点的指针   
{
    Link newp, p, q, s, pc;
    float sum;
    p = pa->next; 
    q = pb->next;
    newp=(Link)malloc(LEN); //新多项式的头结点 
    pc = newp;    //pc指向新多项式的头结点
    while(p&&q){
        switch(cmp(p, q))
        {
            case -1:// //若指数：p<q,则将p所指结点链入头结点为newp的链表中，且p向后遍历   
                s = (Link)malloc(LEN); 
                s->coef = p->coef;
                s->expn = p->expn;
                pc->next = s;
                pc = s;
                p = p->next;
                break;
            case 0://若比较两项的指数相等，则将两项系数相加后得到的项放入头结点为newp的链表中 ，且p,q同时向后遍历  
                sum = p->coef+q->coef; 
                if(sum!=0.0)//若两项系数相加为0，则不放入头结点为newp的链表中
                {
                    s = (Link)malloc(LEN);
                    s->coef = sum;
                    s->expn = p->expn;
                    pc->next = s;
                    pc = s;
                }
                p = p->next;
                q = q->next;
                break;
            case 1://若指数：q<p,则将q所指结点链入头结点为newp的链表中，且q向后遍历    
                s = (Link)malloc(LEN);
                s->coef = q->coef;
                s->expn = q->expn;
                pc->next = s;
                pc = s;
                q = q->next;
                break;
        }
    }
    pc->next=p?p:q;//链入pa或pb的剩余项 
    return newp;//返回新多项式的头指针 
}
Link SubPolyn(Link pa, Link pb)
/*
两个多项式相减得一个新多项式，并且返回新多项式的头结点的指针
相减就是先将减数中每一项的系数变为负，再将两个多项式相加 
*/ 
{
    Link newp, p, q, s, pc;
    float sum;
    newp=(Link)malloc(LEN); 
    pc = newp;
    p = pa->next; 
    q = pb->next;
    while(q){// 将pb中每一项的系数变为负 
        q->coef=0-q->coef;
        q=q->next;
    }
    q=pb->next;
    while(p&&q){
        switch(cmp(p, q))
        {
            case -1:  
                s = (Link)malloc(LEN); 
                s->coef = p->coef;
                s->expn = p->expn;
                pc->next = s;
                pc = s;
                p = p->next;
                break;
            case 0: 
                sum = p->coef + q->coef;//经提醒，由于前面减项系数已变，所以这里还是相加，谢谢！ 
                if(sum!=0.0)
                {
                    s = (Link)malloc(LEN);
                    s->coef = sum;
                    s->expn = p->expn;
                    pc->next = s;
                    pc = s;
                }
                p = p->next;
                q = q->next;
                break;
            case 1:    
                s = (Link)malloc(LEN);
                s->coef = q->coef;
                s->expn = q->expn;
                pc->next = s;
                pc = s;
                q = q->next;
                break;
        }
    }
    pc->next=p?p:q;
    return newp;
}


多项式相乘部分

Link Reverse(Link p)
/*
用头插法逆置链表，
使多项式由降幂变成升幂顺序
或使多项式由升幂变成降幂顺序
*/ 
{
    Link head=p; 
    Link q1,q2;
    q2=head->next;
    head->next=NULL;//断开头结点与第一个结点 
    while(q2)
    {
        q1=q2;      
        q2=q2->next; 
        q1->next=head->next; //头插 
        head->next=q1;  
    }      
    return head;//返回链表逆置后的头结点 
}
Link MultiplyPolyn(Link A,Link B)
/*
    两个多项式相乘得一个新多项式，并且返回新多项式的头结点的指针
    相乘前，A，B两个多项式均是升幂排序 
    相乘时，A为降幂排序，B为升幂排序  
*/
{
  Link pa,pb,pc,s,head;
  int k,maxExpn,minExpn;
  float coef;
  
  head=(Link)malloc(LEN);//头结点 
  head->next=NULL;
  
  if(A->next!=NULL&&B->next!=NULL){
      minExpn=A->next->expn+B->next->expn; //minExpn为两个多项式中指数和的最小值 
     A=Reverse(A);//将A降幂排列 
    B=Reverse(B);//将B降幂排列 
      maxExpn=A->next->expn+B->next->expn; //maxExpn为两个多项式中指数和的最大值
  }
  else{
          return head;
  }       
   pc=head;
   B=Reverse(B);//将B升幂排列 
   
   for(k = maxExpn;k>=minExpn;k--){ //多项式的乘积指数范围为：minExpn~maxExpn
           //根据两项的指数和使每一次循环都得到新多项式中一项  
           pa = A->next;
           while(pa !=NULL&&pa->expn>k){  //找到pa的位置 
               pa = pa->next;
           }
           pb = B->next;
           while(pb!=NULL&&pa!=NULL&&pa->expn+pb->expn<k){//如果指数和和小于k，pb后移结点 
               pb = pb->next;
           }
        coef=0.0;
        while(pa!=NULL&&pb!=NULL){
            if(pa->expn+pb->expn==k){ //如果指数和等于k,系数和累加，且pa，pb均后移结点 
                coef+=pa->coef*pb->coef;
                pa=pa->next;
                pb=pb->next;
            }
            else if(pa->expn+pb->expn>k){//如果指数和大于k，pb后移结点
                pa = pa->next;
            }
            else{//如果指数和和小于k，pb后移结点
                    pb = pb->next;
            }    
        }
        if(coef!=0.0){
        //如果系数和不为0，则生成新结点，将系数和指数赋给新结点后插入到新多项式中 
            s=(Link)malloc(LEN);
            s->coef=coef;
            s->expn=k;
            s->next=pc->next;
            pc->next=s;
            pc=s;
        }
   }
   B = Reverse(B);
   head=Reverse(head);
   return head;    //返回新多项式的头结点 
}


多项式求值部分

void Calculate(Link p,float x)
//代入确定的x到多项式中求值 
{
    Link q=p->next;
    float sum;
    float result=0;//求的结果 
    while(q){
        sum=1.0;
        for(int i=1;i<=q->expn;i++){//先求每一项的 X^expn 的值 
                sum=sum*x;
        }
        result+=sum*q->coef; //再使系数与sum相乘后求每一项的值，最后累加
        q=q->next; 
    }
    printf("将X的值代入多项式中计算的结果为：%.5f\n",result);
} 

代码测试

输入时多项式时每项的幂按乱序输入，且两个多项式中有抵消项时：


输入时多项式时每项的幂按乱序输入，两个多项式相乘：

 



Over!!!

两个一元多项式，并完成两多项式的乘法运算
实验要求
代码实现
测试用例

实验要求
利用顺序表或链表表示两个一元多项式，并完成两多项式的乘法运算。按指数的升序输入第一个一元多项式polya各项的指数和系数，且以输入0 0结束，按指数的升序输入第一个一元多项式polyb各项的指数和系数。输出两一元多项式乘积的一元多项式polyc，并进行算法时间复杂度的分析

例：(2+3x-3x^ 4)*(4x ^ 2+6x ^ 6 )= (8x^ 2+12x^ 3+18x^ 7-18x^10)

这道实验题注意好指数和系数就好了分别计算即可。


代码实现
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<malloc.h>
using namespace std;
#define OK   1
#define ERROR  0
#define TRUE 1
#define FALSE 0
typedef struct Polynode
{
	int coef; //系数 
	int exp;  //指数 
	Polynode* next;
}Polynode, * Polylist;
==void IninPolylist(Polylist* poly)== {
	*poly = (Polynode*)malloc(sizeof(Polynode));
	if (*poly) {
		(*poly)->next = NULL;
	}
	else {
		printf("创建失败！\n");
	}
}
==void Polyadd(Polylist poly, int coef, int exp)==
{
	Polynode* p = (Polynode*)poly;
	bool flag = 0;
	//排序问题(主要是针对exp的大小进行排序)
	while (p->next != NULL) {
		if (p->next->exp < exp) {
			p = p->next;
		}
		else if (p->next->exp == exp) {
			p->next->coef += coef;
			flag = 1;
			break;
		}
		else if (p->exp < exp && p->next->exp > exp) {
			Polynode* s = new Polynode;
			s->exp = exp, s->coef = coef;
			s->next = p->next;
			p->next = s;
			flag = 1;
			break;
		}
	}
	if (!flag) {
		Polynode* s = (Polynode*)new Polynode;
		s->exp = exp, s->coef = coef;
		s->next = p->next;
		p->next = s;
	}
}
void PolyCreate(Polylist poly)
{
	int c, e;
	scanf_s("%d%d", &e, &c);
	while (c != 0)
	{
		Polyadd(poly, c, e);
		scanf_s("%d%d", &e, &c);
	}
}
void PolyMul(Polylist polya, Polylist polyb, Polylist polyc)
{
	Polynode* p = polya->next;
	while (p != NULL) {
		Polynode* pre = new Polynode;
		pre = polyb->next;
		while (pre != NULL) {
			Polyadd(polyc, p->coef * pre->coef, p->exp + pre->exp);
			pre = pre->next;
		}
		delete pre;
		p = p->next;
	}
}
void OutputPolylist(Polylist poly) //输出多项式 
{
	Polylist p = poly->next;
	if (p != NULL)
	{
		if (p->coef < 0)
			cout << "-";
		cout << p->coef << "x^" << p->exp << " ";
		p = p->next;
	}
	while (p != NULL)
	{
		if (p->coef > 0)
			cout << "+ ";
		if (p->coef)
			cout << p->coef << "x^" << p->exp << " ";
		p = p->next;
	}
	cout << endl;
	return;
}
void DestoryPolylist(Polylist* poly) {
	Polylist p;
	while (*poly) {
		p = (*poly)->next;
		free(*poly);
		*poly = p;
	}
}

int main() {
	Polylist polya, polyb, polyc;
	printf("请输入多项式A中各项指数和系数:(以0,0结束!)\n");
	IninPolylist(&polya);
	PolyCreate(polya);
	printf("请输入多项式B中各项指数和系数:(以0,0结束!)\n");
	IninPolylist(&polyb);
	PolyCreate(polyb);
	IninPolylist(&polyc);
	PolyMul(polya, polyb, polyc);
	OutputPolylist(polyc);
	DestoryPolylist(&polya);
	DestoryPolylist(&polyb);
	DestoryPolylist(&polyc);
	return 0;
}

测试用例
测试用例一：