请教，菜单问题，只能完整运行case 1，其他就是空白

出问题代码

int menu_create()
{int a;
 printf(" 输入 1 查看两多项式相加结果 \n 输入 2 查看两多项式相减结果 \n 输入 3 查看两多项式相乘结果 \n");
 scanf("%d",&a);
 if(a!=1&&a!=2&&a!=3)printf(" 输入有误 ");
 return a;
}
int main()
{ PolyNode *h1,*h2,*h;
 h1=Creatpoly();
 printf(" 该多项式为 P1(x)=");
 UnitePoly(h1);
 Insortup(h1);
 Prin_poly(h1);
 printf("\n");
 h2=Creatpoly();
 printf(" 该多项式为 P2(x)=");
 UnitePoly(h2);
 Insortup(h2);
 Prin_poly(h2);
 printf("\n");
 for(;;)
 {switch(menu_create())
 {
	case 1:printf(" 相加后的多项式 \n");
           {
		   h=addition(h1,h2);
           UnitePoly(h);
           printf(" 按 X 的升幂排列 ");
           Insortup(h);
           Prin_poly(h);
           printf("\n");
           printf(" 按 X 的降幂排列 ");
           Insortdown(h);
           Prin_poly(h);
           printf("\n");}
           break;
    case 2:printf(" 相减后的多项式 \n");
    {
           h=subduction(h1,h2);
           UnitePoly(h);
           printf(" 按 X 的升幂排列 ");
           Insortup(h);
           Prin_poly(h);
           printf("\n");
           printf(" 按 X 的降幂排列 ");
           Insortdown(h);
           Prin_poly(h);
           printf("\n");}
		   break;
	case 3:printf(" 相乘后的多项式为 \n");
	{
           h=polymuti(h1,h2);
           UnitePoly(h);
           printf(" 按 X 的升幂排列 ");
           Insortup(h);
           Prin_poly(h);
           printf("\n");
           printf(" 按 X 的降幂排列 ");
           Insortdown(h);
           Prin_poly(h);
           printf("\n");}
		   break;	        
 }
 }
return 0;
}

运行出来就是这样

出不来case2和case3的结果

源代码

