单链表实现的多项式加减法计算，输入的负号变成了正号，并且幂为负时显示错误，这个程序应该怎么改？

Question

//vc6.0实现的C++版![图片说明](https://img-ask.csdn.net/upload/201907/23/1563861033_43306.png)![图片说明](https://img-ask.csdn.net/upload/201907/23/1563861045_50819.png)


//功能：多项式的加减法操作
#include <iostream.h>//读入必须包含的头文件
#include <windows.h>//清屏和颜色设置需要
#include <string.h>
#include <fstream.h>
#include <iomanip.h>
#include <math.h>//处理方幂运算

enum returninfo{success,wrong,fail,overflow,underflow,empty_error};//定义返回信息清单
const int Maxsize=26;//系统允许多项式的最大值
const int Number=40;//设置输入多项式时字符串长度最大限，也可以根据需求任意设置
int order;//设置多项式显示方式0代表降幂显示，1代表升幂显示

class node//定义一个node类，处理多项式中的<项>：如3x^(-2)、4x^3、6x或者常数5等等
{
public:
    node(int initcoeff,int initindex,node *initnext=NULL);//系数、指数、后继结点
    node(node *initnext=NULL);//后继结点函数重载：用于头结点
    ~node();

    int coeff;//系数
    int index;//指数
    node *next;
};

node::node(int initcoeff,int initindex,node *initnext)
{
    coeff=initcoeff;
    index=initindex;
    next=initnext;
}

node::node(node *initnext)
{
    next=initnext;
}

node::~node()
{
}

/*
定义一个线性表类linklist
*/
class linklist
{
public:
    linklist();//构造函数
    ~linklist();//析构函数
    void clearlist(void);//清除多项式
    bool empty(void) const;//判断是否空链
    node *headp;//多项式头结点
};

linklist::linklist()//构造函数
{
    headp = new node;//申请新结点，作为头结点
    headp->next=NULL;//头结点的地址域预设为空地址
}

linklist::~linklist()//析构函数
{
    clearlist();//删除所有数据，释放所有结点
    delete headp;//把头结点也释放掉
}

void linklist::clearlist(void)//清除多项式
{
    node *searchp=headp->next,*followp=headp;//初始化两个指针
    while(searchp!=NULL)
    {
        followp=searchp;
        searchp=searchp->next;
        delete followp;
    }
    headp->next=NULL;//保留了最后一个结点，就是头结点，并且链域置为空
}

bool linklist::empty(void) const//判断是否空链
{
    if(headp->next==NULL)
        return true;
    else
        return false;
}

/*
实现多项式加减法的类sequelist
*/
class sequelist//管理多项式
{
public:
    sequelist();
    ~sequelist();
    returninfo inputdata(void);//从键盘输入多项式
    returninfo deletdata(void);//清空多项式信息
    returninfo calculate(void);//赋值计算
    void addnode(int site,int icoeff,int iindex);//增加项
    void display(char name);//显示某个多项式
    void displayname(void);//显示系统中现存多项式的名称
    void traveral(void);//遍历所有多项式
    void deletepart(char idata);//清除单个多项式信息
    void deletcomp(void);//清除全部多项式信息
    bool findlist(char idata);//查找多项式（提供多项式名称）
    bool scanname(char idata);//判断多项式的名称是否合法
    bool read();//读文件操作
    bool write();//写文件操作
protected:
    linklist list[Maxsize];
};

sequelist::sequelist()
{
}

sequelist::~sequelist()
{
}

returninfo sequelist::deletdata(void)//清空多项式信息
{
    int choice,site;
    char ch,name;
    cout<<"1.清空系统全部多项式信息"<<endl;
    cout<<"2.清除某个指定多项式信息"<<endl;
    cout<<"3.退出清除信息"<<endl;
    cout<<"请选择：";
    cin>>choice;
    if(choice==1||choice==2)
    {
        if(choice==1)
        {
            traveral();
            cout<<endl<<"请问：您确定要清空全部多项式信息吗？(Y/y)：";
            cin>>ch;
            if(ch=='Y'||ch=='y')
                deletcomp();
            else
                return fail;
        }
        else
        {
            cout<<"请输入你要清空的多项式的名称（提示：一个大写字母）：";
            cin>>name;
            site=int(name-'A');
            if(list[site].empty())
                return wrong;
            display(name);
            cout<<endl<<"请问：您确定要清除该多项式信息吗？(Y/y)：";
            cin>>ch;
            if(ch=='Y'||ch=='y')
                deletepart(name);
            else
                return fail;
        }
        return success;
    }
    else
        return fail;
}

