有关一元多项式计算器的程序问题。大家帮忙修改一下哈！谢谢了！

第二个╮夏天

//元素类型、结点类型和指针类型
//#include <iostream>
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <math.h>
typedef int status;
typedef struct NodeType    //结点类型，指针类型
{
float coef;  //系数
int   expn;  //指数
    NodeType *next;
}*LinkType;        
typedef  LinkType  polynomail;  //用带头结点的有序链表表示多项式  
                                    
  
//函数声明
void InitPolyn( polynomail &P);                                  //构造一个多项式
status MakeNode( polynomail &p,float Ncoef,int Nexpn);          //创建一个结点
void CreatPolyn( polynomail &P,int m);                           //输入m项的系数和指数，建立表示一元多项式的有序链表P
void ClearPolyn( polynomail &P);                                 //将单链表清空，并释放原链表的结点空间
void DestroyPolyn( polynomail &P);                               //销毁一元多项式P
void PrintPolyn( polynomail P);                                  //打印输出一元多项式P
int  PolynLength( polynomail P);                                 //返回一元多项式P中的项数
void MergePolynCoef(polynomail &Pn);                             //在序链表中,合并同类项
void SortPolyn(polynomail &Pn);                                   //根据链表的expn指数域，对链表进行降序排序
void DelZeroNode(polynomail &Pn);                                //释放无用结点,即系数为0项
void AddPolyn( polynomail &Pa,polynomail &Pb,polynomail &Pc);      //完成多项式相加运算，即：Pc=Pa+Pb
void SubtractPolyn( polynomail Pa,polynomail Pb,polynomail &Pc); //完成多项式相减运算，即：Pc=Pa-Pb
void MultiplyPolyn( polynomail Pa,polynomail Pb,polynomail &Pc); //完成多项式相乘运算，即：Pc=Pa×Pb
void Difference( polynomail &pa);                                //求多项式的导函数
float Evaluate(polynomail pn, float x );                         //求多项式的值
//算法如下
//构造一个多项式
void InitPolyn( polynomail &P)
{  
P=(NodeType *)malloc(sizeof(NodeType));
    P->coef=0;
P->expn=0;
P->next=NULL; //初始化带头结点的单链表
}
//将单链表清空，并释放原链表的结点空间
void ClearPolyn( polynomail &P)
{
LinkType q;
q=P->next;
    while(q!=NULL) //释放原链表的结点空间
{
  P->next=q->next;
  free(q);
  q=P->next;
}
}
//销毁一元多项式P
void DestroyPolyn(polynomail &P)                           
{
LinkType q=P;
    while(q!=NULL)
{
  q=P->next;
  free(P);   //释放所有结点空间
  q=P;
}                        
} // DestroyPolyn
//根据链表的expn指数域，对链表进行降序排序
void SortPolyn(polynomail &Pn)                                
{
MergePolynCoef(Pn);      //先合并同类项
    LinkType p,q,r;
    q=Pn->next;
Pn->next=NULL;
  while(q!=NULL)         //插入法排序
  {  
   p=Pn;
  while(p->next!=NULL&&p->next->expn>q->expn)
   p=p->next;
  r=q->next;
  q->next=p->next;
  p->next=q;
  q=r;   
  }
}// SortPolyn
//在序链表中,合并同类项
void MergePolynCoef(polynomail &Pn)
{
LinkType p,p1,p2;
    p=Pn->next;
    while(p!=NULL)
{
   p1=p;p2=p->next;
         while(p2!=NULL)    //合并指数相同项
   {
   if(p->expn==p2->expn)
   {
    p->coef+=p2->coef;
    p1->next=p2->next;
    free(p2);  
          p2=p1->next;
   }
         else
   {
    p1=p2;
    p2=p1->next;
   }
   }
     p=p->next;
  }
DelZeroNode(Pn);   //删除合并后系数为0的结点
}
//创建一个结点
status MakeNode( polynomail &p,float Ncoef,int Nexpn)
{  
  if (!(p=(LinkType)malloc(sizeof(NodeType))))
   {
  printf("Error,the momery is overflow");
  return false;
   }
    p->coef=Ncoef;
p->expn=Nexpn;
p->next=NULL;
    return true;
}

