多项式相加实验代码和报告

一.算法模块分析：
    将整个项目可分为四部分：
        1.将输入字符串链表分析到单链表
        2.单链表化简
        3.链表值运算
        4.输出
二.模块分块实现：
    1.将输入字符串链表分析到单链表
        分析： 
        一元稀疏多项式，包含字符有数字（系数和指数）
        系数中小数点，指数符号，变量字母（以x为例）
        运算符（+和-,其中加减也可以表示正负数）
        通过以上分析可以构建如下结构体以用于存储每个单项
        并完成相应标志任务 
        struct Record{
            double factor;//记录系数 - 
            int power;//记录次方 
            int flt;//记录后面有多少小 数,用复数表示 
            bool flag;//记录正或负 
            Record *next; //指向下一个节点的指针 
        };
        并根据实际运算可将每个节点初始化函数写成如下
        Record *InitRecord()
        {
            Record *nr=new Record();
            nr->power=0;//初始化次方为0 
            nr->factor=1;//初始化系数为1 
            nr->flag=true;//初始化为正数 
            nr->next=NULL;
            nr->flt=0;
            return nr; 
        }
         
        实现算法：
        利用栈，将每个项的数字压入栈中，遇符号判断其作用（加减or正负）
        if 加减作用
            已完成一项的处理工作，通知归纳函数将分析出的数据运算成
            具体系数和指数并建立新节点加入到单链表后面
        if 正负作用
            +不必处理
            -通知标志正负的符号(flag)，使其标志负
        遇到x作为系数运算结束的标志，并用相关变量进行标记
        遇到^作为指数开始计数的标志，并通知power=1标记并记录指数位数 
        遇到.作为小数出现的标志，通知flt=-1,标志记录小数位数 
        
        将分析到栈中的数据进行处理（归纳函数）：
            从栈中依次读出每个数字，先算指数，后算系数。利用幂次方依次
            加一的算法， 并作细节处理；
            处理完毕 即保存到新节点并添加到链表中，此时栈中应已清空
            （系数处理结束的标志） 。 
    2.单链表化简
        先根据链表中各项指数大小进行从小到大排序，其中遇到指数相同的直接相加。
        再做循环，将为零的项删除
    3.链表值运算
        取运算链表A,B;
        先取两者头节点A->next,B->next;
        比较指数大小，若指数同样大小，则运算后赋值到新节点，
        若指数不同，取指数较小的，复制到新节点，并将它添加到结果链表后面
        until  A==NULL or B==NULL
        将剩余链表中未运算的各节点依次添加到结果链表后面，形成结果
    4.输出函数
        输出应该按照输入格式进行输出，保持多项式的完整性和简洁性
        对于系数为正的项（非第一项）应该在它输出之前加上‘+’,遇到负系数直接输出。
        在输出系数后应该输出x(指数大于0)，在指数大于1的x后面应输出^,并输出指数 
三.验证代码功能实现情况 
测试一： 
5x^12+6x^3+x-23x^3+12.6+61x^3+13+21x-11-x^12+0
52x+61-11+73x^3+45.12-112x+34x
多项式1和2最简结果:
加法运算
14.6+22x+44x^3+4x^12
+
95.12-26x+73x^3
=
109.72-4x+117x^3+4x^12
减法运算
14.6+22x+44x^3+4x^12
-
95.12-26x+73x^3
=
-80.52+48x-29x^3+4x^12

测试二： 
5x+3x^2-15+21.45x^21+57.34-12x^2+20x
67x^3+51x-67x+123.456-81x+99x^21+41^2
多项式1和2最简结果:
加法运算
42.34+25x-9x^2+21.45x^21
+
123.456-97x+41x^2+67x^3+99x^21
=
165.796-72x+32x^2+67x^3+120.45x^21
减法运算
42.34+25x-9x^2+21.45x^21
-
123.456-97x+41x^2+67x^3+99x^21
=
-81.116+122x-50x^2-67x^3-77.55x^21 
四。总结
    根据代码运行实例结果分析，其可以正确运算各种符合预定规则的输入。
    代码健壮性良好。代码实现中，做到了不写重复代码的要求，将运算代码
    合为一个。并符合代码模块化规则，将各模块分块实现，并完美的结合在
    一起。 