returninfo sequelist::calculate(void)//赋值计算
{
    int site,x,flag=0;
    double result=0,value;
    char name,ch;
    node *searchp;
    cout<<"请输入需要赋值计算的多项式名称（提示：一个大写字母）：";
    cin>>name;
    site=int(name-'A');
    if(list[site].empty())
        return wrong;
    display(name);
    cout<<endl<<"请问：您确认要进行赋值计算吗？(Y/y)：";
    cin>>ch;
    if(ch=='Y'||ch=='y')
    {
        cout<<"请给出变量x的值（如果方幂过大x不宜取大值）：x=";
        cin>>x;
        cout<<endl<<name<<"（"<<x<<"）=";
        searchp=list[site].headp->next;
        while(searchp!=NULL)
        {
            value=searchp->coeff*pow(x,searchp->index);
            result+=value;
            cout<<" ";
            if(value>=0)
            {
                if(flag!=0)
                    cout<<"+";
            }
            cout<<value;
            flag++;
            searchp=searchp->next;
        }
        cout<<endl<<"  ="<<result<<endl<<endl;
    }
    else
        return fail;
    return success; 
}

void sequelist::display(char name)//显示某个多项式
{
    cout<<name<<"(x)=";
    int site;
    site=int(name-'A');
    node *searchp=list[site].headp->next;
    if(searchp->coeff==0)
        cout<<"0";
    else if(searchp->coeff!=1&&searchp->coeff!=-1)
    {
        if(searchp->index==0)
            cout<<searchp->coeff;
        else if(searchp->index==1)
            cout<<searchp->coeff<<"x";
        else if(searchp->index<0)
            cout<<searchp->coeff<<"x^("<<searchp->index<<")";
        else
            cout<<searchp->coeff<<"x^"<<searchp->index;
    }
    else
    {
        if(searchp->index==0)
            cout<<searchp->coeff;
        else if(searchp->index==1)
            cout<<searchp->coeff<<"x";
        else if(searchp->index<0)
            cout<<searchp->coeff<<"x^("<<searchp->index<<")";
        else
            cout<<searchp->coeff<<"x^"<<searchp->index;
    }
    searchp=searchp->next;
    while(searchp!=NULL)
    {
        cout<<" ";
        if(searchp->coeff!=1&&searchp->coeff!=-1)
        {
            if(searchp->index==0)
            {
                if(searchp->coeff>0)
                    cout<<"+";
                cout<<searchp->coeff;
            }
            else if(searchp->index==1)
            {
                if(searchp->coeff>0)
                    cout<<"+";
                cout<<searchp->coeff<<"x";
            }
            else if(searchp->index<0)
            {
                if(searchp->coeff>0)
                    cout<<"+";
                cout<<searchp->coeff<<"x^("<<searchp->index<<")";
            }
            else
            {
                if(searchp->coeff>0)
                    cout<<"+";
                cout<<searchp->coeff<<"x^"<<searchp->index;
            }
        }
        else if(searchp->coeff==1)
        {
            if(searchp->index==0)
                cout<<"+1";
            else if(searchp->index==1)
                cout<<"+x";
            else if(searchp->index<0)
                cout<<"+x^("<<searchp->index<<")";
            else
                cout<<"+x^"<<searchp->index;
        }
        else
        {
            if(searchp->index==0)
                cout<<"-1";
            else if(searchp->index==1)
                cout<<"-x";
            else if(searchp->index<0)
                cout<<"-x^("<<searchp->index<<")";
            else
                cout<<"-x^"<<searchp->index;
        }
        searchp=searchp->next;
    }
    cout<<endl;
}

void sequelist::deletcomp(void)//清除全部多项式信息
{
    int i;
    char name;
    for(i=0;i<Maxsize;i++)
    {
        name=char(i+'A');
        deletepart(name);
    }
}

void sequelist::deletepart(char idata)//清除单个多项式信息
{
    int site;
    site=int(idata-'A');
    node *searchp=list[site].headp->next,*followp;
    while(searchp!=NULL)
    {
        followp=searchp;
        searchp=searchp->next;
        delete followp;
    }
    list[site].headp->next=NULL;
}