//输入m项的系数和指数，建立表示一元多项式的有序链表P
void CreatPolyn( polynomail &P,int m)                  
{
float fcoef;
    int fexpn;
    NodeType *s,*q;
    q=P;
for(int i=1;i<=m;i++)    //if(m==0) 为"空表!";
   {
  printf("第i项式:");
     printf("系数，指数:");
  scanf("%d,%d",&fcoef,&fexpn);
     s=(NodeType *)malloc(sizeof(NodeType));
  s->coef=fcoef;
  s->expn=fexpn;
  s->next=NULL;
  q->next=s;
  q=s;
  q->next=NULL;
   }
MergePolynCoef(P);    //合并指数相同项
DelZeroNode(P);       //删除系数为0的结点
SortPolyn(P);        //按指数域，对链表进行升序排序
}
/*
// 稀疏多项式pa以链表作存储结构,将此链表修改成它的导函数,并释放无用结点
void Difference(polynomail &pa)                                                              
{  
LinkType p,q;
p=pa->next;
q=pa;
   while(p!=NULL)
   {
    if(p->expn==0)
    {
       q->next=p->next;
       free(p);
       p=q->next;
    }   //常数项，导数为零，释放结点
       else
    {
     p->coef=p->coef*p->expn; //系数=原系数* 指数
           (p->expn )--;            //指数减1
     q=q->next;
     p=p->next;     
    }
   }  
}
                                                          */

