基于循环链表的一元多项式的求值、加减乘法、求导、求积分运算

 

 

 ·~~~记两年前的一次数据结构大作业

---

 一、题目选择

        对课本上第二章的关于求多项式和的例题产生了比较浓厚的兴趣，并思考能否拓展对多项式的运算应用，于是又开辟出一些创新的运算，并尝试不同的算法（主要是对乘法运算，有的不太成功），最终确定了加法、减法、乘法、赋值求结果、求导、求不定积分、求定积分、插入单项等功能，并不断地简化步骤，使过程清晰易懂。

 二、需求分析

        主函数采取了switch-case选择结构，以实现对不同功能的切换选择，在它的外部辅助以do -while循环结构，每次循环结束前都输入一个数字字符以确定下一次循环需要选择验证的功能或者停止 程序。因此要求程序过程中能持续多次输入字符控制功能转换，不发生缓冲区溢出等程序停止工作的内存的问题。并且输入不同的字符，能准确地切换到与之对应的函数模块实现各自对应的功能。验收依据:验收者可以依次输入1-9，根据分别产生的提示进行不同的操作，通过自行运算与程序回显的结果进行比对，判断各自的功能是否准确完善。

 三、概要设计

1.数据结构的设计

typedef  struct  pnode{
    float coef;               
    int exp;                            
    struct pnode *next;
}polynode;

   整体上使用了循环链表的数据结构（循环具体体现在Creat（）函数内，稍后还有分析），定义的结构体包含了多项式系数coef（浮点型）、指数exp（整型）、链表指针域*next。多项式结构体名称定义为polynode。

    多项式节点形式 ：              系数 　　　　　     指数 　　      指针

coef

exp

* next

　　

        例如  7+3x+9x³  +5x¹⁷可以表示为 ：

　　　　　　　　　　　　　

2.设计方案论证

　　对于多项式相乘函数，我们曾探讨了两种方案：

　　对于两个多项式:

　　

　　第一种就是作业源代码中的，这种思想是两个循环嵌套，先拿即A的第一项与B中的每个元素相乘，操作过程即两个指针的coef相乘且exp相加，保存在一个polynode类型的循环链表C里，再把C赋给另一个polynode类型的循环链表D里，把C置空。再拿即A的第二项与B的每一项分别相乘重新赋给C，与B每一项都乘完后把C和D相加（用到了多项式链表相加的函数polynode *Add（polynode *a，polynode *b），实现把b链表按升序加入到a链表里面，后面还有关于多项式相加函数的详解），然后再次置空C……以此类推，直到A的最后一项与B的每一项全乘完一遍得到的C再次加到D里面，得到的D即为A与B的乘积。函数返回D，然后打印出来。

　　第二种方案，与第一种前半部分基本一样，这种思想也是两个循环嵌套，先拿即A的第一项与B中的每个元素相乘，操作过程即两个指针的coef相乘且exp相加，保存在一个polynode类型的循环链表C里，再把C赋给另一个polynode类型的循环链表D里，把C置空。然后，A的第二项与B的第一项相乘，得到的结果作为单个节点插入D里面（这里需要一个函数polynode *Insert（polynode *a，polynode *b）旨在把单节点a插入到一个长链表b里面，然后返回新的b），接着与B的第二项、第三项……B的最后一项乘一遍，每乘一次马上插入D一次，然后A的第二项、第三项……A的最后一项都进行一次这个循环，最后函数返回D。（作业中使用的的乘法函数的是方法一，因为方法一运行更加快捷一些）。

3.函数模块描述

int Getvalue(polynode *head,int x)//多项式求值函数                                       
{
    int flag=0;
    polynode *t=head->next;
    while(t!=head)
    {
        flag+=t->coef*(pow(x,t->exp));
        t=t->next;
    }
    return flag;
}

　　主函数提供一个建立好的多项式链表head，并且给入一个X具体的值，实现把x带入链表对应的数学上的多项式得到一个结果，并返回这个结果。先把flag定义值为0，然后遍历head的每一项，当前flag等于上一次循环得到的flag值（或0）加上现在的幂值：t->coef乘以x的（t->exp）次方。

polynode *BDJF(polynode *head)     //求不定积分函数
{
    polynode *p=head;
    p=p->next;
    while(p!=head)
    {
        p->coef=(p->coef)/(p->exp+1);
        p->exp+=1;
        p=p->next;
    }
    return head;
}

