C++/C使用数据结构实现多项式的相加相减求导和正序输出逆序输出（可以保存到文件和从文件读取）

**

数据结构实现多项式的一些操作时，使用链表来实现，直接上代码。

**
代码里面有备注

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



using namespace std;


//多项式的一项结构体
struct Node{

 int index;//一元多项式的指数
 int coefficient;//一元多项式的系数
 struct Node *next;
};


//求多项式的长度
int getPolynomialSize(struct Node *head){

       int size_polynomial=0;
       struct Node *q;
       q=head->next;
       while(q!=NULL){//将其得长度，在指向下一个节点的同时长度加一
        size_polynomial++;
        q=q->next;
       }

       return size_polynomial;//返回长度
};

//将链表倒叙
struct Node *ReversePolynomial(struct Node *head){

    struct Node *reversehead,*q,*p,*polynomial;
    int sizePolynomial;
    sizePolynomial = getPolynomialSize(head);//得到长度
    struct Node saverLink[sizePolynomial];//用来存储一元多项式的数据
    q=reversehead=(struct Node*)malloc(sizeof(struct Node));
    polynomial = head->next;
    for(int i=0;i<sizePolynomial;i++){//先将一元多项式中的数据存入数组内
        saverLink[i].coefficient= polynomial->coefficient;
        saverLink[i].index = polynomial->index;
        polynomial = polynomial->next;
    }
    for(int i=sizePolynomial-1;i>=0;i--){//然后将数组中的数据倒序输出，放入链表内
        p=(struct Node*)malloc(sizeof(struct Node));//申请空间
        p->coefficient = saverLink[i].coefficient;
        p->index = saverLink[i].index;
        p->next = NULL;
        q->next=p;
        q = p;
    }
    return reversehead;//返回倒序链表
};


//创建多项式
struct Node *CreatePolynomial(){

     struct Node *head,*p,*q;
     int size_Link;//多项式项数
     q=head=(struct Node*)malloc(sizeof(struct Node));
     printf("..............输入多项式项数..............\n");
     scanf("%d",&size_Link);
     struct Node polynomial[size_Link];
     int Maxindex;//用来存放最大的
     for(int i=0;i<size_Link;i++){//一元多项式输入
        printf("..............输入第%d项的系数..............\n",i+1);
        scanf("%d",&polynomial[i].coefficient);
        printf("..............输入第%d项的指数..............\n",i+1);
        scanf("%d",&polynomial[i].index);
        if(i==0){
            Maxindex = polynomial[i].index;//用来存放最大的指数值
        }else{

            if(polynomial[i].index<Maxindex){//当当前指数大于前一项的指数时进行转换位置
                int beforeindex,beforecoefficient;
                beforeindex = polynomial[i-1].index;
                beforecoefficient = polynomial[i-1].coefficient;
                polynomial[i-1].index = polynomial[i].index;
                polynomial[i-1].coefficient = polynomial[i].coefficient;
                polynomial[i].index = beforeindex;
                polynomial[i].coefficient = beforecoefficient;
                int minniindex = polynomial[i-1].index;//用于存放前一项的指数值
                    for(int j=i-2;j>=0;j--){
                        if(minniindex<polynomial[j].index){//当前项的指数值小于前一项的指数值时转换位置
                            beforeindex = polynomial[j].index;
                            beforecoefficient = polynomial[j].coefficient;
                            polynomial[j].index = polynomial[j+1].index;
                            polynomial[j].coefficient = polynomial[j+1].coefficient;
                            polynomial[j+1].index = beforeindex;
                            polynomial[j+1].coefficient = beforecoefficient;
                        } else{
                              if(minniindex== polynomial[j].index){//前一项指数值与当前指数值相同时就把他们合并为同一项
                                 polynomial[j+1].coefficient = polynomial[j].coefficient + polynomial[j+1].coefficient;
                                 polynomial[j].coefficient =0;
                                 polynomial[j].index = 0;

                              }
                        }
                          minniindex = polynomial[j].index;
                    }


            }else{
                     if(polynomial[i].index==Maxindex){//前一项指数值与当前指数值相同时就把他们合并为同一项
                polynomial[i].coefficient = polynomial[i-1].coefficient + polynomial[i].coefficient;
                polynomial[i-1].coefficient =0;
                polynomial[i-1].index = 0;

            }
            }

            if(polynomial[i].index>Maxindex){

            }
             Maxindex = polynomial[i].index;//将其最大的指数赋值
        }

     }