//释放无用结点,即系数为0项
void DelZeroNode(polynomail &Pn)                              
{
LinkType p,q;
p=Pn->next;
q=Pn;
while(p!=NULL)
{
  if(p->expn==0)
  {
   q->next=p->next;
   free(p);
   p=q->next;
  }   
}
}
//求多项式的值
float Evaluate(polynomail pn, float x)                        
{

LinkType p;
p=pn->next;  
    float result=0;
    while(p!=NULL)
{
  result+=(p->coef)*(float)pow(x,p->expn);  //pow函数求x的n次方
        p=p->next;
}
    return result;
}
//完成多项式相加运算，即：Pc=Pa+Pb
void AddPolyn(polynomail &Pa,polynomail &Pb,polynomail &Pc)   
{  
float x;
int m;
    //LinkType p,q,r;
NodeType *p,*q,*r;
    NodeType *s;
CreatPolyn(Pa,1);
    p=Pb->next;
    q=Pa->next;
    r=Pc;
  while(p!=NULL&&q!=NULL)
  {
   if(p->expn==q->expn) //指数相同
   {
    x=p->coef+q->coef ;
       if(x!=0)         //指数相同，若系数相加不等于0,插入表中
    {
     s=(NodeType *)malloc(sizeof(NodeType));
        s->coef=x;
     s->expn=q->expn;
     s->next=NULL;
              r->next=s;
     r=r->next;
    }
      p=p->next;
      q=q->next;
   }
   else if(q->expn<p->expn)  //指数小的插入表中
   {
  s=(NodeType *)malloc(sizeof(NodeType));
  s->coef=q->coef;
  s->expn=q->expn;
  s->next=NULL;
        r->next=s;r=r->next;
     q=q->next;
   }
     else
  {
    s=(NodeType *)malloc(sizeof(NodeType));
    s->coef=p->coef;
    s->expn=p->expn;
    s->next=NULL;
          r->next=s;
    r=r->next;
    p=p->next;
  }
  }
//加入余下的多项式
while(p!=NULL)
  {
  s=(NodeType *)malloc(sizeof(NodeType));
     s->coef=p->coef;
  s->expn=p->expn;
  s->next=NULL;
     r->next=s;
  r=r->next;
  p=p->next;
  }
while(q!=NULL)
{
  s=(NodeType *)malloc(sizeof(NodeType));
     s->coef=q->coef;
  s->expn=q->expn;
  s->next=NULL;
     r->next=s;
  r=r->next;
  q=q->next;
}
}// AddPoly
//完成多项式相减运算，即：Pc=Pa-Pb   
void SubtractPolyn( polynomail Pa,polynomail Pb,polynomail &Pc)      
{
float x;
    LinkType p,q,r;
    NodeType *s;
    p=Pa->next;
    q=Pb->next;
    r=Pc;
while(p!=NULL&&q!=NULL)
  {  
  if(p->expn==q->expn)    //指数相同
  {
   x=p->coef-q->coef;
      if(x!=0)       //指数相同，若系数相减不等于0,插入表中
   {
    s=(NodeType *)malloc(sizeof(NodeType));
       s->coef=x;
    s->expn=q->expn;
    s->next=NULL;
             r->next=s;
    r=r->next;
   }
     p=p->next;
  q=q->next;
  }
  else if(q->expn<p->expn)   //指数小的插入表中
  {   
   s=(NodeType *)malloc(sizeof(NodeType));
   s->coef=-q->coef;    //减数的系数变为相反数
   s->expn=q->expn;
   s->next=NULL;
         r->next=s;
   r=r->next;
   q=q->next;
  }
     else  
  {  
   s=(NodeType *)malloc(sizeof(NodeType));
   s->coef=p->coef;
   s->expn=p->expn;
   s->next=NULL;
         r->next=s;
   r=r->next;
   p=p->next;
  }
}
//加入余下的多项式，减数的系数变为相反数
  while(p!=NULL)
  {
   s=(NodeType *)malloc(sizeof(NodeType));
   s->coef=p->coef;
   s->expn=p->expn;
   s->next=NULL;
      r->next=s;
   r=r->next;
   p=p->next;
  }
   while(q!=NULL)
   {
    s=(NodeType *)malloc(sizeof(NodeType));
       s->coef=-q->coef;
    s->expn=q->expn;
    s->next=NULL;
       r->next=s;
    r=r->next;
    q=q->next;
   }
}// SubtractPolyn
//完成多项式相乘运算，即：Pc=Pa×Pb
void MultiplyPolyn( polynomail Pa,polynomail Pb,polynomail &Pc)  
{  

LinkType p,q,r;
    NodeType *s;
p=Pa->next;
r=Pc;
while(p!=NULL)
{
  q=Pb->next;
        while(q!=NULL)
  {
   s=(NodeType *)malloc(sizeof(NodeType));
         s->coef=p->coef*q->coef;
         s->expn=p->expn+q->expn;
            s->next=NULL;      
            r->next=s;
         r=r->next;
         q=q->next;
  }
    p=p->next;
   }
MergePolynCoef(Pc);  //合并指数相同项
DelZeroNode(Pc);     //删除系数为0的结点
SortPolyn(Pc);      //按指数域，对链表进行升序排序
}// MultiplyPolyn
//主函数
void main()
{
    polynomail Pa,Pb,Pc;
float x;
printf("        **********************************************************\n");
printf("        ****************欢迎使用一元多项式计算器******************\n");
printf("        **********************************************************\n");
    loop:while(1)
{   
      
       int choice;
    printf("        **********************************************************\n");
    printf("        *******************   1.多项式加法       *****************\n");
    printf("        *******************   2.多项式减法       *****************\n");
    printf("        *******************   3.多项式乘法       *****************\n");
    printf("        *******************   4.求多项式A的导数  *****************\n");
    printf("        *******************   5.求多项式A的值    *****************\n");
    printf("        *******************   6.谢谢使用!再见!   *****************\n");
    printf("        **********************************************************\n");
    printf("测试数据: A1=x+x^2+x^3                        B1=1+x+x^2 \n");
    printf("          A2=9+x+x^4+2x^6                     B2=6x^(-3)-x+4.4x^2-1.2x^9 \n");
    printf("          A3=-6x^(-3)+5.4x^2-x^2+7.8x^10      B3=7-5x^8+11x^9 \n\n");
       printf("请输入操作(1-6):\n");
       scanf("%d",&choice);
    printf("\n");
       switch(choice)
    {  
          case 1:
     {
           printf("多项式加法C=A+B\n");  
           AddPolyn(Pa,Pb,Pc);  
     }
     /*  case 2:
           printf("多项式减法C=A-B:\n");
        SubtractPolyn(Pa,Pb,Pc);   
       case 3:
           printf("多项式乘法C=A*B:\n");
        MultiplyPolyn(Pa,Pb,Pc);   
       case 4:
        printf("求多项式A的导数:\n");
        Difference(Pa);                 
    case 5:
              printf("求多项式A的值:\n");
                 Evaluate(Pa, x);                */
       case 6:
           printf("谢谢使用!再见!\n");
           return ;
          default:
           printf("错误命令!\n");  
          getchar();
       goto loop;  
    }
};
}