　　上述函数是求不定积分，主函数会给一个已经创建完成的链表*head的头节点地址，操作时，定义个polynode类型p指针指向head第一个元素，进入循环，根据数学求积分的原理，先修改p此前指向的节点的系数为原来的（指数+1）倍，再修改指数，使指数值加一。然后p指针后移，再次判断现在的p是否指向head（因为是循环链表，所以不是NULL），如果不是，重复上述操作，直到head链表里面所有的节点的系数和指数都全部修改完毕返回head头指针。

float djf(polynode *head,float low,float high) //求定积分
{
float d;
    head=BDJF(head);
    d=Getvalue(head,high)-Getvalue(head,low);
    return d;
}

　　需要从主函数给出要求定积分的多项式链表以及上、下界具体浮点值。操作时，先利用BDJF（head）求出head的不定积分函数，接着再通过Getvalue（head，high）和Getvalue（head，low）求出上下界各自对应的值，做差，就是要求的多项式在某个区间上的值。

polynode *Differential(polynode *L)  //求导函数                                         
{
    polynode *p,*q,*pt;
    q=L;
    p=L->next;
    while(p!=L)
    {
        if(p->exp==0)
        {
            pt=p;
            p=p->next;
            q->next=p;
            free(pt);
        }
        else
        {
            p->coef=p->coef*p->exp;
            p->exp--;
            q=p;
            p=p->next;
        }
    }
    return(L);
}

　　主函数提供一个多项式链表L，此函数实现对L的求导操作，即与前文的求不定积分操作恰恰相逆，p指针当前指向节点的系数coef等于p->coef*p->exp，然后修改指数exp，使其减一，修改完毕，p指向下一个节点：p=p->next。直到L全部遍历完成（p=L）循环结束。最后返回修改完的链表L头指针。其中有一步是用if判断指数exp是否为0，因为指数为零即纯系数项，求导值为0，为了节省空间，删除L里面这个部分，使用free（）函数。

polynode  *Insert(polynode *A,polynode *B)  //实现在B链表
{                                  //中按顺序插入单个结点A
    polynode *q1,*q2;
    q1=B;
    q2=B->next;
    while(q2&&A->exp>q2->exp)  //查找插入位置
    {
        q1=q2;
        q2=q2->next;
    }
    if(q2&&A->exp==q2->exp)   //将指数相同项合并
    {
        q2->exp+=A->exp;
        free(A);
        if(!q2->coef)         //若系数相加和为0则释放节点
        {
            q1->next=q2->next;
            free(q2);
        }
    }
    else             //指数为新则插入新节点，改变前后连接逻辑
    {
        A->next=q2;
        q1->next=A;
    }
    return B;    
}

　　此函数的目的其实有两个；其一，仅仅是在一个已经建立好的多项式链表B中插入一个单节点A，并返回现在的B，从而实现、检验链表的插入操作。其二，前面设计方案论证里提到的关于乘法函数的方法二说到，会使用一个插入函数，实现A中任一项与B中的任一项每乘一次都要把新节点插入到D里面，此函数可作为这种方法编写的乘法函数的重要的一部分。

polynode *Multiply(polynode *A,polynode *B)   //实现两链表的乘法运算
{
    polynode * p,* q,* n,* temp,* m,*r; //定义当前指针p，q风别指向两链表和头指针，及新生成节点n
    int exp;//定义整型指数
    float coef;
    r=(polynode *)malloc(sizeof(polynode));//为最后要得到的乘积链表*r开辟头节点
    r->next=r;
    p=A->next;//当前指针跳过A链表头指向实际运算数
    while(p!=A)//控制操作，循环A链表与内部while所控制B链表进行项之间的运算
    {
    　　temp=(polynode *)malloc(sizeof(polynode));//在内部            创头节点为新生链表准备 即A中每一项与B中各项相乘构            成        一新链表
       temp->next=NULL;//置空链表
       m=temp;//临时变量，为后移指针做准备
       q=B->next;//当前指针跳过B链表头指向实际运算数
       while(q!=B)
       {
            n=(polynode *)malloc(sizeof(polynode)); //建立新节点
            exp=p->exp+q->exp;//进行系数相加操作
            coef=p->coef*q->coef; //进行指数相乘操作
            n->coef=coef;//赋值新节点的系数域
            n->exp=exp; //赋值新节点的指数域
            m->next=n; //链接节点至头结点，构成链表
            m=m->next;//后移指针，为下一节点做准备
            q=q->next;//控制B链表下一项
       }
       p=p->next;   //控制A链表下一项
       m->next=temp;
       Add(r,temp);
    }
    return r; 
}

　　乘法运算的思想在前面的“设计论证模块”里已经详细的说明了，这里就在此解释（其中，由于乘法的复杂性、核心性，为了方便理解，我在上面的代码后加入了必要的注释）。

　　

