一元稀疏多项式

1.一元稀疏多项式

#include<stdio.h>
#define max 100 
typedef struct node
{
    int xishu,zhishu;//系数和指数
    struct node *next;
    char fuhao;//此项后的符号
}lot,*lotcac;//多项式结构体

----------------------------------------------------
int main()
{
    lotcac create();//用户输入多项式的函数
    void print(lotcac);//输出稀疏多项式
    lotcac addcac(lotcac,lotcac);//多项式相加函数
    lotcac jiancac(lotcac,lotcac);//与加类似，不做赘述
    lotcac multipcac(lotcac,lotcac);//多项式相乘函数
}

-------------------------------------------------
lotcac addcac(lotcac p,lotcac q)
{
    lotcac add,r;
    add=(lotcac)malloc(sizeof(lot));
    add->next=NULL;
    r=add;
    m=p->next;
    n=q->next;
    while(m&&n)
    {
        if(m->zhishu==n->zhishu)
        {
            lotcac newnode=(lotcac)malloc(sizeof(lot));
            newnode->zhishu=m->zhishu;
            newnode->xishu=m->xishu+n->xishu;
            r->next=newnode;
            newnode->next=NULL;
            r=newnode;
            m=m->next;
            n=n->next;
        }
        else if(m->zhishu>n->zhishu)
        {
            lotcac newnode=(lotcac)malloc(sizeof(lot));
            newnode->zhishu=m->zhishu;
            newnode->xishu=m->xishu;
            r->next=newnode;
            newnode->next=NULL;
            r=newnode;
            m=m->next;
        }
        else
        {
            lotcac newnode=(lotcac)malloc(sizeof(lot));
            newnode->zhishu=n->zhishu;
            newnode->xishu=n->xishu;
            r->next=newnode;
            newnode->next=NULL;
            r=newnode;
            n=n->next;
        }
    }
    while(m)
    {
            lotcac newnode=(lotcac)malloc(sizeof(lot));
            newnode->zhishu=m->zhishu;
            newnode->xishu=m->xishu;
            r->next=newnode;
            newnode->next=NULL;
            r=newnode;
            m=m->next;
    }
    while(n)
    {
            lotcac newnode=(lotcac)malloc(sizeof(lot));
            newnode->zhishu=n->zhishu;
            newnode->xishu=n->xishu;
            r->next=newnode;
            newnode->next=NULL;
            r=newnode;
            n=n->next;
    }
    return add;
}
-----------------------------
void print(lotcac p)
{
    if(p)
    {
    q=p->next;
    while(q->next!=NULL)//因为最后一项没有运算符，所以特殊处理
    {
        printf("%dx^%d%c",p->xishu,p->zhishu,p->fuhao);
        q=q->next;
    }
    printf("%dx%d\n",q->xishu,q->zhishu);
    }
}
--------------------------------
lotcac create()
{
    lotcac p=(lotcac)malloc(sizeof(lot));//头节点
    p->next=NULL;
    printf("请输入项数：\n");
    scanf("%d",&n);
    printf("请逐个输入多项式的每项系数、指数及其后面的符号,之间逗号隔开：\n");
    for(int i=0;i<n;i++)
    {
        if(i<n-1)
        {
        printf("第%d项\n",i+1);
        lotcac newnode=(lotcac)malloc(sizeof(lot));
        scanf("%d,%d,%c",&newnode->xishu,&newnode->zhishu,&newnode->fuhao);
        getchar();
        }
        else//最后一项没有运算符
        {
            printf("第%d项\n",i+1);
            lotcac newnode=(lotcac)malloc(sizeof(lot));
            scanf("%d,%d",&newnode->xishu,&newnode->zhishu);
        }
        q=p->next;
        pre=p;
        while(q)//寻找插在哪里
        {
            if(q->zhishu>newnode->zhishu)
            {
                pre=q;
                q=q->next;
            }
            else
            {
                break;
            }
        }
        //头插法
        newnode->next=pre->next;
        pre->next=newnode;
    }
    return p;
}


-----------------------------------------
Link Reverse(Link p)
/*
用头插法逆置链表，
使多项式由降幂变成升幂顺序
或使多项式由升幂变成降幂顺序
*/ 
{
    Link head=p; 
    Link q1,q2;
    q2=head->next;
    head->next=NULL;//断开头结点与第一个结点 
    while(q2)
    {
        q1=q2;      
        q2=q2->next; 
        q1->next=head->next; //头插 
        head->next=q1;  
    }      
    return head;//返回链表逆置后的头结点 
}
-----------------------------------------
Link MultiplyPolyn(Link A,Link B)
/*
    两个多项式相乘得一个新多项式，并且返回新多项式的头结点的指针
    相乘前，A，B两个多项式均是升幂排序 
    相乘时，A为降幂排序，B为升幂排序  
*/
{
  Link pa,pb,pc,s,head;
  int k,maxExpn,minExpn;
  float coef;
  
  head=(Link)malloc(LEN);//头结点 
  head->next=NULL;
  
  if(A->next!=NULL&&B->next!=NULL){
      minExpn=A->next->expn+B->next->expn; //minExpn为两个多项式中指数和的最小值 
     A=Reverse(A);//将A降幂排列 
    B=Reverse(B);//将B降幂排列 
      maxExpn=A->next->expn+B->next->expn; //maxExpn为两个多项式中指数和的最大值
  }
  else{
          return head;
  }       
   pc=head;
   B=Reverse(B);//将B升幂排列 
   
   for(k = maxExpn;k>=minExpn;k--){ //多项式的乘积指数范围为：minExpn~maxExpn
           //根据两项的指数和使每一次循环都得到新多项式中一项  
           pa = A->next;
           while(pa !=NULL&&pa->expn>k){  //pa都大于k了就没另一项的事了
               pa = pa->next;
           }
           pb = B->next;
           while(pb!=NULL&&pa!=NULL&&pa->expn+pb->expn<k){//找到指数和相等或大于的情况
               pb = pb->next;
           }
        coef=0.0;
        while(pa!=NULL&&pb!=NULL){//上面的while退出后则找寻了一个可能范围，可能出现我们想要的指数和的范围，这个while就是通过不断的移动，将这些指数都为k的项的系数加起来
            if(pa->expn+pb->expn==k){ //如果指数和等于k,系数和累加，且pa，pb均后移结点 
                coef+=pa->coef*pb->coef;
                pa=pa->next;
                pb=pb->next;
            }
            else if(pa->expn+pb->expn>k)}//大于了，则肯定移a因为a事降序
                pa = pa->next;
            }
            else{
                    pb = pb->next;//小于了，肯定移b因为b是升序
            }    
        }
        if(coef!=0.0){
        //如果系数和不为0，则生成新结点，将系数和指数赋给新结点后插入到新多项式中，尾插法，最后结果依旧降序
            s=(Link)malloc(LEN);
            s->coef=coef;
            s->expn=k;
            s->next=pc->next;
            pc->next=s;
            pc=s;
        }
   }
   B = Reverse(B);
   head=Reverse(head);
   return head;    //返回新多项式的头结点 
}
-------------------------------------------------

多项式在某点值和导函数比较简单就不写了