故乡的风

修改的你的代码，有些你的可能是对的，但是我开始没搞清楚，就改了。整体来说的，你的算法没问题，可能有些小问题，我大体改过来了。而且，我也测试了一组数据，没有问题。你自己测测看看。

1. //元素类型、结点类型和指针类型
   
2. //#include <iostream>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <malloc.h>
   
6. #include <string.h>
   
7. #include <MATH.H>
   
8. 
   
9. typedef int status;
   
10. typedef struct NodeType    //结点类型，指针类型
    
11. {
    
12.         float coef;  //系数
    
13.         int   expn;  //指数
    
14.     NodeType *next;
    
15. }*LinkType;
    
16. typedef  LinkType  Polynomial;  //用带头结点的有序链表表示多项式
    
17. 
    
18. //函数声明
    
19. void InitPolyn( Polynomial &P);                                  //构造一个多项式
    
20. status MakeNode( Polynomial &p,float Ncoef,int Nexpn);           //创建一个结点
    
21. void CreatPolyn( Polynomial &P,int m);                           //输入m项的系数和指数，建立表示一元多项式的有序链表P
    
22. void ClearPolyn( Polynomial &P);                                 //将单链表清空，并释放原链表的结点空间
    
23. void DestroyPolyn( Polynomial &P);                               //销毁一元多项式P
    
24. void PrintPolyn( Polynomial P);                                  //打印输出一元多项式P
    
25. int  PolynLength( Polynomial P);                                 //返回一元多项式P中的项数
    
26. void MergePolynCoef(Polynomial &Pn);                             //在序链表中,合并同类项
    
27. void SortPolyn(Polynomial &Pn);                                  //根据链表的expn指数域，对链表进行降序排序
    
28. void DelZeroNode(Polynomial &Pn);                                //释放无用结点,即系数为0项
    
29. void AddPolyn( Polynomial Pa,Polynomial Pb,Polynomial &Pc);      //完成多项式相加运算，即：Pc=Pa+Pb
    
30. void SubtractPolyn( Polynomial Pa,Polynomial Pb,Polynomial &Pc); //完成多项式相减运算，即：Pc=Pa-Pb
    
31. void MultiplyPolyn( Polynomial Pa,Polynomial Pb,Polynomial &Pc); //完成多项式相乘运算，即：Pc=Pa×Pb
    
32. void Difference(Polynomial Pa, Polynomial &Pb);                  //求多项式的导函数
    
33. float Evaluate(Polynomial pn, float x );                         //求多项式的值
    
34. 
    
35. //算法如下
    
36. 
    
37. //构造一个多项式
    
38. void InitPolyn( Polynomial &P)
    
39. {
    
40.         P=(NodeType *)malloc(sizeof(NodeType));
    
41.     P->coef=0;
    
42.         P->expn=0;
    
43.         P->next=NULL; //初始化带头结点的单链表
    
44. }
    
45. 
    
46. //将单链表清空，并释放原链表的结点空间
    
47. void ClearPolyn( Polynomial &P)
    
48. {
    
49.         LinkType p1, p2;
    
50.         p1 = P;
    
51.         p2 = p1->next;
    
52.     while(p2!=NULL) //释放原链表的结点空间
    
53.         {
    
54.                 p1->next=p2->next;
    
55.                 free(p2);
    
56.                 p2=p1->next;
    
57.         }
    
58. }
    
59. 
    
60. //销毁一元多项式P
    
61. void DestroyPolyn(Polynomial &P)
    
62. {
    
63.         LinkType q=P;
    
64.     while(q!=NULL)
    
65.         {
    
66.                 q=P->next;
    
67.                 free(P);   //释放所有结点空间
    
68.                 q=P;
    
69.         }
    
70. } // DestroyPolyn
    
71. 
    
72. //根据链表的expn指数域，对链表进行降序排序
    
73. void SortPolyn(Polynomial &Pn)
    
