一元稀疏多项式简单计算器（C语言）含注释

问题描述

设计一个一元稀疏多项式简单计算器

基本要求

一元稀疏多项式简单计算器的基本功能是：

（1）输入并建立多项式；

（2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en，其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；

（3）多项式a和b相加，建立多项式a+b；

（4）多项式a和b相减，建立多项式a-b。

测试数据

（1）（2x+5x3-3.1x11）+(7-5x3+11x9)=(-3.1x11+11x9+2x+7)

（2）(6x-3-X+4.4X2-1.2X9)-(-6X-3+5.4X2-X2+7.8X15)=(-7.8X15-1.2X9+12X-3-X)

（3）(1+X+X2+X3+X4+X5)+(-X3-X4)=(1+X+X2+X5)

（4）(X+X3)+(-X-X3)=0

实现提示

用带表头结点的单链表存储多项式。

选作内容

（1）计算多项式在X处的值。

（2）计算多项式a的导函数a’。

（3）多项式a和b相乘，建立乘积多项式ab。

（4）多项式的输出形式为类数学表达式。例如，多项式-3x8+6x3-18的输出形式为-3x＾8+6x＾3-18。注意，系数为1的非零次项的输出形式中略去系数1，如1x8的输出形式为x＾8。

（5）计算器的仿真界面。

程序界面如下：

仿真界面如下：

Tips:

1. 可以合并同指数的项

2. 类数学表达式与实际基本一直

3. 输入时注意系数与指数为0的情况

4. 采用链表的数据结构

一些个人感想：

整个程序难度不大，相比运动会略难，在编写过程中耗时最长的是类数学表达式，为了输出准确，不断测试特殊情况，进行调整。

完整程序如下：

#include <iostream>
#include <iomanip>
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
using namespace std;
//链表实现多项式

struct Node
{
    int coef;     //系数
    int power;    //指数
    Node *link;  //指针域
};
Node Head,Head2;//头节点
Node *LinkList;//多项式a
Node *LinkList2;//多项式b
int n=0,m=0;//项数

Node *temp,head;//相乘时所使用的新表，用来暂存相乘后的数据

void wait();
void cover();
void input(Node *LinkList,int flag);
void Insert(Node *LinkList,int coef,int power,int flag);
void printLinkList(Node *LinkList,int flag);
void selectionSort(Node *LinkList);
void add(Node *LinkList,Node *LinkList2);
void subtract(Node *LinkList,Node *LinkList2);
void calculate(Node *LinkList);
void dX(Node *LinkList);
void multiply(Node *LinkList);

int main()
{
    char choice;
    LinkList=&Head;
    Head.link=NULL;
    LinkList2=&Head2;
    Head2.link=NULL;
    while(1)
    {
        system("cls");
        printf("\n\n\n\n");
        printf("\t\t               一元稀疏多项式简单计算器  \n");
        printf("\t\t=========================================================");
        printf("\n\n");
        printf("\t\t             1：输入\n");
        printf("\t\t             2：输出（整数序列->类数学表达式）\n");
        printf("\t\t             3：相加\n");
        printf("\t\t             4：相减\n");
        printf("\t\t             5：计算在X处的值\n");
        printf("\t\t             6：计算多项式a的导函数a'\n");
        printf("\t\t             7：多项式a和b相乘，建立乘积多项式ab。\n");
        printf("\t\t             0：退出\n");
        printf("\n");
        printf("\t\t请选择：");
    
        choice = getch();
        system("cls");
        switch(choice)
        {
        case '1':
            cover();
            LinkList->link=NULL;
            input(LinkList,1);
            wait();
            break;
        case '2':
            printLinkList(LinkList,1);
            wait();
            break;
        case '3':
            add(LinkList,LinkList2);
            wait();
            break;
        case '4':
            subtract(LinkList,LinkList2);
            wait();
            break;
        case '5':
            calculate(LinkList);
            wait();
            break;
        case '6':
            dX(LinkList);
            wait();
            break;
        case '7':
            multiply(LinkList);
            wait();
            break;
        case '0':
            exit(0);
        default:
            break;
        }
    }

}