     for(int i=0;i<size_Link;i++){//将数组中的转换为链表
        p = (struct Node*)malloc(sizeof(struct Node));
        if(polynomial[i].index==0&&polynomial[i].coefficient==0){//如果系数为0和指数为0就不存入链表中

        }else{
            if(polynomial[i].coefficient==0){//如果系数0就不存入链表中

            }else{
                 p->index = polynomial[i].index;//将其放入链表中
                 p->coefficient = polynomial[i].coefficient;
                 p->next = NULL;
                 q->next = p;
                 q=p;
            }

        }

     }

     return head;//返回头节点
};


//从文件中输出多项式A
struct Node *fileinA(){
    struct  Node *p1,*p2,*headA;
  int i=0;
  FILE *fp;//打开文件
  char file[20]="d:\\polynomialA.txt";
  if ((fp=fopen(file,"rb"))==NULL)//判断文件是否可以打开
    {

      printf("..............不能打开文件:%s..............\n",file);
      exit(0);
    }
  headA=p2=(struct Node *)malloc(sizeof(*p1));//申请空间
  headA->next=NULL;
  p1=(struct Node *)malloc(sizeof(*p1));
  while (fread(p1,sizeof(*p1),1,fp)==1)//将文件中的内容读入链表中
   { i++;
     p2->next=p1;
     p2=p1;
     p1->next=NULL;
     p1=(struct Node *)malloc(sizeof(*p1));
   }
   free(p1);
  fclose(fp);//判断文件中内容是否为空
  if (i==0){     printf("..............没有任何记录%s!..............\n");
	   }
  return headA;
};


//从文件中输出多项式B
struct Node *fileinB(){
    struct  Node *p1,*p2,*headB;
  int i=0;
  FILE *fp;//打开文件
  char file[20]="d:\\polynomialB.txt";
  if ((fp=fopen(file,"rb"))==NULL)//判断文件是否可以打开
    {
      printf("..............不能打开文件:%s..............\n",file);
      exit(0);
    }
  headB=p2=(struct Node *)malloc(sizeof(*p1));//申请空间
  headB->next=NULL;
  p1=(struct Node *)malloc(sizeof(*p1));
  while (fread(p1,sizeof(*p1),1,fp)==1)//将文件中的内容读入链表中
   { i++;
     p2->next=p1;
     p2=p1;
     p1->next=NULL;
     p1=(struct Node *)malloc(sizeof(*p1));
   }
   free(p1);
  fclose(fp);//判断文件内容是否为空
  if (i==0){     printf("..............没有任何记录%s!..............\n");
	   }
  return headB;
};

//将一元多项式A存入文件中
void saveA(struct Node *head)
{ struct Node *p1;

   if(head==NULL){//判断文件是否为空
     printf(".............. 一元多项式为空，请现输入在保存..............\n" );
     return ;
   }
  FILE *fp;
  char file[20]="d:\\polynomialA.txt";
  if ((fp=fopen(file,"wb"))==NULL)//打开文件
    {
      printf("..............不能打开文件:%s............../n",file);
      exit(0);
    }
   p1=head->next;
   while (p1!=NULL)//将链表中的内容存入文件中
   { fwrite((void *)p1,sizeof(struct Node),1,fp);
     p1=p1->next;
   }
   fclose(fp);
};

//将一元多项式B存入文件中
void saveB(struct Node *head)
{ struct Node *p1;

   if(head==NULL){//判断链表是否为空
     printf(".............. 一元多项式为空，请现输入在保存..............\n" );
     return ;
   }

  FILE *fp;
  char file[20]="d:\\polynomialB.txt";
  if ((fp=fopen(file,"wb"))==NULL)//打开文件
    {
      printf("..............不能打开文件:%s..............\n",file);
      exit(0);
    }
   p1=head->next;
   while (p1!=NULL)//将链表中的内容存入文件中
   { fwrite((void *)p1,sizeof(struct Node),1,fp);
     p1=p1->next;
   }
   fclose(fp);
};