74. {
    
75.         MergePolynCoef(Pn);      //先合并同类项
    
76.     LinkType p,q,r;
    
77.     q=Pn->next;
    
78.         Pn->next=NULL;
    
79.   while(q!=NULL)         //插入法排序
    
80.   {
    
81.           p=Pn;
    
82.          while(p->next!=NULL&&p->next->expn > q->expn)
    
83.                  p=p->next;
    
84.          r=q->next;
    
85.          q->next=p->next;
    
86.          p->next=q;
    
87.          q=r;
    
88.   }
    
89. }// SortPolyn
    
90. 
    
91. //在序链表中,合并同类项
    
92. void MergePolynCoef(Polynomial &Pn)
    
93. {
    
94.         LinkType p,p1,p2;
    
95.     p=Pn->next;
    
96.     while(p!=NULL)
    
97.         {
    
98.                  p1=p;p2=p->next;
    
99.          while(p2!=NULL)    //合并指数相同项
    
100.                  {
     
101.                         if(p->expn==p2->expn)
     
102.                         {
     
103.                                 p->coef+=p2->coef;
     
104.                                 p1->next=p2->next;
     
105.                                 free(p2);
     
106.                         p2=p1->next;
     
107.                         }
     
108.                 else
     
109.                         {
     
110.                                 p1=p2;
     
111.                                 p2=p1->next;
     
112.                         }
     
113.                  }
     
114.             p=p->next;
     
115.   }
     
116. DelZeroNode(Pn);   //删除合并后系数为0的结点
     
117. }
     
118. 
     
119. //创建一个结点
     
120. status MakeNode( Polynomial &p,float Ncoef,int Nexpn)
     
121. {
     
122.   if (!(p=(LinkType)malloc(sizeof(NodeType))))
     
123.    {
     
124.                 printf("Error,the momery is overflow");
     
125.                 return false;
     
126.    }
     
127.     p->coef=Ncoef;
     
128.         p->expn=Nexpn;
     
129.         p->next=NULL;
     
130.     return true;
     
131. }
     
132. 
     
133. 
     
134. //输入m项的系数和指数，建立表示一元多项式的有序链表P
     
135. void CreatPolyn(Polynomial &P,int m)
     
136. {
     
137.         float fcoef;
     
138.     int fexpn;
     
139.     NodeType *s,*q;
     
140.     q=P;
     
141.     printf("项数:%d\n", m);
     
142. for(int i=1;i<=m;i++)    //if(m==0) 为"空表!";
     
143.    {
     
144.          printf("第%d项式:", i);
     
145.      printf("系数，指数:");
     
146.          scanf("%f %d",&fcoef, &fexpn);
     
147.      s=(NodeType *)malloc(sizeof(NodeType));
     
148.          s->coef=fcoef;
     
149.          s->expn=fexpn;
     
150.          s->next=NULL;
     
151.          q->next=s;
     
152.          q=s;
     
153.    }
     
154. 
     
155. MergePolynCoef(P);    //合并指数相同项
     
156. // DelZeroNode(P);       //删除系数为0的结点
     
157. SortPolyn(P);        //按指数域，对链表进行升序排序
     
158. }
     
159. 
     
160. // 稀疏多项式pa以链表作存储结构,将此链表修改成它的导函数,并释放无用结点
     
161. void Difference(Polynomial Pa, Polynomial &Pb)
     
162. {
     
163.         LinkType p,q;
     
164.         NodeType *s;
     
165.         p=Pa->next;
     
166.         q=Pb;
     
167.    while(p!=NULL)
     
168.    {
     
169.            if(p->expn==0)
     
170.            {
     
171.               p=p->next;
     
172.            }   //常数项，导数为零，释放结点
     
173.        else
     
174.            {
     
175.                    s = (NodeType *)malloc(sizeof(NodeType));
     
176.                    s->coef = p->coef * p->expn;
     
177.                    s->expn = p->expn - 1;
     
178.                    s->next = NULL;
     
179. 
     
180.                    p = p->next;
     
181.                    q->next = s;
     
182.                    q = q->next;
     
183.            }
     
184.    }
     
185. }
     
186. 
     
187. //释放无用结点,即系数为0项
     
188. void DelZeroNode(Polynomial &Pn)
     