returninfo sequelist::inputdata(void)//从键盘输入多项式（重点，难点，关键）
{
    char iname,idata[Number];
    node *searchp,*followp;
    int flag=0;//标志项系数正负(flag==1表示负，flag==0表示正)A=3x^(-2)+4x^3-6x^(-3)+5
    cout<<"请输入你要新建多项式的名称（提示：一个大写字母）：";
    cin>>iname;
    if(scanname(iname))//名称通过检验
    {
        int site,icoeff=0,iindex=0,i=0,j=0,k=0;
        char data[20][20];//将输入的数据分项处理分成20块长度为20的项
        site=int(iname-'A');
        cout<<"请连续输入多项式不要有空格："<<endl<<iname<<"(x)=";
        cin>>idata;
        //首先将第一项分开来处理
        data[k][i]=idata[i];
        while(idata[++i]!='+'&&idata[i]!='-'&&idata[i]!='\0')
            data[k][++j]=idata[i];
        data[k][++j]='\n';//项的最后一位以'\n'结束
        k++;//将项数加1，
        //从第二项开始往后的各项处理
        for(;idata[i]!='\0';)
        {
            j=0;//j还原为0
            data[k][0]=idata[i];//记录每一项的符号位
            while(idata[++i]!='+'&&idata[i]!='-'&&idata[i]!='\0')
            {
                data[k][++j]=idata[i];
                if(idata[++i]=='(')//指数为负的处理
                {
                    data[k][++j]=idata[i];
                    data[k][++j]=idata[++i];//将负号写入
                    i++;
                }
                i--;
            }
            data[k][++j]='\n';//项的最后一位以'\n'结束
            k++;//继续写下一项
        }//注意：此时的k后面会有用！！！
        //得到的data[20][20]为多项式的20个项
        for(i=0;i<k;)//将每一项分为node格式，并将其挂链对应的多项式上面
        {
            icoeff=0;
            iindex=0;
            j=0;
            if(data[i][0]=='-')//如果为负
            {
                flag=1;
                j++;
            }
            else if(data[i][0]=='+')//如果为正
            {
                flag=0;
                j++;
            }
            else
                flag=0;//这个是针对多项式的第一项为正的情况考虑的
            //项系数的确定
            while(data[i][j]>='0'&&data[i][j]<='9')
            {
                icoeff=icoeff*10+int(data[i][j]-'0');
                j++;
            }
            if(icoeff==0)
                icoeff=1;
            if(icoeff==1)
                icoeff=0-icoeff;//如果系数为负，则加上负号
            switch(data[i][j])//将data[i][j]分路：
            {
            case 'x'://此项为含x的项
                if(data[i][++j]=='\n')//指数为1的情况
                    iindex=1;
                else
                {
                    if(data[i][j]=='^')//后面紧接着是指数的情况（正和负）
                    {
                        if(data[i][++j]=='(')//指数为负的情况
                        {
                            j++;//跳过负号
                            while(data[i][++j]>='0'&&data[i][j]<='9')
                                iindex=iindex*10+int(data[i][j]-'0');
                            iindex=0-iindex;
                        }
                        else//指数为正的情况
                        {
                            j--;
                            while(data[i][++j]>='0'&&data[i][j]<='9')
                                iindex=iindex*10+int(data[i][j]-'0');
                        }
                    }
                    else
                    {
                        deletepart(iname);//清空现场再返回错误信息
                        return wrong;
                    }
                }
                //将项插入多项式中
                addnode(site,icoeff,iindex);
                break;
            case '\n'://此项为常数项
                iindex=0;
                addnode(site,icoeff,iindex);
                break;
            default://此项涉及到前面的多项式，如4A,5B,A*B等等
                int site1,site2;
                site1=int(data[i][j]-'A');
                if(site==site1||list[site1].empty())//如果为空
                {
                    deletepart(iname);//清空现场再返回错误信息
                    return wrong;
                }
                node *searchp1=list[site1].headp->next;
                if(data[i][++j]=='\n')//如4A,5B
                {
                    while(searchp1!=NULL)
                    {
                        addnode(site,(searchp1->coeff)*icoeff,searchp1->index);
                        searchp1=searchp1->next;
                    }
                }
                else if(data[i][j]=='*')//如3A*B等等
                {
                    site2=int(data[i][++j]-'A');
                    if(site==site2||data[i][++j]!='\n')
                    {
                        deletepart(iname);//清空现场再返回错误信息
                        return wrong;
                    }
                    if(list[site2].empty())//如果为空
                    {
                        deletepart(iname);//清空现场再返回错误信息
                        return empty_error;
                    }
                    node *searchp2=list[site2].headp->next;
                    while(searchp2!=NULL)
                    {
                        searchp1=list[site1].headp->next;
                        while(searchp1!=NULL)
                        {
                            addnode(site,(searchp1->coeff)*icoeff*(searchp2->coeff),(searchp1->index)+(searchp2->index));
                            searchp1=searchp1->next;
                        }
                        searchp2=searchp2->next;
                    }
                }
                else
                {
                    deletepart(iname);//清空现场再返回错误信息
                    return wrong;
                }
                break;
            }
            i++;
        }
        //到现在为止，多项式已经创建成功，下面进行系数项为0的清除工作
        followp=list[site].headp;
        searchp=list[site].headp->next;
        while(searchp!=NULL)
        {
            if(searchp->coeff==0)//系数项为0的清除
            {
                followp->next=searchp->next;
                delete searchp;
                searchp=followp;
            }
            followp=searchp;
            searchp=searchp->next;
        }
        if(list[site].headp->next==NULL)//多项式为0的情况
        {
            searchp=new node(0,0);//附加一个0项
            list[site].headp->next=searchp;
            searchp->next=NULL;
        }
        cout<<endl<<"新建多项式信息整理后如下："<<endl;
        display(iname);//多项式显示
        return success;
    }
    return fail;
}
void sequelist::displayname(void)//显示系统中现存多项式的名称
{
    int j=0;
    cout<<"系统当前存在多项式的名称有："<<endl;
    for(int i=0;i<Maxsize;i++)
    {
        if(!list[i].empty())
        {
            cout<<setw(4)<<char(i+'A');
            j++;
            if((j+1)%8==0)//每行显示7个多项式名称
                cout<<endl;
        }
    }
    cout<<endl<<"◇◇共"<<j<<"个多项式信息！"<<endl<<endl;
}