//测试打印
void println(struct Node *head){

   struct Node *q,*reversehead;//reversehead为逆序的头节点

    if(NULL == head){//首先判断一元多项式是否为空
        printf("..............一元多项式为空..............\n");
        return ;
    }
   printf(".....................需要正序输出输入1，逆序输出输入0..............\n");
   int flag;
   scanf("%d",&flag);
   if(flag==1){
    q = head->next;

   }
   if(flag==0){
    reversehead = ReversePolynomial(head);//得到逆序的一元多项式链表
    q = reversehead->next;

   }

    if(q==NULL){
        printf("..............一元多项式为空..............\n");
        return ;
    }
      printf("M(x)=");
   while(q!=NULL){
         if(q->coefficient<0){//如果系数小于0就放在括号里面
            printf("(%d)",q->coefficient);
         }
         else{//否则不放入

            printf("%d",q->coefficient);
         }
         if(q->next==NULL){//如果是最后一项则后面+号不加了
                if(q->index==0){//若是指数为0则不打印指数了
                    printf(";\n");
                }else
            printf("X^%d;\n",q->index);
         }else{
              if(q->index==0){//若是指数为0则不打印指数了
                    printf("+");
                }else if(q->index==1){//若指数为一的话就不用打印指数
                   printf("X+");
                }else//若不为一的话就打印指数
          printf("X^%d+",q->index);
         }

        q = q->next;
   }

};


//多项式相加
struct Node *AddPolynomial(struct Node *headA,struct Node *headB){

       struct Node *head,*p,*q,*pA,*pB; //pA为headA一元多项式的头节点，pB为一元多项式headB的头节点
       int size_polynomialA,size_polynomialB;//size_polyonmialA为一元多项式A的长度，size_polynomialB为一元多项式B的长度
       int size_polnomial;//表示两个一元多项式的长度之和

       if(headA==NULL&&headB==NULL){
        printf("..............         多项式为空无法进行加法计算,请先输入多项式  ................\n");
        return NULL;
       }

       size_polynomialA = getPolynomialSize(headA);//得到一元多项式headA的长度
       size_polynomialB = getPolynomialSize(headB);//得到一元多项式headB的长度

       pA = headA->next;
       pB = headB->next;
      q=head=(struct Node*)malloc(sizeof(struct Node));//申请空间

    size_polnomial = size_polynomialA + size_polynomialB;//得到两个一元多项式的总长度

       for(int i=0;i<size_polnomial;i++){//进行循环，使其可以遍历两个一元多项式
            int flag;//判断标志
              if(pA!=NULL&&pB!=NULL){
                if(pA->index>pB->index){//当pB中的指数较小时将其节点插入新链表中
                     p = (struct Node*)malloc(sizeof(struct Node));//申请空间
                     p->coefficient = pB->coefficient;
                     p->index = pB->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     flag = 1;//将一元多项式B加入新的一元多项式中

                }
                if(pA->index==pB->index){//当pB中的指数和pA中的指数相同时将其节点指数值给新链表的指数值，但是系数是这两个的系数之和
                     p = (struct Node*)malloc(sizeof(struct Node));
                      int sumCofficient = pA->coefficient + pB->coefficient;
                     if(sumCofficient==0){//如果两个系数之和为零的话不存入新一元多项式中

                     }else{
                     p->coefficient = pB->coefficient+pA->coefficient;//系数和相加
                     p->index = pB->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     }

                     flag = 2;//一元多项式A和一元多项式B指数相同，相加之后加入

                }
                if(pA->index<pB->index){//当pA中的指数较小时将其节点插入新链表中
                     p = (struct Node*)malloc(sizeof(struct Node));//申请空间
                     p->coefficient = pA->coefficient;
                     p->index = pA->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     flag = 3;//将一元多项式A放入新的一元多项式中

                }
                switch(flag){
                     case 1:
                          pB = pB->next;//一元多项式B移向下一个节点
                          break;
                     case 2:
                          pA = pA->next;//一元多项式A移向下一个节点
                          pB = pB->next;//一元多项式B移向下一个节点
                          i++;//同时需要将i加一
                          break;
                     case 3:
                          pA = pA->next;//一元多项式A移向下一个节点
                          break;
                     default:
                          break;
                }
              }


            if(pA==NULL){//如果一元多项式此时指向最后一个节点时将一元多项式B中剩余的所有节点都放入新节点中
                while(pB){
                     p = (struct Node*)malloc(sizeof(struct Node));//申请空间
                     p->coefficient = pB->coefficient;
                     p->index = pB->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     pB = pB->next;
                     i++;//此时i要一直加一
                }
            }

            if(pB==NULL){//如果一元多项式此时指向最后一个节点时将一元多项式A中剩余的所有节点都放入新节点中
                while(pA){
                     p = (struct Node*)malloc(sizeof(struct Node));//申请空间
                     p->coefficient = pA->coefficient;
                     p->index = pA->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     pA = pA->next;
                     i++;//再PA不断加入的同时i同时进行加一
                }
            }


       }