//多项式输入
void input(Node *LinkList,int flag)
{
    Node *p=LinkList->link;
    int coef,power;
    int i,length;//长度
    printf("请输入项数：");
    if(flag==1)
    {
        scanf("%d",&n);
        length=n;
    }
    else
    {
        scanf("%d",&m);
        length=m;
    }
    for(i=1;i<=length;i++)
    {
        printf("请输入第%d项的系数：",i);
        scanf("%d",&coef);
        printf("请输入第%d项的指数：",i);
        scanf("%d",&power);
        Insert(LinkList,coef,power,flag);
    }
}

//数据传入链表-尾插
void Insert(Node *LinkList,int coef,int power,int flag)
{
    int i;
    Node *p=LinkList,*temp;
    while(p->link!=NULL)//计算是否有相同指数
    {
        p=p->link;
        if(p->power==power)
        {
            p->coef+=coef;
            if(flag==1)
                n--;
            else
                m--;
            return;
        }
    }
    temp=new Node;
    temp->power=power;
    temp->coef=coef;
    temp->link=NULL;//指针域
    p->link=temp;
}

//打印多项式
void printLinkList(Node *LinkList,int flag)
{
    selectionSort(LinkList);
    Node *p=LinkList->link,*q=LinkList->link;
    if(flag==1)
        printf("%d||",n);
    else
        printf("%d||",m);
    while(q!=NULL)
    {
        printf("(%d,%d) ",q->coef,q->power);
        q=q->link;
    }
    printf("\n");
    flag=0;//重置flag，控制首项符号
    int sum=0;
    while(p!=NULL)
    {
        sum+=p->coef*pow(1,p->power);//把x=1代入，如果sum=0，说明各项等于0，输出0
        if(p->coef==0)//系数为0，不打印
        {
            p=p->link;
            continue;
        }
        //单独判断正负号的打印
        if(p->coef>0&&flag==1)//系数大于0且不为第一项
            printf(" + ");
        else if(p->coef<0)//系数小于0
            printf(" - ");
        if(p->coef==1||p->coef==-1)//系数为1、-1时单独处理
        {
            if(p->power==0)// |(-)1*X＾0|=1
            {
                printf("1");
                flag=1;
                p=p->link;
                continue;
            }
            if(p->power==-1)// |(-)X＾-1|=X
            {
                printf("X＾(-1) ");
                flag=1;
                p=p->link;
                continue;
            }
            printf("X＾%d ",p->power);// |(-)1X＾n|=x＾n
            flag=1;
        }
        else //其余情况
        {
            if(p->power==1) //|nX＾1|=nX
            {
                printf("%dX",abs(p->coef));
                flag=1;
                p=p->link;
                continue;
            }
            else if(p->power==0) //|nX＾0|=n
            {
                printf("%d",abs(p->coef));
                flag=1;
                p=p->link;
                continue;
            }
            if(p->power<0) //||n*X＾(-m)|=n*X＾(-m)
            {
                printf("%dX＾(%d) ",abs(p->coef),p->power);
                flag=1;
                p=p->link;
                continue;
            }
            printf("%dX＾%d",abs(p->coef),p->power); //多数情况
            flag=1;
        }
        p=p->link;
    }
    if(sum==0)//均为0
        printf("0");
}

//相加
void add(Node *LinkList,Node *LinkList2)
{
    LinkList2->link=NULL;
    printf("请输入多项式b：\n");
    input(LinkList2,m);
    printLinkList(LinkList,1);
    printf("\n加上\n");
    printLinkList(LinkList2,2);
    printf("\n等于\n—————————————————————————————————————————————————\n");
    Node *q=LinkList2->link;
    while(q!=NULL)
    {
        n++;
        Insert(LinkList,q->coef,q->power,1);
        q=q->link;
    }
    printLinkList(LinkList,1);
}