void sequelist::addnode(int site,int icoeff,int iindex)//增加项
{
    node *newnode,*searchp,*followp;
    if(list[site].empty())//如果为空
    {
        newnode= new node(icoeff,iindex);
        list[site].headp->next=newnode;
        newnode->next=NULL;
    }
    else
    {
        followp=list[site].headp;
        searchp=list[site].headp->next;
        if(order==1)//降序显示
        {
            while(searchp!=NULL&&searchp->index>iindex)
            {
                followp=searchp;
                searchp=searchp->next;
            }
        }
        else//升序显示
        {
            while(searchp!=NULL&&searchp->index>iindex)
            {
                followp=searchp;
                searchp=searchp->next;
            }
        }
        if(searchp!=NULL&&searchp->index==iindex)
        {
            searchp->coeff+=icoeff;//同类项合并
        }
        else//非同类项则按序插入
        {
            newnode=new node(icoeff,iindex);
            newnode->next=searchp;
            followp->next=newnode;
        }
    }
}

void sequelist::traveral(void)//遍历所有多项式
{
    int j=0;
    for(int i=0;i<Maxsize;i++)
    {
        if(!list[i].empty())
        {
            display(char(i+'A'));
            j++;
        }
    }
    cout<<"系统中现有多项式个数为："<<j<<endl;
}

bool sequelist::findlist(char idata)//查找多项式（提供多项式名称）
{
    int site;
    site=int(idata-'A');
    if(list[site].empty())
        return false;
    else
    {
        display(idata);
        return true;
    }
}

bool sequelist::scanname(char idata)//判断多项式的名称是否合法
{
    if(idata>='A'&&idata<='Z')
    {
        int site;
        site=int(idata-'A');
        if(!list[site].empty())
        {
            cout<<"对不起，多项式"<<idata<<"已经存在！"<<endl;
            display(idata);
            return false;
        }
        else
        {
            cout<<"恭喜！多项式名称通过检验！请继续..."<<endl;
            return true;
        }
    }
    cout<<"对不起，您输入的多项式名称格式不正确！"<<endl;
    return false;
}