   return head;

};


//多项式的相减
struct Node *SubtractionPolynomial(struct Node *headA,struct Node *headB){

       struct Node *head,*p,*q,*pA,*pB ; //pA为headA一元多项式的头节点，pB为一元多项式headB的头节点
       int size_polynomialA,size_polynomialB;//size_polyonmialA为一元多项式A的长度，size_polynomialB为一元多项式B的长度
       int size_polnomial;//表示两个一元多项式的长度之和

        if(headA==NULL&&headB==NULL){
        printf("..............         多项式为空无法进行减法计算,请先输入多项式  ................\n");
        return NULL;
       }

       size_polynomialA = getPolynomialSize(headA);//得到一元多项式headA的长度
       size_polynomialB = getPolynomialSize(headB);//得到一元多项式headB的长度

       pA = headA->next;
       pB   = headB->next;
       q=head=(struct Node*)malloc(sizeof(struct Node));//申请空间


    size_polnomial = size_polynomialA + size_polynomialB;//得到两个一元多项式的总长度

       for(int i=0;i<size_polnomial;i++){//进行循环，使其可以遍历两个一元多项式

            int flag;//判断标志
              if(pA!=NULL&&pB!=NULL){
                if(pA->index>pB->index){//当pB中的指数较小时将其节点插入新链表中
                     p = (struct Node*)malloc(sizeof(struct Node));//申请空间
                     p->coefficient = pB->coefficient;
                     p->index = pB->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     flag = 1;//将一元多项式B加入新的一元多项式中

                }
                if(pA->index==pB->index){//当pB中的指数和pA中的指数相同时将其节点指数值给新链表的指数值，但是系数是这两个的系数之和
                     p = (struct Node*)malloc(sizeof(struct Node));
                      int sumCofficient = pA->coefficient - pB->coefficient;
                     if(sumCofficient==0){//如果两个系数之和为零的话不存入新一元多项式中

                     }else{
                     p->coefficient = pB->coefficient-pA->coefficient;//系数和相加
                     p->index = pB->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     }

                     flag = 2;//一元多项式A和一元多项式B指数相同，相加之后加入

                }
                if(pA->index<pB->index){//当pA中的指数较小时将其节点插入新链表中
                     p = (struct Node*)malloc(sizeof(struct Node));//申请空间
                     p->coefficient = pA->coefficient;
                     p->index = pA->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     flag = 3;//将一元多项式A放入新的一元多项式中

                }
                switch(flag){
                     case 1:
                          pB = pB->next;//一元多项式B移向下一个节点
                          break;
                     case 2:
                          pA = pA->next;//一元多项式A移向下一个节点
                          pB = pB->next;//一元多项式B移向下一个节点
                          i++;//同时需要将i加一
                          break;
                     case 3:
                          pA = pA->next;//一元多项式A移向下一个节点
                          break;
                     default:
                          break;
                }
              }


            if(pA==NULL){//如果一元多项式此时指向最后一个节点时将一元多项式B中剩余的所有节点都放入新节点中
                while(pB){
                     p = (struct Node*)malloc(sizeof(struct Node));//申请空间
                     p->coefficient = pB->coefficient;
                     p->index = pB->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     pB = pB->next;
                     i++;//此时i要一直加一
                }
            }

            if(pB==NULL){//如果一元多项式此时指向最后一个节点时将一元多项式A中剩余的所有节点都放入新节点中
                while(pA){
                     p = (struct Node*)malloc(sizeof(struct Node));//申请空间
                     p->coefficient = pA->coefficient;
                     p->index = pA->index;
                     p->next = NULL;
                     q->next = p;
                     q = q->next;
                     pA = pA->next;
                     i++;//将节点加入的同时进行i++同步增长
                }
            }


       }

       return head;

};


