题解：一元多项式输入、输出、运算（基于链表)

在pta上做的一道题，虽然不难，但我作为个人觉得比较繁琐，也有一些容易出错的点，在这里总结一下我之前一些写的一些bug，也欢迎有大佬对我的解法提出意见或优化方案，原题如下

https://pintia.cn/problem-sets/1503577965866790912/problems/1503578332519346180

读入2个多项式和一个运算符（加号+,减号-,乘号*），计算多项式运算结果，并按照要求输出运算结果。

输入样例：

x+5x^2
*
-x+5x^2

输出样例：

x + 5x^2
*
-x + 5x^2
=
-x^2 + 25x^4

多项式的定义

由若干个单项式，通过 '+' 或 '-' 连接起来的式子。 例如：-x^2+3-5x^6 + x   +   9  + x

单项式的基本格式为：

系数x^幂指数

例如：

5x^2 表示5倍的 x 平方
3x^-4 表示3倍的 x 的 -4 次方

一个单项式内部【不允许】有空白字符（空格或\t)。例如不允许：2  x^  3 

输入要求

1）当省略系数，则表示系数为 1。例如：x^3
2）当系数省略为减号时，则表示系数为 -1。例如：-x^3
3）当省略幂指数时，则表示幂指数为1。例如：-5x。
4）对于常数项，可以省略x^0，例如：-2 （表示 -2x^0） 

单项输出要求

1）如果幂指数为 0，须简化为常数项。例如：3x^0 应该输出为 3
2）如果幂指数为 1，须省略它。例如：3x^1 应该输出为3x
3）如果系数为1或-1，须省略1。例如：-x^6，x^2
4）单项式内部不能有空白字符（空格或\t)

多项式输出要求

1）在项与项之间的+号、-号左右两侧须各留一个空格 
2）按照幂指数升高的顺序输出，例如：-2 + 3x^5 -x^9 
3）不输出系数为零的项
4）零多项式，输出 0 

按照接口要求，编写以下 7 个函数代码

void       PrintMonomial(int coef, int expo); 
Monomial*  ParseMonomial(char **s);
Polynomial InsertAfterTail(Polynomial head, Monomial* pNewNode);
Polynomial TrimZeroTerms(Polynomial head);
Polynomial SortPolynomial(Polynomial head);
Polynomial Minus(Polynomial p1, Polynomial p2);
Polynomial Multiply(Polynomial p1, Polynomial p2);

函数接口定义：

  ------------------------------------------------------------------------------
  函数 PrintMonomial - 输出单项式
       void PrintMonomial(int coef, int expo);
       1）如果幂指数为 0，则简化为常数项。例如：x^0 应该输出为 1
       2）如果幂指数为 1，则须省略它。例如：-3x^1 应该输出为-3x
       3）如果系数为1或-1，则输出时须省略1。例如：-x^6，x^2
       4）输出时，单项式内部不能有空白字符（空格或\t) 
       5）零单项式不输出 
  参数
      coef - 单项式系数
      expo - 单项式幂指数 
  返回值
     无 
  ------------------------------------------------------------------------------
  函数 ParseMonomial - 读入字符串中的第一个单项式
       Monomial* ParseMonomial(char **s)
    参数 
        s - *s是字符串指针，指定数据读取源  
            函数执行成功后，*s会单项式后面的第一个字符
    返回值
        成功 - 所读入的单项式指针
        失败 - NULL
  ------------------------------------------------------------------------------
  函数 InsertAfterTail - 插入新节点到多项式链表末尾 
       Polynomial InsertAfterTail(Polynomial head, Monomial* pNewNode); 
  参数
      head - 多项式的头节点指针 
      pNewNode - 新插入节点的指针
  返回值
      插入节点后，新多项式的头节点指针
  ------------------------------------------------------------------------------
  函数 DeleteZeroTerms - 删除多项式中的零系数节点 
       Polynomial DeleteZeroTerms(Polynomial head);
  参数
      head - 被简化的多项式的头节点指针
  返回值：简化后的多项式链表的节点指针
  ------------------------------------------------------------------------------
  函数 SortPolynomial - 对多项式按照幂指数进行升序排序
       Polynomial SortPolynomial(Polynomial head); 
  参数
       head - 被排序的多项式的头节点指针
  返回值：排序后的多项式头节点指针 
  ------------------------------------------------------------------------------
  函数 Minus - 多项式求差： p1 - p2 
               链表 p1和p2保持不变 
       Polynomial Minus(Polynomial p1, Polynomial p2);
  返回值： 
      多项式 "差" 的表头指针 
  ------------------------------------------------------------------------------
  函数 Multiply - 多项式乘积： p1 * p2 
               链表 p1和p2保持不变 
       Polynomial Multiply(Polynomial p1, Polynomial p2);
  返回值：
      多项式 "积" 的表头指针 
  ------------------------------------------------------------------------------

 裁判程序如下

