02-线性结构2 一元多项式的乘法与加法运算

问题

设计函数分别求两个一元多项式的乘积与和。

输入格式:

输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

输出格式:

输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。

输入样例:

4 3 4 -5 2  6 1  -2 0
3 5 20  -7 4  3 1

输出样例:

15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1
5 20 -4 4 -5 2 9 1 -2 0

解答

#include <iostream>

using namespace std;

template <typename C, typename E>
class Node
{
public:
    C coe;
    E exp;
    Node *next;
};

template <typename C, typename E>
class List
{
public:
    Node<C, E> *head;
    int size;
    List()
    {
        head = new Node<C, E>;
        head->next = nullptr;
        size = 0;
    }
    List(int n)
    {
        head = new Node<C, E>;
        head->next = nullptr;
        size = 0;
        Node<C, E> *q = head;
        for (size = 0; size < n; ++size)
        {
            Node<C, E> *p = new Node<C, E>;
            cin >> p->coe >> p->exp;
            q->next = p;
            q = q->next;
        }
        q->next = nullptr;
    }
    List(const List<C, E> &L)
    {
        head = new Node<C, E>;
        head->next = nullptr;
        size = 0;
        Node<C, E> *p = L.head->next;
        Node<C, E> *h = head;
        while (p)
        {
            Node<C, E> *r = new Node<C, E>;
            r->coe = p->coe;
            r->exp = p->exp;
            p = p->next;
            h->next = r;
            h = h->next;
            ++size;
        }
        h->next = nullptr;
    }

    List &operator=(const List<C, E> &L2)
    {
        head = new Node<C, E>;
        head->next = nullptr;
        size = 0;
        Node<C, E> *p = L2.head->next;
        Node<C, E> *h = head;
        while (p)
        {
            Node<C, E> *r = new Node<C, E>;
            r->coe = p->coe;
            r->exp = p->exp;
            p = p->next;
            h->next = r;
            h = h->next;
            ++size;
        }
        h->next = nullptr;
        return *this;
    }

    ~List()
    {
        for (Node<C, E> *p = head; p;)
        {
            Node<C, E> *q = p->next;
            delete p;
            p = q;
        }
    }

    void traverse()
    {
        if (size == 0)
        {
            cout << 0 << " " << 0 << endl;
            return;
        }
        Node<C, E> *p = head->next;
        for (; p->next; p = p->next)
            cout << p->coe << " " << p->exp << " ";
        cout << p->coe << " " << p->exp << endl;
    }

    List<C, E> add(const List<C, E> &L2)
    {
        List<C, E> L;
        Node<C, E> *p = head->next;
        Node<C, E> *q = L2.head->next;
        Node<C, E> *h = L.head;
        while (p and q)
        {
            if (p->exp > q->exp)
            {
                Node<C, E> *r = new Node<C, E>;
                r->coe = p->coe;
                r->exp = p->exp;
                p = p->next;
                h->next = r;
                h = h->next;
                L.size++;
            }
            else if (p->exp < q->exp)
            {
                Node<C, E> *r = new Node<C, E>;
                r->coe = q->coe;
                r->exp = q->exp;
                q = q->next;
                h->next = r;
                h = h->next;
                L.size++;
            }
            else
            {
                Node<C, E> *r = new Node<C, E>;
                r->coe = p->coe + q->coe;
                if (r->coe == 0)
                {
                    p = p->next;
                    q = q->next;
                    continue;
                }
                r->exp = p->exp;
                p = p->next;
                q = q->next;
                h->next = r;
                h = h->next;
                L.size++;
            }
        }
        if (p)
        {
            while (p)
            {
                Node<C, E> *r = new Node<C, E>;
                r->coe = p->coe;
                r->exp = p->exp;
                p = p->next;
                h->next = r;
                h = h->next;
                L.size++;
            }
        }
        if (q)
        {
            while (q)
            {
                Node<C, E> *r = new Node<C, E>;
                r->coe = q->coe;
                r->exp = q->exp;
                q = q->next;
                h->next = r;
                h = h->next;
                L.size++;
            }
        }
        h->next = nullptr;
        return L;
    }

    List<C, E> mul(const List<C, E> &L2)
    {
        List<C, E> L;
        Node<C, E> *p = head->next;
        Node<C, E> *q = L2.head->next;
        if (p == nullptr or q == nullptr)
        {
            L.head->next = nullptr;
            return L;
        }
        for (; q; q = q->next)
        {
            List<C, E> T;
            Node<C, E> *h = T.head;
            for (p = head->next; p; p = p->next)
            {
                Node<C, E> *r = new Node<C, E>;
                r->coe = p->coe * q->coe;
                r->exp = p->exp + q->exp;
                h->next = r;
                h = h->next;
                ++T.size;
            }
            h->next = nullptr;
            L = L.add(T);
        }
        return L;
    }
};

int main()
{

    int m, n;
    cin >> m;
    List<int, int> L1(m);
    cin >> n;
    List<int, int> L2(n);

    List<int, int> L3 = L1.mul(L2);
    L3.traverse();

    List<int, int> L4 = L1.add(L2);
    L4.traverse();

    return 0;
}