//一元多项式求导
struct Node *DerivativePolynomial(struct Node *head){

   struct Node *derivate,*q,*p;
   if(head==NULL){//若链表为空则直接放回
    return NULL;
   }
   q=derivate=(struct Node*)malloc(sizeof(struct Node));
   head = head->next;
   while(head){

    int product = head->coefficient*head->index;//求导后的系数
    if(product!=0){//判断乘积是否为0，若为0则不存入
        p=(struct Node*)malloc(sizeof(struct Node));
        p->coefficient=product;
        p->index = head->index-1;
        p->next = NULL;
        q->next = p;
        q=p;
    }
    head = head->next;
   }

   return derivate;
};





int main()
{
    struct Node *headA=NULL,*headB=NULL,*Addhead=NULL,*Subtractionhead=NULL,*derivateA=NULL,*derivateB=NULL,*derivateAdd=NULL,*derivateSubtrac=NULL ;//headA为一元多项式A链表的头节点，
    //headB为一元多项式B链表的头节点，
    //Addhead是两个一元多项式相加的一元多项式的链表的头节点，
    //Subtractionhead是两个一元多项式相减的一元多项式的链表的头节点
    //derivateA是一元多项式A的求导链表的头节点
    //derviateB是一元多项式B的求导链表的头节点
    //derviateAdd是一元多项式相加结果的值的链表的头节点
    //derviateSubtrac是一元多项式结果相减的值的链表的头节点
    int  note;//为判断做什么操作的标志



      do{
     printf("........................功能列表...................\n");
     printf("..............         1.创建一元多项式  ................\n");
     printf("..............         2.从文件中提取一元多项式  ................\n");
     printf("..............         3.进行加法计算  ................\n");
     printf("..............         4.进行减法计算  ................\n");
     printf("..............         5.保存数据  ................\n");
     printf("..............         6.打印一元多项式A  ................\n");
     printf("..............         7.打印一元多项式B  ................\n");
     printf("..............         8.打印进行加法运算结果  ................\n");
     printf("..............         9.打印进行减法运算结果  ................\n");
     printf("..............         10.打印一元多项式A求导结果  ................\n");
     printf("..............         11.打印一元多项式B求导结果  ................\n");
     printf("..............         12.打印进行加法运算求导结果  ................\n");
     printf("..............         13.打印进行减法运算求导结果  ................\n");
     printf("..............         14.退出  ................\n");
     scanf("%d",&note);
        switch(note){
            case 1://创建一元多项式
                    printf("..............         输入一元多项式A  ................\n");
                    headA = CreatePolynomial();
                    printf("..............         输入一元多项式B  ................\n");
                    headB = CreatePolynomial();
            break;
            case 2://从文件中提取一元多项式
                    headA = fileinA();
                    headB = fileinB();
                    if(headA==NULL||headB==NULL){
                    printf("..............         文件中的数据为空，请现输入一元多项式  ................\n");
                    }

            break;
            case 3://一元多项式相加
                   Addhead = AddPolynomial(headA,headB);

            break;
            case 4://一元多项式的相减
                   Subtractionhead = SubtractionPolynomial(headA,headB);

            break;
            case 5://保存一元多项式到文件中
                   saveA(headA);
                   saveB(headB);

            break;
            case 6://打印一元表达式A
                   println(headA);

            break;
            case 7://打印一元表达式B
                   println(headB);

            break;
            case 8://打印一元表达式相加的结果
                   println(Addhead);

            break;
            case 9://打印一元表达式相减的结果
                   println(Subtractionhead);

            break;
            case 10://打印一元表达式A的求导结果
                   derivateA = DerivativePolynomial(headA);
                   println(derivateA);

            break;
            case 11://打印一元表达式B的求导结果
                   derivateB = DerivativePolynomial(headB);
                   println(derivateB);

            break;
            case 12://打印一元表达式相加的结果的求导结果
                   derivateAdd = DerivativePolynomial(Addhead);
                   println(derivateAdd);

            break;
            case 13://打印一元表达式相减的结果的求导结果
                   derivateSubtrac = DerivativePolynomial(Subtractionhead);
                   println(derivateSubtrac);

            break;
            case 14://退出
                exit(0);
        }

    }while(note<14);

    return 0;
}

代码里面有备注，如果有错误欢迎指出，然后有不清楚的可以留言。