189. {
     
190.         LinkType p,q;
     
191.         q=Pn;
     
192.         p = q->next;
     
193.         while(p!=NULL)
     
194.         {
     
195.                 if(p->coef==0)
     
196.                 {
     
197.                         q->next=p->next;
     
198.                         free(p);
     
199.                         p=q->next;
     
200.                 }
     
201.                 q = p;
     
202.                 p = q->next;
     
203.         }
     
204. }
     
205. 
     
206. //求多项式的值
     
207. float Evaluate(Polynomial pn, float x)
     
208. {
     
209. 
     
210.         LinkType p;
     
211.         p=pn->next;
     
212.     float result=0;
     
213.     while(p!=NULL)
     
214.         {
     
215.                 result+=(p->coef)*(float)pow(x,p->expn);  //pow函数求x的n次方
     
216.         p=p->next;
     
217.         }
     
218.     return result;
     
219. }
     
220. 
     
221. //完成多项式相加运算，即：Pc=Pa+Pb
     
222. void AddPolyn(Polynomial Pa,Polynomial Pb,Polynomial &Pc)
     
223. {
     
224.         float x;
     
225.     //LinkType p,q,r;
     
226.         NodeType *p,*q,*r;
     
227.     NodeType *s;
     
228.     p=Pa->next;
     
229.     q=Pb->next;
     
230.     r=Pc;
     
231.   while(p!=NULL&&q!=NULL)
     
232.   {
     
233.           if(p->expn==q->expn) //指数相同
     
234.           {
     
235.                   x=p->coef+q->coef ;
     
236.               if(x!=0)         //指数相同，若系数相加不等于0,插入表中
     
237.                   {
     
238.                           s=(NodeType *)malloc(sizeof(NodeType));
     
239.                       s->coef=x;
     
240.                           s->expn=q->expn;
     
241.                           s->next=NULL;
     
242.               r->next=s;
     
243.                           r=r->next;
     
244.                   }
     
245.              p=p->next;
     
246.              q=q->next;
     
247.           }
     
248.           else if(q->expn > p->expn)  //指数大的插入表中
     
249.           {
     
250.                 s=(NodeType *)malloc(sizeof(NodeType));
     
251.                 s->coef=q->coef;
     
252.                 s->expn=q->expn;
     
253.                 s->next=NULL;
     
254.         r->next=s;r=r->next;
     
255.             q=q->next;
     
256.           }
     
257.      else
     
258.          {
     
259.                   s=(NodeType *)malloc(sizeof(NodeType));
     
260.                   s->coef=p->coef;
     
261.                   s->expn=p->expn;
     
262.                   s->next=NULL;
     
263.           r->next=s;
     
264.                   r=r->next;
     
265.                   p=p->next;
     
266.          }
     
267.   }
     
268. //加入余下的多项式
     
269. while(p!=NULL)
     
270.   {
     
271.          s=(NodeType *)malloc(sizeof(NodeType));
     
272.             s->coef=p->coef;
     
273.          s->expn=p->expn;
     
274.          s->next=NULL;
     
275.      r->next=s;
     
276.          r=r->next;
     
277.          p=p->next;
     
278.   }
     
279. while(q!=NULL)
     
280. {
     
281.          s=(NodeType *)malloc(sizeof(NodeType));
     
282.      s->coef=q->coef;
     
283.          s->expn=q->expn;
     
284.          s->next=NULL;
     
285.      r->next=s;
     
286.          r=r->next;
     
287.          q=q->next;
     
288. }
     
289. }// AddPoly
     
290. 
     
291. //完成多项式相减运算，即：Pc=Pa-Pb
     
292. void SubtractPolyn( Polynomial Pa,Polynomial Pb,Polynomial &Pc)
     