#include 
#include 

#define MAXLINE 1024

// 交换 a, b，以t为中间变量
#define SWAP(a,b,t) (t)=(a),(a)=(b),(b)=(t)

//  单项式结构 
typedef struct MonomialStruct{
    int coef; // 系数
    int expo;  // 幂次
    struct MonomialStruct * next;
} Monomial; 

//  多项式类型定义
typedef Monomial *Polynomial;

void       PrintMonomial(int coef, int expo); 
Monomial*  ParseMonomial(char **s);
Polynomial InsertAfterTail(Polynomial head, Monomial* pNewNode);
Polynomial TrimZeroTerms(Polynomial head);
Polynomial SortPolynomial(Polynomial head);
Polynomial Minus(Polynomial p1, Polynomial p2);
Polynomial Multiply(Polynomial p1, Polynomial p2);

/*******************************************************************************
 函数 CreateMonomial - 创建一个单项式项式节点 
      Monomial * CreateMonomial(int coef, int expo); 
 参数
     coef - 系数
     expo - 幂指数  
 返回值
     成功 - 所创建的节点指针 
     失败 - NULL 
*******************************************************************************/
Monomial * CreateMonomial(int coef, int expo)
{
    Monomial * p = (Monomial*)malloc(sizeof(Monomial));
    if( !p )
        return NULL;
    p->coef = coef;
    p->expo = expo;
    p->next = NULL;    
    return p;
}

/*******************************************************************************
 函数 DeletePolynomial - 删除一个多项式，并释放所有的节点内存 
      Polynomial DeletePolynomial(Polynomial p)
 参数
     head - 被删除的多项式的头节点指针 
 返回值
     空指针 NULL 
*******************************************************************************/
Polynomial DeletePolynomial(Polynomial head)
{
    while(head) {
        Monomial * d = head;
        head = head->next;
        free(d);
    }
    return NULL;
}

/*****************************************************
 函数 AddMonomial - 在多项式中添加一个单项式
      如果链表中已经存在同次项，则不会创建新节点，而是对系数进行累加。
      Polynomial AddMonomial(Polynomial head, int coef, int expo); 
 参数
      head - 多项式的头节点指针 
      coef - 单项式的系数
      expo - 单项式的幂指数 
 返回值
      新的多项式链表的表头指针
*****************************************************/
Polynomial AddMonomial(Polynomial head, int coef, int expo)
{
    Monomial * p;
    if( coef==0 )
        return head;

    for( p = head; p && p->expo!=expo; p = p->next )
        ; // 寻找同次项
    if( p ) 
        // 找到同次项 
        p->coef += coef;
    else {
        p = CreateMonomial(coef, expo);
        head = InsertAfterTail(head, p);
    }
    return head;
}

/*****************************************************
  函数 Add - 多项式求和： p1 + p2 
               链表 p1 和 p2保持不变 
  返回值：
      多项式 "和" 的表头指针 
*****************************************************/ 
Polynomial Add(Polynomial p1, Polynomial p2)
{
    Polynomial h = NULL;
    for( ; p1; p1=p1->next )
        h = AddMonomial(h, p1->coef, p1->expo);
    for( ; p2; p2=p2->next )
        h = AddMonomial(h, p2->coef, p2->expo);
    return h;
}

// 判断字符串 s 的起始字符是否为：x^ 或 X^
int IsEXPO(char *s)
{
    return ( (s[0]=='x' || s[0]=='X') && s[1]=='^');
}

// 字符是否为\n或\0
int IsEndingChar(char ch)
{
    return (ch==0 || ch=='\n');
}

// 跳过字符串起始部分的空格和制表符
// 返回值：一个指针
//        指向字符串前面的第一个非空白字符
char * SkipSpaceChars(char *s)
{
    while( *s==' ' || *s=='\t' )
        s++;
    return s;
}