　　这种思想是两个循环嵌套，先拿p0（即A的第一项）与B中的每个元素相乘，操作过程即两个指针的coef相乘且exp相加，保存在一个polynode类型的循环链表temp里，再把temp加到另一个polynode类型的循环链表r（r一开始为空循环链表）里，把temp置空。再拿p₁x即A的第二项与B的每一项分别相乘重新赋给temp，与B每一项都乘完后再把temp和r相加（用到了多项式链表相加的函数polynode *Add（polynode *a，polynode *b），实现把b链表按升序加入到a链表里面），然后再次置空temp......以此类推，直到A的最后一项p_mx^m与B的每一项全乘完一遍得到的temp再次加到r里面，得到的r即为A与B的乘积。函数返回r，然后在主函数里面打来。

四、详细设计

　　这里我开始介绍主函数的构造。

 

　　以上是主函数前一部分，作用就是功能执行前的声明与定义。这里便不逐个介绍，后面还会提到。

　　接下来是循环-选择部分，也是主函数的核心。首先输入字符‘ch’，为进入循环的switch（ch）部分做选择做准备，以确定切换的不同的功能。而循环使用的是

do

{

.....

}while     的循环结构。循环里面是一个完整的switch—case‘...’选择结构 ，意图实现选择功能，case里面就是字符‘ch’对应的不同的功能。

　　Ch=‘1’时，先逐次建立两个多项式链表，第一个是ha，第二个是hb，建立完后立刻输出（Output函数）刚刚建立的多项式，以确定是否正确。然后执行Add（ha，hb）加法函数，结果返回给ha，并输出。

　　Ch=‘2’时，先逐次建立两个多项式链表，第一个是ha，第二个是hb，建立完后立刻输出（Output函数）刚刚建立的多项式，以确定是否正确。然后执行Del（ha，hb）减法函数，结果返回给ha，并输出。

　　Ch=‘3’时，只需要建立一个多项式链表ha并输出，接着输出(Output())把ha求导（Differential(ha)）得到的多项式。

　　Ch=‘4’时，先逐次建立两个多项式链表，第一个是ha，第二个是hb，建立完后立刻输出（Output函数）刚刚建立的多项式，以确定是否正确。然后执行Multiply（ha，hb）乘法函数，结果返回给hc，并输出hc。

　　Ch=‘5’时，先建立ha并输出，然后建立要插入ha里面的单节点hc，对它的系数、指数赋值，通过函数Insert（hc，ha）实现按幂值递增顺序插入ha并且返回值赋给ha，然后打印。

　　Ch=‘6’时，先建立ha并输出，然后输入用于计算的底数，赋给x，通过Getvalue（ha，x）返回求得的数值，在printf（）函数里面直接打印出来。