293. {
     
294.         float x;
     
295.     LinkType p,q,r;
     
296.     NodeType *s;
     
297.     p=Pa->next;
     
298.     q=Pb->next;
     
299.     r=Pc;
     
300. while(p!=NULL&&q!=NULL)
     
301.   {
     
302.          if(p->expn==q->expn)    //指数相同
     
303.          {
     
304.                  x=p->coef-q->coef;
     
305.              if(x!=0)       //指数相同，若系数相减不等于0,插入表中
     
306.                  {
     
307.                          s=(NodeType *)malloc(sizeof(NodeType));
     
308.                      s->coef=x;
     
309.                          s->expn=q->expn;
     
310.                          s->next=NULL;
     
311.              r->next=s;
     
312.                          r=r->next;
     
313.                  }
     
314.             p=p->next;
     
315.                 q=q->next;
     
316.          }
     
317.          else if(q->expn > p->expn)   //指数大的插入表中
     
318.          {
     
319.                  s=(NodeType *)malloc(sizeof(NodeType));
     
320.                  s->coef=-q->coef;    //减数的系数变为相反数
     
321.                  s->expn=q->expn;
     
322.                  s->next=NULL;
     
323.          r->next=s;
     
324.                  r=r->next;
     
325.                  q=q->next;
     
326.          }
     
327.      else
     
328.          {
     
329.                  s=(NodeType *)malloc(sizeof(NodeType));
     
330.                  s->coef=p->coef;
     
331.                  s->expn=p->expn;
     
332.                  s->next=NULL;
     
333.          r->next=s;
     
334.                  r=r->next;
     
335.                  p=p->next;
     
336.          }
     
337. }
     
338. //加入余下的多项式，减数的系数变为相反数
     
339.   while(p!=NULL)
     
340.   {
     
341.           s=(NodeType *)malloc(sizeof(NodeType));
     
342.           s->coef=p->coef;
     
343.           s->expn=p->expn;
     
344.           s->next=NULL;
     
345.       r->next=s;
     
346.           r=r->next;
     
347.           p=p->next;
     
348.   }
     
349.    while(q!=NULL)
     
350.    {
     
351.            s=(NodeType *)malloc(sizeof(NodeType));
     
352.        s->coef=-q->coef;
     
353.            s->expn=q->expn;
     
354.            s->next=NULL;
     
355.        r->next=s;
     
356.            r=r->next;
     
357.            q=q->next;
     
358.    }
     
359. }// SubtractPolyn
     
360. 
     
361. //完成多项式相乘运算，即：Pc=Pa×Pb
     
362. void MultiplyPolyn( Polynomial Pa,Polynomial Pb,Polynomial &Pc)
     
363. {
     
364. 
     
365.         LinkType p,q,r;
     
366.     NodeType *s;
     
367.         p=Pa->next;
     
368.         r=Pc;
     
369.         while(p!=NULL)
     
370.         {
     
371.                 q=Pb->next;
     
372.         while(q!=NULL)
     
373.                 {
     
374.                         s=(NodeType *)malloc(sizeof(NodeType));
     
375.                 s->coef=p->coef*q->coef;
     
376.                 s->expn=p->expn+q->expn;
     
377.             s->next=NULL;
     
378.             r->next=s;
     
379.                 r=r->next;
     
380.                 q=q->next;
     
381.                 }
     
382.            p=p->next;
     
383.    }
     
384.    MergePolynCoef(Pc);  //合并指数相同项
     
385.    DelZeroNode(Pc);     //删除系数为0的结点
     
386.    SortPolyn(Pc);      //按指数域，对链表进行降序排序
     
387. }// MultiplyPolyn
     
388. 
     
389. void PrintPolyn(Polynomial P) {
     
390.     Polynomial pCur;
     
391.     pCur = P->next;
     
392.     while (pCur) {
     
393.         printf("%.0fX^%d  ", pCur->coef, pCur->expn);
     
394.         pCur = pCur->next;
     
395.     }
     
396.     printf("\n");
     
397. }
     
398. 
     
399. 
     
400. //主函数
     
401. int main()
     