/*****************************************************
  函数 GetSignChar - 字符串*s中第一个单项式的符号字符
       int GetSignChar(char **s);
  参数 
       s - *s是字符串指针 
  返回值
    成功   -返回符号字符，将*s指向符号之后的字符 
    不成功 -返回 0 
*****************************************************/
int GetSignChar(char **s)
{
    char *p = SkipSpaceChars(*s); // 忽略空白字符
    if( *p=='+' || *p=='-' ) {
        *s = p + 1;
        return (*p);
    }
    return 0;
}

/*****************************************************
从一行标准输入，读取一个一元多项式 
返回值：
    所读取的多项式链表的表头指针
*****************************************************/ 
Polynomial ParsePolynomial()
{
    char linebuffer[1024], *s = linebuffer;
    Polynomial hResult = NULL;

    if( !fgets(linebuffer, sizeof(linebuffer), stdin) )
        return NULL;
    while( 1 ) {
        Monomial *pNewNode;
        int signChar = GetSignChar(&s);
        pNewNode = ParseMonomial(&s);
        if( !pNewNode ) 
            break;
        if( signChar == '-' )
            pNewNode->coef =  -pNewNode->coef; 
        hResult = InsertAfterTail(hResult, pNewNode);
    }
    return hResult;
}

/*****************************************************
  函数 PrintPolynomial - 输出多项式
       Polynomial PrintPolynomial(Polynomial pHead);
       两个单项式之间的+/-左右各留出一个空格 
  返回值
       被输出的多项式 
*****************************************************/ 
Polynomial PrintPolynomial(Polynomial pHead)
{
    Polynomial p = pHead;
    int firstTerm = 1, nothingOutputYet = 1; 
    for( ; p; p = p->next )
    {
        int c = p->coef;
        int k = p->expo;
        if( c==0 ) // 忽略系数为0的项
            continue;
        if( firstTerm ) {
            PrintMonomial(c,k);
            firstTerm = 0;
        } else {
            printf(" %c ", c>0 ? '+' : '-');
            PrintMonomial(c>0?c:-c, k);
        }
        nothingOutputYet = 0; 
    }
    if( nothingOutputYet ) 
        putchar('0');
    putchar('\n');
    return pHead;
}


/*------------------------------------------------------------------

 1. 如果测试多项式输入输出，那么： 
 
   输入多项式1，回车
   回车
 
 2. 如果测试两个多项式的 "加"、"减"、"乘"运算，那么： 
 
   输入第一个多项式，回车
   输入运算符（+、-、*)，回车
   输入第二个多项式，回车

------------------------------------------------------------------*/ 
int main()
{
    Polynomial p1,  p2,  pResult;
    char cmdString[MAXLINE], cmd;
     
    p1 = ParsePolynomial(); //读入多项式 1 

    if( !fgets(cmdString, sizeof(cmdString), stdin) )
        return 0;

    cmd = cmdString[0];
    
    if( cmd!='+' && cmd!='-' && cmd!='*' ) {
        //测试多项式的输入和输出 
        printf("input=");
        PrintPolynomial( p1 );
        return 0;
    }
    
    p2 = ParsePolynomial(); //读入多项式 1 
    
    // printf("\n运算结果是:\n\n");
    PrintPolynomial( p1 );
    printf("%c\n", cmd);
    PrintPolynomial( p2 );
    printf("=\n");
        
    if( cmd=='+' )
        pResult = PrintPolynomial( SortPolynomial( TrimZeroTerms( Add(p1,p2) ) ) );
    else if( cmd=='-' )
        pResult = PrintPolynomial( SortPolynomial( TrimZeroTerms( Minus(p1, p2) ) ) );
    else //if( cmd=='*' )
        pResult = PrintPolynomial( SortPolynomial( TrimZeroTerms( Multiply(p1, p2) ) ) );

    // printf("\n");

    DeletePolynomial(p1);
    DeletePolynomial(p2);
    DeletePolynomial(pResult);
    
    return 0; 
}

 以下是我写的代码

1.输出单项式

//by jr_wwwsy


//输出单项式
void PrintMonomial(int coef, int expo){
	if(expo==0){                    
		printf("%d",coef);
		return;
	}
	if(coef!=1&&coef!=-1){
		printf("%d",coef);
	}
	else if(coef==-1){
		printf("-");
	}
	printf("x");
	if(expo==1){
		return;
	}
	printf("^%d",expo);
	return;
}