`　　Ch=‘7’时，先建立ha并输出，然后带入BDJF(ha)求ha的不定积分并且赋给hb，并输出。

　　Ch=‘8’时，先建立ha并输出，然后输入定积分的下界m和上界n，代入djf（ha，m，n）求出定积分，包含在printf（）里面输出。

　　当输入ch=‘9’时结束程序。Switch-case选择结束之后，为了给下一次循环作出判断，需要再输入ch字符，而循环是否继续的条件就是判断本次输入的ch是否等于‘9’。

五、测试结果

界面

加法

减法

乘法

 求导

 

插入一项

求具体值

求不定积分

求定积分

六、程序流程图

七、源代码

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<malloc.h>
#include<math.h>
typedef struct pnode           //数据结构
{
    float coef;                           //系数项
    int exp;                               //指数项
    struct pnode *next;
}polynode;
polynode *Creat()                //创建多项式
{
    float coef;
    int exp;
    polynode *head,*s,*r;
    head=(polynode*)malloc(sizeof(polynode));
    head->coef=0;                   //初始化
    head->exp=-1;
    r=head;
    printf("
  请输入各项的系数和指数（如 1  2），均为0时结束输入
");
    while(1)
    {
        printf("coef  exp:");
        scanf("%f %d",&coef,&exp);
        if(coef!=0)
        {
                s=(polynode*)malloc(sizeof(polynode));
                s->coef=coef;
                s->exp=exp;
                r->next=s;
                r=s;
        }
        else break;
    }
    r->next=head;         //循环链表 首尾相连
    return head;
}
polynode *Add(polynode *pa,polynode *pb)   //多项式相加运算函数
{
    polynode *p,*q,*r,*s;
    float x;
    p=pa->next;
    q=pb->next;
    s=pa;
    while((p!=pa)&&(q!=pb))
    {
        if(p->exp<q->exp)
        {
            s=p;
            p=p->next;
        }
       if(p->exp>q->exp)
       {
           r=q->next;
           q->next=p;
           s->next=q;
           s=q;
           q=r;
       }
       else
       {
           x=p->coef+q->coef;
           if(x!=0)
           {
               p->coef=x;
               s=p;
           }
           else
           {
               s->next=p->next;
               free(p);
           }
           p=s->next;
           r=q;
           q=q->next;
           free(r);
       }
    }
    if(q!=pb)
    {
        r=q;
        while(r->next!=pb)
            r=r->next;
        s->next=q;
        r->next=pa;
    }
    return pa;
}
polynode *Del(polynode *pa,polynode *pb)   //多项式减法运算函数
{
    polynode *p,*q,*r,*s;
    float x;
    p=pa->next;
    q=pb->next;
    s=pa;
    while((p!=pa)&&(q!=pb))
    {
        if(p->exp<q->exp)
        {
            s=p;
            p=p->next;
        }
       if(p->exp>q->exp)
       {
           q->coef=-(q->coef);
           r=q->next;
           q->next=p;
           s->next=q;
           s=q;
           q=r;
       }
       else
       {
           x=p->coef-q->coef;
           if(x!=0)
           {
               p->coef=x;
               s=p;
           }
           else
           {
               s->next=p->next;
               free(p);
           }
           p=s->next;
           r=q;
           q=q->next;
           free(r);
       }
    }
    if(q!=pb)
    {
        r=q;
        q->coef=-(q->coef);
        while(r->next!=pb)
        {
            r=r->next;
             r->coef=-(r->coef);
        }
        s->next=q;
        r->next=pa;
    }
    return pa;
}
polynode *BDJF(polynode *head)         //求不定积分函数
{
    polynode *p=head;
    p=p->next;
    while(p!=head)
    {
        p->coef=(p->coef)/(p->exp+1);
        p->exp+=1;
        p=p->next;
    }
    return head;
}
int djf(polynode *head,int low,int high)     //求定积分函数
{
    int d;
    head=BDJF(head);
    d=Getvalue(head,high)-Getvalue(head,low);
    return d;
}
polynode *Multiply(polynode *A,polynode *B)   //实现两链表的乘法运算
{
    polynode * p,* q,* n,* temp,* m,*r;              //定义当前指针p，q风别指向两链表和头指针，尾指针，及新生成节点n
    int exp;                                     //定义整型指数
    float coef;
    r=(polynode *)malloc(sizeof(polynode));  //为最后要得到的乘积链表*r开辟头节点
    r->next=r;                //体现循环链表的操作
    p=A->next;              //当前指针跳过A链表头指向实际运算数
    while(p!=A)           //控制操作，循环A链表与内部while所控制B链表进行项之间的运算
    {
       temp=(polynode *)malloc(sizeof(polynode));   //在内部创头节点为新生链表准备 即A中每一项与B中各项相乘构成一新链表
       temp->next=NULL;                //置空链表
       m=temp;                //临时变量，为后移指针做准备
        q=B->next;         //当前指针跳过B链表头指向实际运算数
        while(q!=B)
        {
            n=(polynode *)malloc(sizeof(polynode)); //建立新节点
            exp=p->exp+q->exp;       //进行系数相加操作
            coef=p->coef*q->coef;    // //进行指数相乘操作
            n->coef=coef;         //赋值新节点的系数域
            n->exp=exp;           //赋值新节点的指数域
            m->next=n;           //链接节点至头结点，构成链表
            m=m->next;         //后移指针，为下一节点做准备
            q=q->next;         //控制B链表下一项
        }
        p=p->next;              //控制A链表下一项
        m->next=temp;
        Add(r,temp);
    }
    return r;
}
int Getvalue(polynode *head,int x)                                           //求多项式值的函数
{
    int flag=0;
    polynode *t=head->next;
    while(t!=head)
    {
        flag+=t->coef*(pow(x,t->exp));
        t=t->next;
    }
    return flag;
}
void Output(polynode *head)                                                          //输出多项式
{
    polynode *p;
    p=head->next;
    printf("%.1fX^%d",p->coef,p->exp);
    while(p!=head)
    {
         p=p->next;
         if(p!=head)
            if(p->coef>0) printf("+%.1fX^%d",p->coef,p->exp);   //输出各项的稀疏和指数
            else printf("%.1fX^%d",p->coef,p->exp);
         else break;
    }
    printf("
");
}
polynode *Differential(polynode *L)                                               //求导函数
{
    polynode *p,*q,*pt;
    q=L;
    p=L->next;
    while(p!=L)
    {
        if(p->exp==0)
        {
            pt=p;
            p=p->next;
            q->next=p;
            free(pt);
        }
        else
        {
            p->coef=p->coef*p->exp;
            p->exp--;
            q=p;
            p=p->next;
        }
    }
    return L;
}
polynode  *Insert(polynode *A,polynode *B)  //实现在B链表中按顺序插入单个结点A
{
    polynode *q1,*q2;
    q1=B;
    q2=B->next;
    while(q2&&A->exp>q2->exp)  //查找插入位置
    {
        q1=q2;
        q2=q2->next;
    }
    if(q2&&A->exp==q2->exp)   //将指数相同项合并
    {
        q2->exp+=A->exp;
        free(A);
        if(!q2->coef)         //若系数相加和为0则释放节点
        {
            q1->next=q2->next;
            free(q2);
        }
    }
    else                     //指数为新则插入新节点，改变前后连接逻辑
    {
        A->next=q2;
        q1->next=A;
    }
    return B;
}
int main()
{
    char ch;
    int x;
    int m,n;
    polynode *ha,*hb,*hc;
    printf("**********************************************欢迎来到多项式运算程序！！！**********************************************
");
    printf("*********************************************************菜单***********************************************************
");
    printf("
输入字符1：实现两个多项式相加，并输出");
    printf("
输入字符2：实现两个多项式相减，并输出");
    printf("
输入字符3：实现一个多项式的求导，并输出");
    printf("
输入字符4：实现两个多项式相乘，并输出");
    printf("
输入字符5：实现单个节点插入另一个多项式，并输出");
    printf("
输入字符6：实现输入一个底数x，求一个确定的多项式值");
    printf("
输入字符7：求一个多项式的不定积分");
    printf("
输入字符8：自己定义上、下界，求一个多项式的定积分
");
    ch=getche();
    do
    {
        switch(ch)                           //选择开关，循环使用，键‘9’结束程序
        {
            case '1':
                printf("
您选择的是 加法运算：	依次建立多项式A和B：
");
                ha=Creat();
                Output(ha);
                hb=Creat();
                Output(hb);
                ha=Add(ha,hb);
                printf("多项式A+多项式B（即现在的多项式A）：
");
                Output(ha);
                break;
            case '2':
                 printf("
您选择的是 减法运算：	依次建立多项式A和B：
");
                ha=Creat();
                Output(ha);
                hb=Creat();
                Output(hb);
                ha=Del(ha,hb);
                printf("多项式A-多项式B（即现在的多项式A）：
");
                Output(ha);
                break;
            case '3':
                 printf("
您选择的是 求导运算：	建立多项式A：
");
                ha=Creat();
                Output(ha);
                printf("求导得到的多项式为：
");
                Output(Differential(ha));
                break;
            case '4':
                 printf("
您选择的是 乘法运算：	依次建立多项式A和B：
");
                ha=Creat();
                Output(ha);
                hb=Creat();
                Output(hb);
                hc=Multiply(ha,hb);
                printf("
多项式A * 多项式B=
");
                Output(hc);
                break;
            case '5':
                printf("
建立待插入的多项式A：
");
                ha=Creat();
                Output(ha);
                hc=(polynode*)malloc(sizeof(polynode));
                scanf("%f %d",&hc->coef,&hc->exp);
                ha=Insert(hc,ha);
                printf("插入以后的多项式为：");
                Output(ha);
                break;
            case '6':
                printf("
您选择的是赋值计算	建立多项式ha：
");
                ha=Creat();
                Output(ha);
                printf("请确定底数x的值(要求x是自然数)：	");
                scanf("%d",&x);
                printf("
把x=%d带入ha多项式中得到其值为：%d
",x,Getvalue(ha,x));
                break;
            case '7':
                 printf("
您选择的是 求不定积分运算：	建立多项式A：
");
                ha=Creat();
                Output(ha);
                printf("取得的不定积分是：
");
                hb=BDJF(ha);
                Output(hb);
                break;
            case '8':
                printf("
您选择的是 求定积分运算：	建立多项式A：
");
                ha=Creat();
                Output(ha);
                printf("分别输入下界m和上界n：	");
                scanf("%d%d",&m,&n);
                printf("取得的定积分是：	%d
",djf(ha,m,n));
                break;
            default: printf("请输入有效字符！
");
        }
        ch=getche();
        printf("
");
    }
    while(ch!='9');
    return 0;
}