402. {
     
403.     Polynomial Pa,Pb,Pc;
     
404.         float x = 2;
     
405. 
     
406.         InitPolyn(Pa);
     
407.         CreatPolyn(Pa, 3);
     
408.         PrintPolyn(Pa);
     
409.         InitPolyn(Pb);
     
410.         CreatPolyn(Pb, 2);
     
411.         PrintPolyn(Pb);
     
412.         InitPolyn(Pc);
     
413. 
     
414.         printf("        ****************欢迎使用一元多项式计算器******************\n");
     
415.         printf("        **********************************************************\n");
     
416.     while(1)
     
417.         {
     
418. 
     
419.        int choice;
     
420.            printf("        **********************************************************\n");
     
421.            printf("        *******************   1.多项式加法       *****************\n");
     
422.            printf("        *******************   2.多项式减法       *****************\n");
     
423.            printf("        *******************   3.多项式乘法       *****************\n");
     
424.            printf("        *******************   4.求多项式A的导数  *****************\n");
     
425.            printf("        *******************   5.求多项式A的值    *****************\n");
     
426.            printf("        *******************   6.谢谢使用!再见!   *****************\n");
     
427.            printf("        **********************************************************\n");
     
428.            printf("测试数据: A1=x+x^2+x^3                        B1=1+x+x^2 \n");
     
429.            printf("          A2=9+x+x^4+2x^6                     B2=6x^(-3)-x+4.4x^2-1.2x^9 \n");
     
430.            printf("          A3=-6x^(-3)+5.4x^2-x^2+7.8x^10      B3=7-5x^8+11x^9 \n\n");
     
431.        printf("请输入操作(1-6):\n");
     
432.        scanf("%d",&choice);
     
433.            printf("\n");
     
434.            getchar();
     
435. 
     
436.        switch(choice)
     
437.            {
     
438.           case 1:
     
439.                           {
     
440.                          printf("多项式加法C=A+B\n");
     
441.                          AddPolyn(Pa,Pb,Pc);
     
442.                          PrintPolyn(Pc);
     
443.                          ClearPolyn(Pc);
     
444.                           }
     
445.                           break;
     
446. 
     
447.               case 2:
     
448.                   {
     
449.                          printf("多项式减法C=A-B:\n");
     
450.                              SubtractPolyn(Pa,Pb,Pc);
     
451.                              PrintPolyn(Pc);
     
452.                              ClearPolyn(Pc);
     
453.                   }
     
454.                   break;
     
455. 
     
456.               case 3:
     
457.                   {
     
458.                          printf("多项式乘法C=A*B:\n");
     
459.                              MultiplyPolyn(Pa,Pb,Pc);
     
460.                              PrintPolyn(Pc);
     
461.                              ClearPolyn(Pc);
     
462.                   }
     
463.                           break;
     
464. 
     
465.               case 4:
     
466.                   {
     
467.                              printf("求多项式A的导数:\n");
     
468.                              Difference(Pa, Pc);
     
469.                              PrintPolyn(Pc);
     
470.                              ClearPolyn(Pc);
     
471.                   }
     
472.                   break;
     
473. 
     
474.                   case 5:
     
475.                       {
     
476.                      printf("求多项式A的值:\n");
     
477.                      x = 2;
     
478.                  float value = Evaluate(Pa, x);
     
479.                  printf("%f\n", value);
     
480.                       }
     
481.               break;
     
482.               case 6:
     
483.                   {
     
484.                          printf("谢谢使用!再见!\n");
     
485.                          exit(0);
     
486.                   }
     
487.                   break;
     
488. 
     
489.           default:
     
490.               {
     
491.                          printf("错误命令!\n");
     
492.               }
     
493.               break;
     
494.            }
     
495.         };
     
496. 
     
497.         return 0;
     
498. }

复制代码

第二个╮夏天

故乡的风 发表于 2013-6-26 22:05

                               
登录/注册后可看大图

修改的你的代码，有些你的可能是对的，但是我开始没搞清楚，就改了。整体来说的，你的算法没问题，可能有些 ...

嗯嗯。一开始出现的问题都解决了，不会再一执行就报错了。亲，谢谢哈！辛苦了！:handshake

微博评论

转发微博

                               
登录/注册后可看大图

来自 回推 的新浪微博

微博评论

转发微博

                               
登录/注册后可看大图

来自 鞠金桓1999 的新浪微博

微博评论

转发微博

                               
登录/注册后可看大图

来自 回推 的新浪微博

微博评论

转发微博

                               
登录/注册后可看大图

来自 柳荣1 的新浪微博

微博评论

转发微博

                               
登录/注册后可看大图

来自 回推 的新浪微博

微博评论

转发微博

                               
登录/注册后可看大图

来自 傻乎乎宏逸 的新浪微博

微博评论

转发微博

                               
登录/注册后可看大图

来自 傻乎乎宏逸 的新浪微博

微博评论

转发微博

                               
登录/注册后可看大图

来自 出世秀雅 的新浪微博

微博评论

转发微博

                               
登录/注册后可看大图

来自 公寓草间野分 的新浪微博

zjc78361

这么长