一元多项式计算器（数据结构实验）

实验目的

1. 掌握顺序表和单链表的存储特点及插入、删除等算法。
2. 灵活运用顺序表和单链表的相关算法实现一元多项式的计算。

实验内容

设有一元多项式Am(x)和Bn(X)，编程实现多项式Am(x)和Bn(x)的加法、减法和乘法运算。其中多项式描述为：

Am(x)=A0+A1x1+A2x2+A3x3+….+Amxm；

Bn(x)=B0+B1x1+B2x2+B3x3+….+Bnxn。

实验说明

1. 输入和输出：
   1. 输入
      • 从键盘输入运算指令（相加、相减、相乘），根据运算指令进行相应运算；
      • 从键盘输入两个多项式的系数和指数；
      • 系数和指数采用int类型，运算结果不超出int取值范围。
   2. 输出
      • 每种运算结果以多项式形式输出，要输出升幂和降幂两种情况。
      • 结果多项式中无重复阶项、无零系数项，输出多项式时请采用如下易读形式（一元多项式，总变元为x）：　x^4 - 3 x^2 + 5
2. 实验要求：

• 实现一个简单的交互式界面，包括系统菜单、输入提示等。
• 多项式运算前首先判定多项式特点，根据多项式是否稀疏来选用合适的存储结构；
• 根据多项式不同的运算要求选择合适的存储结构；
• 上机编辑、调试出完整正确的程序，包括相加、相减、相乘运算。

测试结果

实现代码

采用链表实现。

/*
 * File name：main.cpp
 * Version：V1.0
 * Description：一元多项式计算器
 * Others：无
 * Log：2021/5/16
 */
#include 

using namespace std;

//创建了多项式结构体，包含系数和指数信息
typedef struct polynomial
{
     
    float Coef; //系数
    int Index;   //指数
    struct polynomial *next;
} polynomial;

//功能函数声明
void CreatePolyn(polynomial **p, int m);
void AddPolyn(polynomial **pa, polynomial **pb);
void SubtractPolyn(polynomial **pa, polynomial **pb);
void MultiplyPolyn(polynomial **pa, polynomial **pb);
void CopyPolyn(polynomial **pa, polynomial *pb);
void MultiplyOperate(polynomial *pa, polynomial *pb);
void PrintPolyn(polynomial *p);

/*
 * @Description : 主函数
 * @param       : 无
 * @return        : 无
 */
int main()
{
     
    //65001 是UTF-8代码页，防止出现中文乱码（看个人编译器情况）
    //system("chcp 65001 > nul");

    polynomial *pa, *pb;    //定义两个结构体指针
    int n,m;                //用来存放多项式的项数
    int choose;             //选择加减乘
    int Flag = 1;
    while (1) {
     
        if (Flag == 1) {
     
            cout << "***************** 一元多项式计算器 *****************" << endl;
            cout << "***** 本计算器只能计算两项一元多项式计算，请规范操作 *****" << endl;
            cout << "请输入第一个多项式的项数: ";
            cin >> n;
            CreatePolyn(&pa, n);
            cout << endl;
            cout << "请输入第二个多项式的项数 :";
            cin >> m;
            CreatePolyn(&pb, m);
            cout << endl;


            cout << "********************************" << endl;
            cout << "本计算器可以进行的计算方式:" << endl;
            cout << "1.相加" << endl;
            cout << "2.相减" << endl;
            cout << "3.相乘" << endl;
            cout << "********************************" << endl;
            cout << endl;
            cout << "请选择计算方式:";
            cin >> choose;

            if (choose == 1) {
     
                AddPolyn(&pa, &pb);         //加法
            } else if (choose == 2) {
     
                SubtractPolyn(&pa, &pb);    //减法
            } else {
     
                MultiplyPolyn(&pa, &pb);    //乘法
            }


            cout << "结果如下: " << endl;
            PrintPolyn(pa);
            cout << endl;
        } else {
     

            cout << "**********************************" << endl;
            cout << "           谢谢使用本系统!            " << endl;
            cout << "**********************************" << endl;
            return 0;
        }

        cout << endl;
        cout << "**********************************" << endl;
        cout << "           是否继续使用？            " << endl;
        cout << "1.是" << endl;
        cout << "2.否" << endl;
        cout << "**********************************" << endl;
        cin >> Flag;
    }
}

/*
 * @Description : 创建链表
 * @param **p   : 多项式结构体指针地址
 * @param m     : 多项式项数
 * @return        : 无
 */
void CreatePolyn(polynomial **p, int m)
{
     
    int i, data;
    polynomial *cp, *temp;
    (*p) = (polynomial *)malloc(sizeof(polynomial));
    (*p)->Coef = 0.0;
    (*p)->Index = -1;
    (*p)->next = NULL;
    for(i=1; i<=m; ++i){
     
        cp = *p;        //初始位置
        temp = (polynomial *)malloc(sizeof(polynomial));
        cout << "请输入第" << i << "项的系数: ";
        cin >> temp->Coef;
        cout << "请输入第" << i << "项的指数: ";
        cin >> temp->Index;

        while(cp->next && temp->Index > cp->next->Index)
        {
     
            cp = cp->next;
        }
        if(cp->next && temp->Index == cp->next->Index){
          // 如果已经存在相同指数的多项式，跳出循环
            continue;
        }
        temp->next = cp->next;
        cp->next = temp;
    }
}


/*
 * @Description : 加法,加法本质上就是合并链表
 * @param **pa  : 多项式一结构体指针地址
 * @param **pb  : 多项式二结构体指针地址
 * @return        : 无
 */