这个函数要注意就是对系数和指数分类讨论，要注意讨论的顺序，还有就是情况不要有所遗漏，可以自己多测试几组输出

2.读入第一个单项式

Monomial*  ParseMonomial(char **s){
	if(IsEndingChar(**s)) return NULL;           //如果读入的是结束符号，那么就返回NULL
	int coef=1,expo=0;                    //赋初值
	if(**s>='0'&&**s<='9'){                 //读取系数
		coef=0;
		while(**s>='0'&&**s<='9'){
			coef=coef*10+**s-'0';
			(*s)++;
		}
	}
	if( !IsEXPO(*s) && (**s=='x'||**s=='X') ){       //判断指数是不是1
		(*s)++;
		expo=1;
	}
	else if( IsEXPO(*s) ){            //指数不是1的情况
		(*s)+=2;
		int tag=1;
		expo=0;
		if(**s=='-') tag=-1,(*s)++;      //注意负号
		while(**s>='0'&&**s<='9'){
			expo=expo*10+**s-'0';
			(*s)++;
		}
		expo=expo*tag;
	}
	
	//printf("%d %d %c ",coef,expo,**s);
	return CreateMonomial(coef,expo);          //裁判程序中给出的函数
}

这部分读入需要用到二级指针，因为需要使指针移动来读取后面的单项式；

这里我犯了一个小错误，就是用了*s++的写法，记错了优先级，所以多种运算符出现在一起时，如果不确定，就多用括号来规避错误

3.插入一个新节点到多项式链表的结尾

Polynomial InsertAfterTail(Polynomial head, Monomial* pNewNode){
	Monomial *tail=head;
	if(head==NULL){
		head=pNewNode;
		pNewNode->next =NULL;
		return head;
	}
	while(tail->next !=NULL){
		tail=tail->next ;
	}
	tail->next =pNewNode;
	pNewNode->next =NULL;
	//printf("success");
	return head;
}

 这里我之前忘记了判定head==NULL，就导致单项式一直挂不到链表上

4.删除系数为0的节点

Polynomial TrimZeroTerms(Polynomial head){
	Monomial *find=head,*tmp;
	while(find->next !=NULL){
		tmp=find->next ;
		if(tmp->coef ==0){
			find->next =tmp->next ;
			free(tmp);
		}
		else find=tmp;
	}
	if(head->coef ==0){
		tmp=head->next;
		head=head->next ;
		free(tmp);
	}
	return head;
}

5.将单项式排序

个人感觉在链表上，冒泡排序写起来最顺手，其他排序方法没有尝试过（而且复杂度不高的情况下用冒泡排序不会超时），交换的方式我是非常简单粗暴的交换了节点里面的对应元素，刚开始有想过通过指针交换两个节点，但我觉得写起来不如直接交换内容舒服（每个节点只存系数和指数，交换起来不会太麻烦）

Polynomial SortPolynomial(Polynomial head){
	Monomial *a,*tag=NULL;
	int t;
	while(head!=tag){
		//printf("t");
		a=head;
			//printf("%d %d ",a->expo ,a->next->expo);
		while(a!=tag&&a->next !=tag){
		//printf("in");
			if((a->expo) >(a->next->expo) ){
				
				SWAP(a->expo ,a->next->expo,t);
				SWAP(a->coef ,a->next->coef,t);
			}
			a=a->next;
		}
		tag=a;
	}
	return head;
}

这里还有一个点就是我写的时候没分清head和head->next，导致陷入死循环

6.多项式减法

AddMnomial( ) 是原题给出的，直接拿来用就好

Polynomial Minus(Polynomial p1, Polynomial p2){
	Polynomial h = NULL;
    for( ; p1; p1=p1->next )
        h = AddMonomial(h, p1->coef, p1->expo);
    for( ; p2; p2=p2->next )
        h = AddMonomial(h, -p2->coef, p2->expo);
    return h;
}

 7.多项式乘法

这里要注意内层循环不能直接用p2，因为这样的话在下一个外层循环的时候p2已经指向NULL，且找不到链表头，所以重新设置变量pp充当循环变量

Polynomial Multiply(Polynomial p1, Polynomial p2){
	Polynomial h = NULL,pp;
    for( ;p1;p1=p1->next ){
    	for(pp=p2;pp;pp=pp->next ){
    		h=AddMonomial(h,p1->coef *pp->coef ,p1->expo +pp->expo );
		}
	}
    return h;
}