【id:33】【20分】E. DS线性表—多项式运算

原创 于 2023-03-23 12:38:50 发布 · 522 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #c++ #数据结构

该文描述了一个编程任务，要求实现两个一元多项式的加、减、乘法操作。输入包含多项式的系数和指数，输出是经过运算后的多项式结果，遵循特定的输出格式。示例中给出了使用链表数据结构实现的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目描述

对于一元多项式 p(x)=p0+p1x+p2x2+ … +pnxn ，每个项都有系数和指数两部分，例如p2x2的系数为p2,指数为2。

编程实现两个多项式的加法、减法、乘法。

例如：多项式A = 5+x+2x2，多项式B = -x+4x4，计算：

A+B = 5+2x2+4x4

A-B = 5 + 2x +2x2 - 4x4

A*B = -5x - x2 -2x3 +20x4 + 4x5+8x6

实现方法不限，可以使用容器。

输入

测试次数t，每组测试数据格式如下:

第一行，第一个多项式A的项数n（n>0)

第二行，A的每一项的系数 指数（共2n个数字，均为整数，以空格分隔）

第三行，第一个多项式B的项数m（m>0)

第四行，B的每一项的系数 指数（共2m个数字，均为整数，以空格分隔）

输出

对每组测试数据，输出五行，分别是：

多项式A

多项式B

A+B

A-B

A*B

每组测试数据间以空行分隔。

多项式输出格式：项之间用+连接，例如，1 + x 。但后一项系数为负数，不输出+号，如: 1 + （-2x2），输出为1 - 2x^2。

如果该项：系数为0，不输出，但表达式只有一项0，要输出。

指数为0，不输出x^0。指数为负数，例如-3，输出x^(-3)。指数为正数，例如3，输出x^3。指数为1，输出x。

以上一句话总结：和数学中多项式表示相同，x的指数加^表示。

样例查看模式

正常显示查看格式

输入样例1 <-复制

输出样例1

语言: 编译选项

主题: 

#include<iostream>
using namespace std;
class ListNode
{
public:
    int data;
    int index;
    ListNode* next;
    ListNode() {
        next = NULL;
    }
};
class LinkList
{
public:
    ListNode* head;
    int len;
    LinkList()
    {
        head = new ListNode();
        len = 0;
    }
    ~LinkList()
    {
        ListNode* p, * q;
        p = head->next;//
        while (p != NULL)
        {
            q = p;
            p = p->next;
            delete q;
        }
        len = 0;
        head = NULL;
    }
    ListNode creatList(int n)
    {
        len = n;
        ListNode* pnew = new ListNode();
        ListNode* tail = new ListNode();
        head->data = 0;
        head->next = NULL;
        tail = head;
        for(int i = 0; i < len; i++)
        {
            pnew = new ListNode;
            cin >> pnew->data >> pnew->index;
            pnew->next = NULL;
            tail->next = pnew;
            tail = pnew;//最后一个指针变成pnew了
        }
        return *head;
    }
    void display() {
        ListNode* p = head->next;
        if (head->next == NULL) {
            cout << "0" << endl;
            return;
        }
        while (p) {
            if (p->data >= 0) {
                if (p->data == 0) {
                    while (p->next && p->next->data == 0) { p = p->next; }
                    if (p->next && p->next->index == 0) { cout << p->next->data; p = p->next; }//只有这种情况要特殊处理，因为如果不处理的话，要出现一个p->data
                    else if (p->next && p->next->data != 0) { NULL; }//这种情况出现在后面
                    else { cout << "0"; }
                }

                // else if (p->data == 1) { NULL; }//等于1 相当于不存在
                else {
                    if (p->index == 1) {
                        if (p->data == 1) { cout << "x"; }

                        else { cout << p->data << "x"; }
                    }
                    if (p->index == 0) {
                        cout << p->data;
                    }
                    if (p->index > 1) {
                        if (p->data == 1) { cout << "x^" << p->index; }
                        else { cout << p->data << "x^" << p->index; }
                    }
                    if (p->index < 0) {
                        if (p->data == 1) { cout << "x^(" << p->index << ")"; }
                        else { cout << p->data << "x^(" << p->index << ")"; }
                    }
                    while (p->next && p->next->data == 0) { p = p->next; }
                    if (p->next && p->data == 0 && p->next->data != 0) { cout << "+"; }

                }
                if (p->next && p->next->data > 0 && p->data != 0) { cout << "+"; }
            }
            else {//p->data<0
                if (p->index == 1) {
                    if (p->data == -1) { cout << "-x"; }
                    else { cout << p->data << "x"; }
                }
                if (p->index == 0) {
                    cout << p->data;
                }
                if (p->index > 1) {
                    if (p->data == -1) { cout << "-x^" << p->index; }
                    else { cout << p->data << "x^" << p->index; }
                }
                if (p->index < 0) {
                    if (p->data == -1) { cout << "-x^(" << p->index << ")"; }
                    else { cout << p->data << "x^(" << p->index << ")"; }
                }
                if (p->next && p->next->data == 0) { p = p->next; }
                if (p->next && p->next->data > 0) { cout << "+"; }
            }
            p = p->next;
        }
        cout << endl;
        return;
    }