void AddPolyn(polynomial **pa, polynomial **pb)
{
     
    polynomial *cpa, *cpb, *temp, *ccpa, *p = (*pa);
    cpa = (*pa)->next;
    cpb = (*pb)->next;
    while(cpa && cpb)       //对每一项进行比较
    {
     
        if(cpa->Index < cpb->Index)
        {
     
            p->next = cpa;
            p = cpa;
            cpa = cpa->next;
        }
        else if(cpa->Index > cpb->Index)
        {
     
            p->next = cpb;
            p = cpb;
            cpb = cpb->next;
        }
        else
        {
     
            if(cpa->Coef + cpb->Coef == 0)
            {
     
                cpa = cpa->next;
                cpb = cpb->next;

            }
            else
            {
     
                cpa->Coef += cpb->Coef;
                p->next = cpa;
                p = cpa;
                cpa = cpa->next;
                cpb = cpb->next;
            }
        }
    }
    if(cpa)
        p->next = cpa;
    else
        p->next = cpb;
    free(*pb);          //*pb已经为空，释放空间
}

/*
 * @Description : 减法
 * @param **pa  : 多项式一结构体指针地址
 * @param **pb     : 多项式二结构体指针地址
 * @return        : 无
 */
void SubtractPolyn(polynomial **pa, polynomial **pb)
{
     
    polynomial *cpa, *cpb, *temp, *ccpa, *p = (*pa);
    cpa = (*pa)->next;
    cpb = (*pb)->next;
    while(cpa && cpb)   //对每一项进行比较
    {
     
        if(cpa->Index < cpb->Index)
        {
     
            p->next = cpa;
            p = cpa;
            cpa = cpa->next;
        }
        else if(cpa->Index > cpb->Index)
        {
     
            p->next = cpb;
            p = cpb;
            p->Coef *= -1;  // 此时结果为负数，需改变符号
            cpb = cpb->next;
        }
        else                //  此时指数相等
        {
     
            if(cpa->Coef == cpb->Coef)  //如果两项系数相等，删除该节点
            {
     
                cpa = cpa->next;
                cpb = cpb->next;

            }
            else
            {
     
                cpa->Coef -= cpb->Coef;
                p->next = cpa;
                p = cpa;
                cpa = cpa->next;
                cpb = cpb->next;
            }
        }
    }

    if(cpa) {
     
        p->next = cpa;
    }
    if(cpb){
     
        p->next = cpb;
        while(cpb){
     
            cpb->Coef *= -1; // 改变系数的符号，将减数多项式的系数变为负的
            cpb = cpb->next;
        }
    }
    free(*pb);      //*pb已经为空，释放空间
}

/*
 * @Description : 乘法
 * @param **pa  : 多项式一结构体指针地址
 * @param **pb     : 多项式二结构体指针地址
 * @return        : 无
 */
void MultiplyPolyn(polynomial **pa, polynomial **pb)
{
     
    polynomial *cpa, *ccpa, *res;
    cpa = *pa;                      //保存着原pa的内容
    CreatePolyn(pa, 0);         //从新初始化pa为头结点
    (*pb) = (*pb)->next;
    while(*pb)                      //只要*pb不为NULL一直进行
    {
     
        CopyPolyn(&ccpa, cpa);      //将后者复制给前者
        MultiplyOperate(ccpa, *pb); //见下文注释
        AddPolyn(pa, &ccpa);        //将结果加入到pa中,直到得到最后的结果
        (*pb) = (*pb)->next;
    }

}

/*
 * @Description : 将pb复制到pa中
 * @param **pa  : 多项式一结构体指针地址
 * @param *pa      : 多项式二结构体指针
 * @return        : 无
 */
void CopyPolyn(polynomial **pa, polynomial *pb)
{
     
    CreatePolyn(pa, 0);
    polynomial *temp, *cpa;
    cpa = *pa;
    pb = pb->next; // 移动指针指向第一个节点
    while(pb)
    {
     
        //进行复制操作
        temp = (polynomial *)malloc(sizeof(polynomial));
        temp->Coef = pb->Coef;
        temp->Index = pb->Index;
        temp->next = NULL;
        cpa->next = temp;
        cpa = temp;
        pb = pb->next;
    }
}

/*
 * @Description : 相乘功能处理函数，将参数一与参数二的每一项分别相乘
 * @param *pa      : 多项式一结构体指针
 * @param *pa      : 多项式二结构体指针
 * @return        : 无
 */
void MultiplyOperate(polynomial *pa, polynomial *pb)
{
     
    pa = pa->next;
    while(pa)
    {
     
        pa->Coef *= pb->Coef;
        pa->Index += pb->Index;
        pa = pa->next;
    }
}

/*
 * @Description : 打印多项式
 * @param *p       : 结构体指针
 * @return        : 无
 */
void PrintPolyn(polynomial *p)
{
     
    polynomial *temp = p->next;
    int a[100000];
    double b[100000];
    int aid=0,bid=0;
    int cnt=0;
    cout << "升幂情况: " ;
    while(temp){
     
        if(cnt!=0&& temp->Coef > 0)printf("+");
        b[bid]=temp->Coef;
        a[aid]=  temp->Index;
        cout << b[bid] << "x^" << a[aid];
        aid++;
        bid++;
        cnt++;
        temp = temp->next;
    }
    if(cnt==0) {
         //如果是空的输出0
        cout << "0";
    }
    cout << endl;
    cout << "降幂情况: ";
    int ans=0;
    for(int i=aid-1; i>=0; i--){
     
        if(ans!=0&&b[i]>0) {
     
            cout << "+";
        }
        cout << b[i] << "x^" << a[i];
        ans++;
    }
}

存在的问题

未实现的功能：

多项式运算前首先判定多项式特点，根据多项式是否稀疏来选用合适的存储结构；

最后

本文参考了网上多篇文章的解法，但还有不足，还请大佬多多指点