/*
实现多项式计算 
*/ 
#include<windows.h>
#include<cmath>
#include<iostream>
#include<cstring>
#include<stack>
using namespace std;
struct Record{
    double factor;//记录系数 
    int power;//记录次方 
    int flt;//记录后面有多少小数,用复数表示 
    bool flag;//记录正或者
    Record *next; 
};
Record *InitRecord()
{
    Record *nr=new Record();
    nr->power=0;//初始化次方为0 
    nr->factor=1;//初始化系数为1 
    nr->flag=true;//初始化为正数 
    nr->next=NULL;
    nr->flt=0;
    return nr; 
}
class Polynomial{
    public:
        //初始化链表头，多项式字符串，进行分析 
        Polynomial(char *str=NULL);
        //重载构造函数，直接利用多项式进行给予对象 
        Polynomial(Record *h);
        void Analsis(char* str);//分析多项式 
        void OutputPolynomial(); //按规则输出多项式 
        Record* GetHead(){//得到头节点 
            return head;
        }
    private:
        void RemoveRepeatedAndZero(); 
        //处理栈中存储的数据，将一项处理到节点中 
        void InsertToListTail(Record* node); 
        Record *head;//记录头节点 
        Record *tail;//记录尾节点 
        stack<int> Q;
};
Polynomial::Polynomial(char* str)
{
    head=InitRecord();//初始化头节点 
    tail=head;
    if(str!=NULL)
    Analsis(str);
} 
Polynomial::Polynomial(Record *h)
{
    head=h;
}
void Polynomial::Analsis(char* str)
{
    int n=strlen(str);
    int i=0;
    Record *temp;
    bool flag=false; 
    while(i<n)
    {
        if(!flag){
        temp=InitRecord();
        flag=true;
        }
        switch(str[i])//'-' . + x 
        {
            case '-':{
                if(!Q.empty())
                {
                //已经记录了数据就可以插入了 
                InsertToListTail(temp);
                i--;
                flag=false;
                }
                else
                {
                    temp->flag=!temp->flag;
                } 
                break;
            }
            case '.':{
                temp->flt=-1;
                break;
            }
            case '+':{
                if(!Q.empty())
                {
                //已经记录了数据就可以插入了 
                InsertToListTail(temp);
                flag=false;
                }
                break;
            }
            case ' ':break;
            case '^':{
                temp->power=1;
                break;
            }
            case 'x':{
                temp->power=1;
                if(Q.empty())Q.push(1); 
                break;
            }
            default:{
                if(!(str[i]>='0'&&str[i]<='9'))
                {
                    cout<<"多项式中有其它不可识别字符: "<<str[i];break; 
                }
                //如果此时判断的是小数点后面的数字 
                if(temp->flt&&!temp->power)temp->flt--;
                else if(temp->power)temp->power++;//多一个次方
                Q.push(str[i]-'0');
                break;
            }
        }
            i++;
    }
    this->InsertToListTail(temp);
    this->RemoveRepeatedAndZero();
}
//完成插入到链表后新的数据，同时将factor计算出来 
void Polynomial::InsertToListTail(Record* node)
{
    double fr=0.0;
    int p=0;
    int temp=0;
    int i=0;
    //统计平方值 
    if(node->power>1)//如果power大于1才计算 
    {
    while(--node->power>0)
    {
        temp=Q.top();
        Q.pop();
        p+=temp*powl(10,i++);
    }
    node->power=p;
    }
    if(node->flt==0)node->flt--;
    while(!Q.empty())
    {
        temp=Q.top();
        Q.pop();
        fr+=temp*powl(10,++node->flt);
    }
    node->factor=fr;

    if(node->flag==false)//负数标志 
    {
    node->factor=-node->factor;//使系数变符号 
    }
    if(node->factor!=0){
    tail->next=node;//接入新节点 
    tail=node;}
}
void Polynomial::OutputPolynomial()
{
    Record* p=head;
    if(p->next==NULL){
        cout<<0<<endl;
        return;
    }
    int flag=0;
    while(p->next!=NULL)
    {
        //负数输出是会带有负号，不需要加入或验证 
        p=p->next;
        //如果系数为正，且不是头项，就应该输出‘+’ 
        if(p->factor>0&&flag)cout<<'+';
        flag=1;//标志此时不是输出第一项 
        if(p->factor==-1&&p->power)cout<<'-';
        //如果系数不等于1 或者没有x，就输出系数 
        else if(p->factor!=1||!p->power)
        cout<<p->factor;
        if(p->power)//如果有x就要暑输出 
        cout<<'x'; 
        if(p->power>1)//次方大于1，要输出 
        cout<<'^'<<p->power;
    } 
    cout<<endl;
}
//去掉重复幂方项或者零系数项 
void Polynomial::RemoveRepeatedAndZero()
{
    Record* h,*p,*temp,*pre;
    if(head->next==NULL)return;
    h=head->next->next;
    p=head->next;
    pre=head; 
    int flag=true;
    while(flag)
    {
        flag=false;
        while(p!=NULL&&h!=NULL)
        {
            if(p->power==h->power)
            {
                p->factor+=h->factor;
                p->next=h->next;
                temp=h;
                h=h->next;
                delete temp;
                flag=true; 
                continue;
            }
            if(p->power>h->power)
            {
                temp=h;
                p->next=temp->next;
                temp->next=p;
                pre->next=temp;
                p=pre->next;
                h=p->next;
                flag=true;
                continue;
            }
            h=h->next;
            pre=pre->next;
            p=p->next;
        }
        if(p!=NULL)
        p->next=NULL;
        h=head->next->next;
        p=head->next;
        pre=head;
    }
    p=head->next;
    pre=head;
    while(p!=NULL)//去除系数为零的项 
    {
        if(p->factor==0)
        {
            temp=p;
            p=p->next;
            pre->next=p;
            delete temp;
        }
        if(p!=NULL){
        p=p->next;
        pre=pre->next;}    
    }
    pre->next=NULL;
}
//将一个节点复制到一个新空间 
Record* CopyTo(Record* h)
{
    Record* nd=InitRecord();
    nd->factor=h->factor;
    nd->flag=h->flag;
    nd->flt=h->flt;
    nd->next=NULL;
    nd->power=h->power;
    return nd; 
}
//多项式相加过程 
Record* PolyAdd(Record* a,Record *b,int flag)//flag=1=>+else-
{
    Record* result=InitRecord();
    Record* p=result;
    Record* temp;
    a=a->next;
    b=b->next;
    while(a!=NULL&&b!=NULL)
    {
        
         if(a->power<b->power)
         {
             temp=CopyTo(a);
             a=a->next;
         }
         else if(b->power<a->power)
         {
             temp=CopyTo(b);
            if(!flag)temp->factor*=-1;
             b=b->next;
         }
         else{
             temp=CopyTo(a);
            if(flag)
             temp->factor+=b->factor;
            else
                temp->factor-=b->factor;
             b=b->next;
             a=a->next;
         }
         p->next=temp;
         p=temp;
    }
    if(!a)a=b;
    while(a!=NULL)
    {
        p->next=CopyTo(a);
        p=p->next;
        a=a->next;
    }
    p->next=NULL;
    return result;
}
int main()
{
    char str[50];
    char st2[50];
    Record *p,*q,*re,*m;
    cin>>str;
    cin>>st2;
    Polynomial exp(str);
    Polynomial e2(st2);
    p=exp.GetHead();
    q=e2.GetHead(); 
    re=PolyAdd(p,q,1);
    Polynomial res(re);
    cout<<"多项式1和2最简结果:
" ;
    cout<<"加法运算"<<endl;
    exp.OutputPolynomial();
    cout<<'+'<<endl; 
    e2.OutputPolynomial();
    cout<<'='<<endl;
    res.OutputPolynomial();

    m=PolyAdd(p,q,0);
    cout<<"减法运算"<<endl;
    Polynomial minus(m);
    exp.OutputPolynomial();
    cout<<'-'<<endl; 
    e2.OutputPolynomial();
    cout<<'='<<endl;
    minus.OutputPolynomial();
    system("pause");
    return 0;
}
/*
5x^12+6x^3+x-23x^3+12.6+61x^3+13+21x-11-x^12+0
2+x+5+x^2+2x
4x+6+x^3+3x^2
13+7x+4x^2+x^3
7+3x+x^2
6+4x+3x^2+x^3
*/
/*
5x^12+6x^3+x-23x^3+12.6+61x^3+13+21x-11-x^12+0 
52x+61-11+73x^3+45.12-112x+34x
131.12+108x+140x^3+5x^12
25+22x+67x^3+5x^12
106.12+86x+73x^3
*/