//相减
void subtract(Node *LinkList,Node *LinkList2)
{
    LinkList2->link=NULL;
    printf("请输入多项式b：\n");
    input(LinkList2,2);
    printLinkList(LinkList,1);
    printf("\n减去\n");
    printLinkList(LinkList2,2);
    printf("\n等于\n—————————————————————————————————————————————————\n");
    Node *q=LinkList2->link;
    while(q!=NULL)
    {
        n++;
        Insert(LinkList,-q->coef,q->power,1);
        q=q->link;
    }
    printLinkList(LinkList,1);
}

//计算多项式在X处的值
void calculate(Node *LinkList)
{
    Node *p=LinkList->link;
    int x;
    double sum=0;
    printLinkList(LinkList,1);
    printf("\n请输入X的值：");
    scanf("%d",&x);
    while(p!=NULL)
    {
        sum+=p->coef*pow(x,p->power);
        p=p->link;
    }
    printf("\n当X的值为%d时，多项式的值为：%.2f\n",x,sum);
}

//计算多项式a的导函数a’
void dX(Node *LinkList)
{
    printLinkList(LinkList,1);
    Node *p=LinkList->link;
    while(p!=NULL)
    {
        if(p->power==0)
        {
            p->coef=0;
            p=p->link;
            continue;
        }
        p->coef=p->coef*p->power;//系数=系数×指数
        p->power--;//降幂
        p=p->link;
    }
    printf("\n求导成功！如下：\n");
    printLinkList(LinkList,1);
}

//多项式a和b相乘，建立乘积多项式ab
void multiply(Node *LinkList)
{
    temp=&head;//新表
    temp->link=NULL;
    LinkList2->link=NULL;
    int coef,power;
    printf("请输入多项式b：\n");
    input(LinkList2,2);
    printLinkList(LinkList,1);
    printf("\n乘以\n");
    printLinkList(LinkList2,2);
    printf("\n等于\n—————————————————————————————————————————————————\n");
    Node *p=LinkList->link,*q=LinkList2->link;
    n=0;//因为多项式a要放置相乘后的表达式，所以项数要创新计算
    while(q!=NULL)
    {
        while(p!=NULL)
        {
            n++;
            coef=p->coef*q->coef;
            power=p->power+q->power;
            Insert(temp,coef,power,1);
            p=p->link;
        }
        p=LinkList->link;
        q=q->link;
    }
    LinkList=temp;//多项式a等于新表
    printLinkList(LinkList,1);
}




//选择法排序-降序
void selectionSort(Node *LinkList)
{
    Node *p,*q,*max,*temp;
    p=LinkList;
    while(p->link!=NULL)
    {
        q=p->link;
        max=p;
        while(q->link!=NULL)
        {
            if(q->link->power > max->link->power)
                max=q;
            q=q->link;
        }
        if(max!=p)
        {
            temp=max->link;
            max->link=temp->link;//将本循环的最大值从链表删除
            temp->link=p->link;
            p->link=temp;//将本循环的最大值插入链表
        }
        p=p->link;
    }
}

//公用的等待函数
void wait()
{
    cout << "\n\n请按任意键继续" << flush;
    getch();
}

//计算器的仿真界面
void cover()
{
    cout<<"=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*="<<endl;
    cout<<"*\t\t一元多项式计算器\t\t*"<<endl;
    cout<<"=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*="<<endl<<endl<<endl;
    cout<<"       \t1\t2\t3\t+"<<endl;
    cout<<"       \t4\t5\t6\t-"<<endl;
    cout<<"       \t7\t8\t9\t＾"<<endl;
    cout<<"       \t0\t.\t(\tC"<<endl;
    cout<<"       \t'\t=\t)\t×"<<endl;
}