    LinkList* add(LinkList* b)
    {
        LinkList* temp = new LinkList;
        ListNode* t = (*temp).head;
        ListNode* p = head->next;
        ListNode* q=b->head->next;//第一个
        while (p && q)
        {
            ListNode* m = new ListNode;
            if (p->index == q->index)
            {
                m->data = p->data + q->data;
                if (m->data != 0)
                {
                    m->index = p->index;
                    t->next = m;
                    t = m;
                    m->next = NULL;//觉得这个可以删除
                    temp->len++;
                }
                p = p->next;
                q = q->next;
                continue;//节省时间
            }
            if (p->index < q->index)
            {
                m->data = p->data;
                m->index = p->index;
                t->next = m;
                t = m;
                p = p->next;
                temp->len++;
                continue;
            }
            else
            {
                m->data = q->data;
                m->index = q->index;
                t->next = m;
                t = m;
                q = q->next;
                temp->len++;
                continue;
            }
        }
        //会有遗留问题
        while (p)
        {
            ListNode* m = new ListNode();
            m->data = p->data;
            m->index = p->index;
            t->next = m;
            t = m;
            p = p->next;
        }
        while (q)
        {
            ListNode* m = new ListNode();
            m->data = q->data;
            m->index = q->index;
            t->next = m;
            t = m;
            q = q->next;
        }
        return temp;
    }
    LinkList* sub(LinkList* b)
    {
        LinkList* temp = new LinkList();
        ListNode* t = (*temp).head;
        ListNode* p = head->next;
        ListNode* q = b->head->next;
        while (p && q)
        {
            ListNode* m = new ListNode;
            if (p->index == q->index)
            {
                m->data = p->data - q->data;
                if (m->data != 0)
                {
                    m->index = p->index;
                    t->next = m;
                    t = m;
                    temp->len++;
                }
                p = p->next;
                q = q->next;
                continue;
            }
            else if (p->index < q->index)
            {
                m->data = p->data;
                m->index = p->index;
                t->next = m;
                t = m;
                temp->len++;
                p = p->next;
                continue;
            }
            else
            {
                m->data = -q->data;
                m->index = q->index;
                t->next = m;
                t = m;
                temp->len++;
                q = q->next;
                continue;
            }
        }
        while (p)
        {
            ListNode* m = new ListNode();
            m->data = p->data;
            m->index = p->index;
            t->next = m;
            t = m;
            p = p->next;
            temp->len++;
            continue;
        }
        while (q)
        {
            ListNode* m = new ListNode();
            m->data = -q->data;
            m->index = q->index;
            t->next = m;
            t = m;
            q = q->next;
            temp->len++;
            continue;
        }
        return temp;
    }
    LinkList* mul(LinkList* b)
    {
        LinkList* temp1 = new LinkList;
        ListNode* p = head->next;
        while (p)
        {
            LinkList* temp2 = new LinkList;
            ListNode* t2 = (*temp2).head;
            ListNode* q = (*b).head->next;
            while (q)
            {
                ListNode* m = new ListNode;
                m->data = q->data * p->data;
                m->index = q->index + p->index;
                t2->next = m;
                t2 = m;
                q = q->next;
            }
            temp1 = temp1->add(temp2);
            //把所有相加起来
            p = p->next;
        }
        return temp1;
    }
};
int main()
{
    int data, index;
    int n;
    cin >> n;
    int n1, n2;
    while (n--)
    {
        cin >> n1;
        LinkList* a = new LinkList;
        a->creatList(n1);
        a->display();
        cin >> n2;
        LinkList* b = new LinkList;
        b->creatList(n2);
        b->display();
        LinkList* c = a->add(b);
        c->display();
        LinkList* d = a->sub(b);
        d->display();
        LinkList* e = a->mul(b);
        e->display();
        cout << endl;
    }
    return 0;
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值