一元多项式相乘

成绩	10	开启时间	2017年09月27日 星期三 14:00
折扣	0.8	折扣时间	2017年10月20日 星期五 23:55
允许迟交	否	关闭时间	2018年01月8日 星期一 23:55

题目说明：

　　要求采用链表形式，求两个一元多项式的乘积：h3 = h1*h2。函数原型为：void multiplication( NODE * h1, NODE * h2, NODE * h3 )。

输入：

　　输入数据为两行，分别表示两个一元多项式。每个一元多项式以指数递增的顺序输入多项式各项的系数（整数）、指数（整数）。

　　例如：1+2x+x²表示为：<1,0>,<2,1>,<1,2>,

输出：

　　以指数递增的顺序输出乘积： <系数,指数>,<系数,指数>,<系数,指数>,

　　零多项式的输出格式为：<0,0>,

预设代码

前置代码

view plain print ?

1. /* PRESET CODE BEGIN - NEVER TOUCH CODE BELOW */  
2.  
3. #include <stdio.h>  
4. #include <stdlib.h>  
5.   
6. typedef struct node  
7. {   int    coef, exp;  
8.     struct node  *next;  
9. } NODE;  
10.   
11. void multiplication( NODE *, NODE * , NODE * );  
12. void input( NODE * );  
13. void output( NODE * );  
14.   
15. void input( NODE * head )  
16. {   int flag, sign, sum, x;  
17.     char c;  
18.   
19.     NODE * p = head;  
20.   
21.     while ( (c=getchar()) !='\n' )  
22.     {  
23.         if ( c == '<' )  
24.         {    sum = 0;  
25.              sign = 1;  
26.              flag = 1;  
27.         }  
28.         else if ( c =='-' )  
29.              sign = -1;  
30.         else if( c >='0'&& c <='9' )  
31.         {    sum = sum*10 + c - '0';  
32.         }  
33.         else if ( c == ',' )  
34.         {    if ( flag == 1 )  
35.              {    x = sign * sum;  
36.                   sum = 0;  
37.                   flag = 2;  
38.           sign = 1;  
39.              }  
40.         }  
41.         else if ( c == '>' )  
42.         {    p->next = ( NODE * ) malloc( sizeof(NODE) );  
43.              p->next->coef = x;  
44.              p->next->exp  = sign * sum;  
45.              p = p->next;  
46.              p->next = NULL;  
47.              flag = 0;  
48.         }  
49.     }  
50. }  
51.   
52. void output( NODE * head )  
53. {  
54.     while ( head->next != NULL )  
55.     {   head = head->next;  
56.         printf("<%d,%d>,", head->coef, head->exp );  
57.     }  
58.     printf("\n");  
59. }  
60.   
61. int main()  
62. {   NODE * head1, * head2, * head3;  
63.   
64.     head1 = ( NODE * ) malloc( sizeof(NODE) );  
65.     input( head1 );  
66.   
67.     head2 = ( NODE * ) malloc( sizeof(NODE) );  
68.     input( head2 );  
69.   
70.     head3 = ( NODE * ) malloc( sizeof(NODE) );  
71.     head3->next = NULL;  
72.     multiplication( head1, head2, head3 );  
73.   
74.     output( head3 );  
75.   
76.     return 0;  
77. }  
78.   
79. /* PRESET CODE END - NEVER TOUCH CODE ABOVE */  

	测试输入	期待的输出	时间限制	内存限制	额外进程
测试用例 1	以文本方式显示 <1,0>,<2,1>,<1,2>,↵ <1,0>,<1,1>,↵	以文本方式显示 <1,0>,<3,1>,<3,2>,<1,3>,↵	1秒	1024KB	0
测试用例 2	以文本方式显示 <0,0>,↵ <1,20>,<-8,40>,↵	以文本方式显示 <0,0>,↵	1秒	1024KB	0
测试用例 3	以文本方式显示 <1,20>,<-8,40>,↵ <0,0>,↵	以文本方式显示 <0,0>,↵	1秒	1024KB	0
测试用例 4	以文本方式显示 <-1,0>,<1,1>,↵ <1,0>,<1,1>,↵	以文本方式显示 <-1,0>,<1,2>,↵	1秒	1024KB	0
测试用例 5	以文本方式显示 <5,0>,<10,1>,↵ <2,0>,<3,1>,<4,2>,<5,3>,↵	以文本方式显示 <10,0>,<35,1>,<50,2>,<65,3>,<50,4>,↵	1秒	1024KB	0

void multiplication(NODE *head1, NODE *head2, NODE *head3) 
{ 
   NODE*p1 = head3; NODE*p2 = head3; 
  NODE*h1 = head1->next; NODE*h2 = head2->next; 
     
   while (h1) 
 { 
      while (h2) 
     { 
          int coef = h1->coef*h2->coef; 
            if (coef == 0) 
         { 
              h2 = h2->next; 
              continue; 
          } 
          int exp = h1->exp+h2->exp; 
           if (p1->next == NULL) 
           { 
              NODE*tmp = (NODE*)malloc(sizeof(struct node)); 
             tmp->coef = coef; tmp->exp = exp; 
                p1->next = tmp; 
             tmp->next = NULL; 
           } 
          else 
           { 
              while (p2->next&&exp>p2->next->exp) 
                { 
                  p2 = p2->next; 
              } 
              NODE*tmp = p2->next; 
                if (p2->next == NULL) 
               { 
                  NODE*pnew = (NODE*)malloc(sizeof (struct node)); 
                   pnew->coef = coef; 
                  pnew->exp = exp; 
                    p2->next = pnew; 
                    pnew->next = NULL; 
              } 
              else if (tmp->exp == exp) 
               { 
                  tmp->coef += coef; 
                  if (tmp->coef == 0) 
                 { 
                      NODE*mark = tmp->next; 
                      p2->next = mark; 
                        free(tmp); 
                 } 
              } 
              else if (tmp->exp > exp) 
             { 
                  NODE*pnew = (NODE*)malloc(sizeof (struct node)); 
                   pnew->coef = coef; 
                  pnew->exp = exp; 
                    p2->next = pnew; 
                    pnew->next = tmp; 
               } 
 
         } 
          h2 = h2->next; 
          p2 = head3; 
        } 
      h2 = head2->next; 
       h1 = h1->next; 
  } 
  if (head3->next==NULL) 
  { 
      NODE*end = (NODE*)malloc(sizeof(struct node)); 
     end->coef = 0; 
      end->exp = 0; 
       end->next = head3->next; 
     head3->next = end; 
  } 
}