/*
定义一个实现多项式功能的菜单处理类interfacebase 
*/
class interfacebase
{
private:
    sequelist listonface;
public:
    void clearscreen(void);//清屏
    void showmenu(void);//显示菜单函数
    int userchoice(void);//用户的选项
    returninfo processmenu(int menuchoice);//菜单函数
};

void interfacebase::clearscreen(void)
{
    system("cls");
}

void interfacebase::showmenu(void)
{
    cout<<"单链表实现多项式的功能菜单"<<endl;
    cout<<"=========================="<<endl;
    cout<<"1.输入多项式（从键盘输入）"<<endl;
    cout<<"2.显示多项式（遍历所有多项式）"<<endl;
    cout<<"3.清空多项式信息"<<endl;
    cout<<"4.赋值计算"<<endl;
    cout<<"5.显示某个多项式"<<endl;
    cout<<"6.显示系统中现存多项式的名称"<<endl;
    cout<<"7.查找多项式（提供多项式名称）"<<endl;
    cout<<"0.退出程序"<<endl;
    cout<<"=========================="<<endl;
}

int interfacebase::userchoice(void)
{
    int menuchoice;
    cout<<"请输入您的选择：";
    cin>>menuchoice;
    return menuchoice;
}

returninfo interfacebase::processmenu(int menuchoice)
{
    int position,item,returnvalue;
    char name;
    switch(menuchoice)//根据用户的选择进行相应的操作
    {
    case 1:
        returnvalue=listonface.inputdata();
        if(returnvalue==fail)
            cout<<"对不起，您输入的多项式名称格式不正确！请按任意键继续..."<<endl;
        else if(returnvalue==wrong)
            cout<<"对不起，该项多项式错误（或者为空），已删除！请按任意键继续..."<<endl;
        else if(returnvalue==empty_error)
            cout<<"对不起，该项多项式为空！请按任意键继续..."<<endl;
        else
            cout<<"输入多项式操作成功！请按任意键继续..."<<endl;
        break;
    case 2:
        listonface.traveral();
        cout<<"多项式遍历操作成功！请按任意键继续..."<<endl;
        break;
    case 3:
        returnvalue=listonface.deletdata();
        if(returnvalue==fail)
            cout<<"操作取消！请按任意键继续..."<<endl;
        else if(returnvalue==wrong)
            cout<<"对不起，该项多项式为空！请按任意键继续..."<<endl;
        else
            cout<<"清除操作成功！请按任意键继续..."<<endl;
        break;
    case 4:
        returnvalue=listonface.calculate();
        if(returnvalue==wrong)
            cout<<"对不起，该项多项式为空！请按任意键继续..."<<endl;
        else if(returnvalue==fail)
            cout<<"操作取消！请按任意键继续..."<<endl;
        else
            cout<<"赋值计算操作成功！请按任意键继续..."<<endl;
        break;
    case 5:
        cout<<"请输入要显示的多项式名称：";
        cin>>name;
        listonface.display(name);
        cout<<"显示某个多项式操作成功！请按任意键继续..."<<endl;
        break;
    case 6:
        listonface.displayname();
        cout<<"显示系统中现存多项式的名称操作成功！请按任意键继续..."<<endl;
        break;
    case 7:
        cout<<"请输入要查找的多项式名称：";
        cin>>name;
        listonface.findlist(name);
        if(true)
            cout<<"查找多项式操作成功！请按任意键继续..."<<endl;
        else
            cout<<"该多项式为空（不存在）！请按任意键继续..."<<endl;
        break;
    case 0:
        exit(0);
    default:
        cout<<"对不起，您输入的功能编号有错！请重新输入！！！"<<endl;
        break;
    }
    return success;
}

/*
程序主入口
*/
void main(void)
{
    int menuchoice;//定义变量，菜单选单项的选择
    interfacebase interfacenow;
    sequelist sequelistnow;
    system("color f0");//修改屏幕的背景色和字的颜色
    interfacenow.clearscreen();//清屏
    while(1)//永真循环
    {
        interfacenow.showmenu();//显示菜单
        menuchoice=interfacenow.userchoice();//获取用户的选择
        interfacenow.processmenu(menuchoice);//处理用户的选择
        system("pause");//暂停
        interfacenow.clearscreen();//清屏
    }
}//主函数结束