#include<stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct Node
{
 int coef;// 系数
 int exp;// 指数
 struct Node *next;
}PolyNode;
PolyNode *Creatpoly()// 创建多项式的单链表
{
 PolyNode *h,*p,*q;
 h=(PolyNode *)malloc(sizeof(PolyNode));
 p=h;
 p->next=NULL;
 printf(" 请输入多项式的系数及其指数 a b ，当系数输入 0 时停止输入 \n");
 q=(PolyNode *)malloc(sizeof(PolyNode));
 scanf("%d %d",&q->coef,&q->exp);
 while(q->coef!=0)
 {
   p->next=q;
   p=q;
   q=(PolyNode *)malloc(sizeof(PolyNode));
   scanf("%d %d",&q->coef,&q->exp);
 }
 p->next=NULL;
 return(h);
}
void Prin_poly(PolyNode *h)// 将多项式输出函数
{
 PolyNode *p;
 p=h->next;
 while(p!=NULL)
 {  
   if(p->coef>0&&p!=h->next)
   {
     if(p->exp>0)
       printf("+%dx^%d",p->coef,p->exp);
     else if(p->exp<0)
       printf("+%dx^(%d)",p->coef,p->exp);
     else
       printf("+%d",p->coef);
   }
   else if(p->coef<0&&p!=h->next)
   {
     if(p->exp>0)
       printf("%dx^%d",p->coef,p->exp);
     else if(p->exp<0)
       printf("%dx^(%d)",p->coef,p->exp);
     else
       printf("%d",p->coef);
   }
   else 
   {
     if(p->exp>0)
       printf("%dx^%d",p->coef,p->exp);
     else if(p->exp<0)
       printf("%dx^(%d)",p->coef,p->exp);
     else printf("%d",p->coef);
   }
   p=p->next;
 }
}
void Insortup(PolyNode *h)// 排序函数，使多项式中的各项按 X 的升幂排列
{
 PolyNode *s,*p;
 int t,m;
 for(p=h->next;p!=NULL;p=p->next)// 类似于冒泡排序
 {  
   for(s=h->next;s->next!=NULL;s=s->next)
   {
     if(s->exp>s->next->exp)
     {
       t=s->exp;
       m=s->coef;
       s->coef=s->next->coef;
       s->exp=s->next->exp;
       s->next->coef=m;
       s->next->exp=t;
     }
   }
 }
}
void Insortdown(PolyNode *h)// 排序函数，使多项式中的各项按 X 的降幂排列
{
 PolyNode *s,*p;
 int t,m;
 for(p=h->next;p!=NULL;p=p->next)// 类似于冒泡排序
 {  
   for(s=h->next;s->next!=NULL;s=s->next)
   {
     if(s->exp<s->next->exp)
     {
       t=s->exp;
       m=s->coef;
       s->coef=s->next->coef;
       s->exp=s->next->exp;
       s->next->coef=m;
       s->next->exp=t;
     }
   }
 }
}
void UnitePoly(PolyNode *h)// 合并同类项
{
 PolyNode *p1,*p2,*q1,*q2,*temp;
 q1=h;
 p1=q1->next;
 while(p1!=NULL)
 {
   p2=p1->next;
   q2=p1;
   while(p2!=NULL)
   {
     if(p1->exp==p2->exp)
     {
       p1->coef=p1->coef+p2->coef;
       if(p1->coef==0)
       {
         temp=p2;
         q2->next=p2->next;
         free(temp);
         temp=p1;
         q1->next=p1->next;
         p1=q1;
         free(temp);
         break;
       }
       else
       {
         temp=p2;
         q2->next=p2->next;
         p2=p2->next;
         free(temp);
       }
     }
     else
     {
       q2=p2;
       p2=p2->next;
     }
   }
   q1=p1;
   p1=p1->next;
 }
}
PolyNode *polymuti(PolyNode *h1,PolyNode *h2)// 多项式相乘
{
 PolyNode *h,*p,*p1,*p2,*q;
 p1=h1->next;
 h=p=(PolyNode *)malloc(sizeof(PolyNode));
 p->next=NULL;
 while(p1)
 {
   p2=h2->next;
   while(p2)
   {
     q=(PolyNode *)malloc(sizeof(PolyNode));
     q->coef=p1->coef*p2->coef;
     q->exp=p1->exp+p2->exp;
     p->next=q;
     p=q;
     p2=p2->next;
   }
   p1=p1->next;
 }
 p->next=NULL;
 return(h);
}
PolyNode *addition(PolyNode *ha, PolyNode *hb)// 一元多项式相加函数，用于将两个多项式相加，然后将和多项式存放在多项式 ha 中，并将多项式 hb 删除
 { 
 PolyNode *p,*q,*pre,*temp; 
int sum; 
p=ha->next; 
q=hb->next; 
pre=ha;
 while(p!=NULL&&q!=NULL) {
 if(p->exp<q->exp) {
 pre->next=p;
 pre=pre->next;
 p=p->next;
 } 
else if(p->exp==q->exp)
 {
 sum=p->coef+q->coef;
 if(sum!=0) {
 p->coef=sum; 
pre->next=p;
pre=pre->next;
p=p->next;
 temp=q;q=q->next;free(temp); 
}
 else // 如果系数和为零，则删除结点 p 与 q ，并将指针指向下一个结点
 {
 temp=p->next;
free(p);
p=temp;
 temp=q->next;
free(q);
q=temp;
 } }
 else {
 pre->next=q;
 pre=pre->next;
 q=q->next;
 } }
 if(p!=NULL) // 将多项式 A 中剩余的结点加入到和多项式中
 pre->next=p;
 else pre->next=q; 
 return ha;
}
PolyNode *subduction(PolyNode *ha, PolyNode *hb)// 一元多项式相减函数，用于将两个多项式相减，然后将差多项式存放在多项式 ha 中，并将多项式 hb 删除
 { 
 PolyNode *p,*q,*pre,*temp; 
int sum; 
p=ha->next; 
q=hb->next; 
pre=ha;
 while(p!=NULL&&q!=NULL) {
 if(p->exp<q->exp) {
 pre->next=p;
 pre=pre->next;
 p=p->next;
 } 
else if(p->exp==q->exp)
 {
 sum=p->coef-q->coef;
 if(sum!=0) {
 p->coef=sum; 
pre->next=p;
pre=pre->next;
p=p->next;
 temp=q;q=q->next;free(temp); 
}
 else // 如果系数和为零，则删除结点 p 与 q ，并将指针指向下一个结点
 {
 temp=p->next;
free(p);
p=temp;
 temp=q->next;
free(q);
q=temp;
 } }
 else {
 pre->next=q;
 pre=pre->next;
 q=q->next;
 } }
 if(p!=NULL) // 将多项式 A 中剩余的结点加入到和多项式中
 pre->next=p;
 else pre->next=q; 
 return ha;
} 
int menu_create()
{int a;
 printf(" 输入 1 查看两多项式相加结果 \n 输入 2 查看两多项式相减结果 \n 输入 3 查看两多项式相乘结果 \n");
 scanf("%d",&a);
 if(a!=1&&a!=2&&a!=3)printf(" 输入有误 ");
 return a;
}
int main()
{ PolyNode *h1,*h2,*h;
 h1=Creatpoly();
 printf(" 该多项式为 P1(x)=");
 UnitePoly(h1);
 Insortup(h1);
 Prin_poly(h1);
 printf("\n");
 h2=Creatpoly();
 printf(" 该多项式为 P2(x)=");
 UnitePoly(h2);
 Insortup(h2);
 Prin_poly(h2);
 printf("\n");
 for(;;)
 {switch(menu_create())
 {
	case 1:printf(" 相加后的多项式 \n");
           {
		   h=addition(h1,h2);
           UnitePoly(h);
           printf(" 按 X 的升幂排列 ");
           Insortup(h);
           Prin_poly(h);
           printf("\n");
           printf(" 按 X 的降幂排列 ");
           Insortdown(h);
           Prin_poly(h);
           printf("\n");}
           break;
    case 2:printf(" 相减后的多项式 \n");
    {
           h=subduction(h1,h2);
           UnitePoly(h);
           printf(" 按 X 的升幂排列 ");
           Insortup(h);
           Prin_poly(h);
           printf("\n");
           printf(" 按 X 的降幂排列 ");
           Insortdown(h);
           Prin_poly(h);
           printf("\n");}
		   break;
	case 3:printf(" 相乘后的多项式为 \n");
	{
           h=polymuti(h1,h2);
           UnitePoly(h);
           printf(" 按 X 的升幂排列 ");
           Insortup(h);
           Prin_poly(h);
           printf("\n");
           printf(" 按 X 的降幂排列 ");
           Insortdown(h);
           Prin_poly(h);
           printf("\n");}
		   break;	        
 }
 }
return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct Node
{
    int coef; // 系数
    int exp;  // 指数
    struct Node *next;
} PolyNode;
PolyNode *Creatpoly() // 创建多项式的单链表
{
    PolyNode *h, *p, *q;
    h = (PolyNode *)malloc(sizeof(PolyNode));
    p = h;
    p->next = NULL;
    printf(" 请输入多项式的系数及其指数 a b ，当系数输入 0 时停止输入 \n");
    q = (PolyNode *)malloc(sizeof(PolyNode));
    scanf("%d %d", &q->coef, &q->exp);
    while (q->coef != 0)
    {
        p->next = q;
        p = q;
        q = (PolyNode *)malloc(sizeof(PolyNode));
        scanf("%d %d", &q->coef, &q->exp);
    }
    p->next = NULL;
    return (h);
}
void Prin_poly(PolyNode *h) // 将多项式输出函数
{
    PolyNode *p;
    p = h->next;
    while (p != NULL)
    {
        if (p->coef > 0 && p != h->next)
        {
            if (p->exp > 0)
                printf("+%dx^%d", p->coef, p->exp);
            else if (p->exp < 0)
                printf("+%dx^(%d)", p->coef, p->exp);
            else
                printf("+%d", p->coef);
        }
        else if (p->coef < 0 && p != h->next)
        {
            if (p->exp > 0)
                printf("%dx^%d", p->coef, p->exp);
            else if (p->exp < 0)
                printf("%dx^(%d)", p->coef, p->exp);
            else
                printf("%d", p->coef);
        }
        else
        {
            if (p->exp > 0)
                printf("%dx^%d", p->coef, p->exp);
            else if (p->exp < 0)
                printf("%dx^(%d)", p->coef, p->exp);
            else
                printf("%d", p->coef);
        }
        p = p->next;
    }
}
void Insortup(PolyNode *h) // 排序函数，使多项式中的各项按 X 的升幂排列
{
    PolyNode *s, *p;
    int t, m;
    for (p = h->next; p != NULL; p = p->next) // 类似于冒泡排序
    {
        for (s = h->next; s->next != NULL; s = s->next)
        {
            if (s->exp > s->next->exp)
            {
                t = s->exp;
                m = s->coef;
                s->coef = s->next->coef;
                s->exp = s->next->exp;
                s->next->coef = m;
                s->next->exp = t;
            }
        }
    }
}
void Insortdown(PolyNode *h) // 排序函数，使多项式中的各项按 X 的降幂排列
{
    PolyNode *s, *p;
    int t, m;
    for (p = h->next; p != NULL; p = p->next) // 类似于冒泡排序
    {
        for (s = h->next; s->next != NULL; s = s->next)
        {
            if (s->exp < s->next->exp)
            {
                t = s->exp;
                m = s->coef;
                s->coef = s->next->coef;
                s->exp = s->next->exp;
                s->next->coef = m;
                s->next->exp = t;
            }
        }
    }
}
void UnitePoly(PolyNode *h) // 合并同类项
{
    PolyNode *p1, *p2, *q1, *q2, *temp;
    q1 = h;
    p1 = q1->next;
    while (p1 != NULL)
    {
        p2 = p1->next;
        q2 = p1;
        while (p2 != NULL)
        {
            if (p1->exp == p2->exp)
            {
                p1->coef = p1->coef + p2->coef;
                if (p1->coef == 0)
                {
                    temp = p2;
                    q2->next = p2->next;
                    free(temp);
                    temp = p1;
                    q1->next = p1->next;
                    p1 = q1;
                    free(temp);
                    break;
                }
                else
                {
                    temp = p2;
                    q2->next = p2->next;
                    p2 = p2->next;
                    free(temp);
                }
            }
            else
            {
                q2 = p2;
                p2 = p2->next;
            }
        }
        q1 = p1;
        p1 = p1->next;
    }
}
PolyNode *polymuti(PolyNode *h1, PolyNode *h2) // 多项式相乘
{
    PolyNode *h, *p, *p1, *p2, *q;
    p1 = h1->next;
    h = p = (PolyNode *)malloc(sizeof(PolyNode));
    p->next = NULL;
    while (p1)
    {
        p2 = h2->next;
        while (p2)
        {
            q = (PolyNode *)malloc(sizeof(PolyNode));
            q->coef = p1->coef * p2->coef;
            q->exp = p1->exp + p2->exp;
            p->next = q;
            p = q;
            p2 = p2->next;
        }
        p1 = p1->next;
    }
    p->next = NULL;
    return (h);
}
PolyNode *addition(PolyNode *ha, PolyNode *hb) // 一元多项式相加函数，用于将两个多项式相加，然后将和多项式存放在多项式 ha 中，并将多项式 hb 删除
{
    PolyNode *p, *q, *pre, *temp,*Head,*pH,*qH;
    Head = (PolyNode *)malloc(sizeof(PolyNode));
    pH = Head;
    
    int sum;
    p = ha->next;
    q = hb->next;
    pre = ha;
    while (p != NULL && q != NULL)
    {
        if (p->exp < q->exp)			
        {
            p = p->next;
            qH = (PolyNode *)malloc(sizeof(PolyNode));
            qH->coef = p->coef;
            qH->exp = p->exp;
            pH->next = qH;
            pH = qH;
        }
        else if (p->exp == q->exp)
        {
            sum = p->coef + q->coef;
            if (sum != 0)
            {
            	qH = (PolyNode *)malloc(sizeof(PolyNode));
            	qH->coef = sum;
            	qH->exp = p->exp;
				pH->next = qH;
            	pH = qH; 
				
                p = p->next;
                q = q->next;
            }
            else // 如果系数和为零，(则删除结点 p 与 q )不加入结果Head就行，并将指针指向下一个结点
            {
               p = p->next;
                q = q->next;
            }
        }
        else
        {
            q = q->next;
        }
    }
    if (p != NULL) // 将多项式 A 中剩余的结点加入到和多项式中
    	pH->next = p;
    else
        pH->next = q;
    return Head;
}
PolyNode *subduction(PolyNode *ha, PolyNode *hb) // 一元多项式相减函数，用于将两个多项式相减，然后将差多项式存放在多项式 ha 中，并将多项式 hb 删除
{
    PolyNode *p, *q, *pre, *temp,*Head,*pH,*qH;
    Head = (PolyNode *)malloc(sizeof(PolyNode));
    pH = Head;
    
    int sum;
    p = ha->next;
    q = hb->next;
    pre = ha;
    while (p != NULL && q != NULL)
    {
        if (p->exp < q->exp)			
        {
            p = p->next;
            qH = (PolyNode *)malloc(sizeof(PolyNode));
            qH->coef = p->coef;
            qH->exp = p->exp;
            pH->next = qH;
            pH = qH;
        }
        else if (p->exp == q->exp)
        {
            sum = p->coef - q->coef;
            if (sum != 0)
            {
            	qH = (PolyNode *)malloc(sizeof(PolyNode));
            	qH->coef = sum;
            	qH->exp = p->exp;
				pH->next = qH;
            	pH = qH; 
				
                p = p->next;
                q = q->next;
            }
            else // 如果系数和为零，(则删除结点 p 与 q )不加入结果Head就行，并将指针指向下一个结点
            {
               p = p->next;
                q = q->next;
            }
        }
        else
        {
            q = q->next;
        }
    }
    if (p != NULL) // 将多项式 A 中剩余的结点加入到和多项式中
    	pH->next = p;
    else
        pH->next = q;
    return Head;
}
int menu_create()
{
    int a;
    printf(" 输入 1 查看两多项式相加结果 \n 输入 2 查看两多项式相减结果 \n 输入 3 查看两多项式相乘结果 \n");
    scanf("%d", &a);
    if (a != 1 && a != 2 && a != 3)
        printf(" 输入有误 ");
    return a;
}
int main()
{
    PolyNode *h1, *h2, *h;
    h1 = Creatpoly();
    printf(" 该多项式为 P1(x)=");
    UnitePoly(h1);
    Insortup(h1);
    Prin_poly(h1);
    printf("\n");
    h2 = Creatpoly();
    printf(" 该多项式为 P2(x)=");
    UnitePoly(h2);
    Insortup(h2);
    Prin_poly(h2);
    printf("\n");
    for (;;)
    {
        switch (menu_create())
        {
        case 1:
            printf(" 相加后的多项式 \n");
            {
                h = addition(h1, h2);
                UnitePoly(h);
                printf(" 按 X 的升幂排列 ");
                Insortup(h);
                Prin_poly(h);
                printf("\n");
                printf(" 按 X 的降幂排列 ");
                Insortdown(h);
                Prin_poly(h);
                printf("\n");
               /*
                //可加入你自己的程序验证，发现h1，h2都被改变了 
                Prin_poly(h1);
                printf("\n");
                Prin_poly(h2);
                printf("\n");
                */

            }
            break;
        case 2:
            printf(" 相减后的多项式 \n");
            {
                h = subduction(h1, h2);
                UnitePoly(h);
                printf(" 按 X 的升幂排列 ");
                Insortup(h);
                Prin_poly(h);
                printf("\n");
                printf(" 按 X 的降幂排列 ");
                Insortdown(h);
                Prin_poly(h);
                printf("\n");
                
				/*
                //可加入你自己的程序验证，发现h1，h2都被改变了 
                Prin_poly(h1);
                printf("\n");
                Prin_poly(h2);
                printf("\n");
                */
            }
            break;
        case 3:
            printf(" 相乘后的多项式为 \n");
            {
                h = polymuti(h1, h2);
                UnitePoly(h);
                printf(" 按 X 的升幂排列 ");
                Insortup(h);
                Prin_poly(h);
                printf("\n");
                printf(" 按 X 的降幂排列 ");
                Insortdown(h);
                Prin_poly(h);
                printf("\n");
                /*
                //可加入你自己的程序验证，发现h1，h2都被改变了 
                Prin_poly(h1);
                printf("\n");
                Prin_poly(h2);
                printf("\n");
                */
            }
            break;
        }
    }
    return 0;
}

程序的问题是，在进行加减运算时，链表h1，h2的内容被改变，如果一直运行乘法3，没有任何问题。但只要进行了加减运算，就会出现错误，你可以试一下，在进行加减运算后输出两个链表，发现改变了，进行乘法运算后，链表h1，h2不会发生改变。更明显的地方是，加减函数，你直接返回ha，将ha作为结果返回，这不就说明，你改变了链表h1的内容？所以这里需要另外一条链表，来作为返回结果。

链表当时没学好，加减函数你自己可以再改一改

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct Node
{
    int coef; // 系数
    int exp;  // 指数
    struct Node *next;
} PolyNode;
PolyNode *Creatpoly() // 创建多项式的单链表
{
    PolyNode *h, *p, *q;
    h = (PolyNode *)malloc(sizeof(PolyNode));
    p = h;
    p->next = NULL;
    printf(" 请输入多项式的系数及其指数 a b ，当系数输入 0 时停止输入 \n");
    q = (PolyNode *)malloc(sizeof(PolyNode));
    scanf("%d %d", &q->coef, &q->exp);
    while (q->coef != 0)
    {
        p->next = q;
        p = q;
        q = (PolyNode *)malloc(sizeof(PolyNode));
        scanf("%d %d", &q->coef, &q->exp);
    }
    p->next = NULL;
    return (h);
}
void Prin_poly(PolyNode *h) // 将多项式输出函数
{
    PolyNode *p;
    p = h->next;
    while (p != NULL)
    {
        if (p->coef > 0 && p != h->next)
        {
            if (p->exp > 0)
                printf("+%dx^%d", p->coef, p->exp);
            else if (p->exp < 0)
                printf("+%dx^(%d)", p->coef, p->exp);
            else
                printf("+%d", p->coef);
        }
        else if (p->coef < 0 && p != h->next)
        {
            if (p->exp > 0)
                printf("%dx^%d", p->coef, p->exp);
            else if (p->exp < 0)
                printf("%dx^(%d)", p->coef, p->exp);
            else
                printf("%d", p->coef);
        }
        else
        {
            if (p->exp > 0)
                printf("%dx^%d", p->coef, p->exp);
            else if (p->exp < 0)
                printf("%dx^(%d)", p->coef, p->exp);
            else
                printf("%d", p->coef);
        }
        p = p->next;
    }
}
void Insortup(PolyNode *h) // 排序函数，使多项式中的各项按 X 的升幂排列
{
    PolyNode *s, *p;
    int t, m;
    for (p = h->next; p != NULL; p = p->next) // 类似于冒泡排序
    {
        for (s = h->next; s->next != NULL; s = s->next)
        {
            if (s->exp > s->next->exp)
            {
                t = s->exp;
                m = s->coef;
                s->coef = s->next->coef;
                s->exp = s->next->exp;
                s->next->coef = m;
                s->next->exp = t;
            }
        }
    }
}
void Insortdown(PolyNode *h) // 排序函数，使多项式中的各项按 X 的降幂排列
{
    PolyNode *s, *p;
    int t, m;
    for (p = h->next; p != NULL; p = p->next) // 类似于冒泡排序
    {
        for (s = h->next; s->next != NULL; s = s->next)
        {
            if (s->exp < s->next->exp)
            {
                t = s->exp;
                m = s->coef;
                s->coef = s->next->coef;
                s->exp = s->next->exp;
                s->next->coef = m;
                s->next->exp = t;
            }
        }
    }
}
void UnitePoly(PolyNode *h) // 合并同类项
{
    PolyNode *p1, *p2, *q1, *q2, *temp;
    q1 = h;
    p1 = q1->next;
    while (p1 != NULL)
    {
        p2 = p1->next;
        q2 = p1;
        while (p2 != NULL)
        {
            if (p1->exp == p2->exp)
            {
                p1->coef = p1->coef + p2->coef;
                if (p1->coef == 0)
                {
                    temp = p2;
                    q2->next = p2->next;
                    free(temp);
                    temp = p1;
                    q1->next = p1->next;
                    p1 = q1;
                    free(temp);
                    break;
                }
                else
                {
                    temp = p2;
                    q2->next = p2->next;
                    p2 = p2->next;
                    free(temp);
                }
            }
            else
            {
                q2 = p2;
                p2 = p2->next;
            }
        }
        q1 = p1;
        p1 = p1->next;
    }
}
PolyNode *polymuti(PolyNode *h1, PolyNode *h2) // 多项式相乘
{
    PolyNode *h, *p, *p1, *p2, *q;
    p1 = h1->next;
    h = p = (PolyNode *)malloc(sizeof(PolyNode));
    p->next = NULL;
    while (p1)
    {
        p2 = h2->next;
        while (p2)
        {
            q = (PolyNode *)malloc(sizeof(PolyNode));
            q->coef = p1->coef * p2->coef;
            q->exp = p1->exp + p2->exp;
            p->next = q;
            p = q;
            p2 = p2->next;
        }
        p1 = p1->next;
    }
    p->next = NULL;
    return (h);
}
PolyNode *addition(PolyNode *ha, PolyNode *hb) // 一元多项式相加函数，用于将两个多项式相加，然后将和多项式存放在多项式 ha 中，并将多项式 hb 删除
{
    PolyNode *p, *q, *pre, *temp,*Head,*pH,*qH;
    Head = (PolyNode *)malloc(sizeof(PolyNode));
    pH = Head;
    
    int sum;
    p = ha->next;
    q = hb->next;
    pre = ha;
    while (p != NULL && q != NULL)
    {
        if (p->exp < q->exp)			
        {
            p = p->next;
            qH = (PolyNode *)malloc(sizeof(PolyNode));
            qH->coef = p->coef;
            qH->exp = p->exp;
            pH->next = qH;
            pH = qH;
        }
        else if (p->exp == q->exp)
        {
            sum = p->coef + q->coef;
            if (sum != 0)
            {
            	qH = (PolyNode *)malloc(sizeof(PolyNode));
            	qH->coef = sum;
            	qH->exp = p->exp;
				pH->next = qH;
            	pH = qH; 
				
                p = p->next;
                q = q->next;
            }
            else // 如果系数和为零，(则删除结点 p 与 q )不加入结果Head就行，并将指针指向下一个结点
            {
               p = p->next;
                q = q->next;
            }
        }
        else
        {
            q = q->next;
        }
    }
    if (p != NULL) // 将多项式 A 中剩余的结点加入到和多项式中
    	pH->next = p;
    else
        pH->next = q;
    return Head;
}
PolyNode *subduction(PolyNode *ha, PolyNode *hb) // 一元多项式相减函数，用于将两个多项式相减，然后将差多项式存放在多项式 ha 中，并将多项式 hb 删除
{
    PolyNode *p, *q, *pre, *temp,*Head,*pH,*qH;
    Head = (PolyNode *)malloc(sizeof(PolyNode));
    pH = Head;
    
    int sum;
    p = ha->next;
    q = hb->next;
    pre = ha;
    while (p != NULL && q != NULL)
    {
        if (p->exp < q->exp)			
        {
            p = p->next;
            qH = (PolyNode *)malloc(sizeof(PolyNode));
            qH->coef = p->coef;
            qH->exp = p->exp;
            pH->next = qH;
            pH = qH;
        }
        else if (p->exp == q->exp)
        {
            sum = p->coef - q->coef;
            if (sum != 0)
            {
            	qH = (PolyNode *)malloc(sizeof(PolyNode));
            	qH->coef = sum;
            	qH->exp = p->exp;
				pH->next = qH;
            	pH = qH; 
				
                p = p->next;
                q = q->next;
            }
            else // 如果系数和为零，(则删除结点 p 与 q )不加入结果Head就行，并将指针指向下一个结点
            {
               p = p->next;
                q = q->next;
            }
        }
        else
        {
            q = q->next;
        }
    }
    if (p != NULL) // 将多项式 A 中剩余的结点加入到和多项式中
    	pH->next = p;
    else
        pH->next = q;
    return Head;
}
int menu_create()
{
    int a;
    printf(" 输入 1 查看两多项式相加结果 \n 输入 2 查看两多项式相减结果 \n 输入 3 查看两多项式相乘结果 \n");
    scanf("%d", &a);
    if (a != 1 && a != 2 && a != 3)
        printf(" 输入有误 ");
    return a;
}
int main()
{
    PolyNode *h1, *h2, *h;
    h1 = Creatpoly();
    printf(" 该多项式为 P1(x)=");
    UnitePoly(h1);
    Insortup(h1);
    Prin_poly(h1);
    printf("\n");
    h2 = Creatpoly();
    printf(" 该多项式为 P2(x)=");
    UnitePoly(h2);
    Insortup(h2);
    Prin_poly(h2);
    printf("\n");
    for (;;)
    {
        switch (menu_create())
        {
        case 1:
            printf(" 相加后的多项式 \n");
            {
                h = addition(h1, h2);
                UnitePoly(h);
                printf(" 按 X 的升幂排列 ");
                Insortup(h);
                Prin_poly(h);
                printf("\n");
                printf(" 按 X 的降幂排列 ");
                Insortdown(h);
                Prin_poly(h);
                printf("\n");
               /*
                //可加入你自己的程序验证，发现h1，h2都被改变了 
                Prin_poly(h1);
                printf("\n");
                Prin_poly(h2);
                printf("\n");
                */

            }
            break;
        case 2:
            printf(" 相减后的多项式 \n");
            {
                h = subduction(h1, h2);
                UnitePoly(h);
                printf(" 按 X 的升幂排列 ");
                Insortup(h);
                Prin_poly(h);
                printf("\n");
                printf(" 按 X 的降幂排列 ");
                Insortdown(h);
                Prin_poly(h);
                printf("\n");
                
				/*
                //可加入你自己的程序验证，发现h1，h2都被改变了 
                Prin_poly(h1);
                printf("\n");
                Prin_poly(h2);
                printf("\n");
                */
            }
            break;
        case 3:
            printf(" 相乘后的多项式为 \n");
            {
                h = polymuti(h1, h2);
                UnitePoly(h);
                printf(" 按 X 的升幂排列 ");
                Insortup(h);
                Prin_poly(h);
                printf("\n");
                printf(" 按 X 的降幂排列 ");
                Insortdown(h);
                Prin_poly(h);
                printf("\n");
                /*
                //可加入你自己的程序验证，发现h1，h2都被改变了 
                Prin_poly(h1);
                printf("\n");
                Prin_poly(h2);
                printf("\n");
                */
            }
            break;
        }
    }
    return 0;
}

程序的问题是，在进行加减运算时，链表h1，h2的内容被改变，如果一直运行乘法3，没有任何问题。但只要进行了加减运算，就会出现错误，你可以试一下，在进行加减运算后输出两个链表，发现改变了，进行乘法运算后，链表h1，h2不会发生改变。更明显的地方是，加减函数，你直接返回ha，将ha作为结果返回，这不就说明，你改变了链表h1的内容？所以这里需要另外一条链表，来作为返回结果。

链表我当时学的也不咋地，加减法函数你可以自己改一下