【Weiss】【第03章】练习3.6：有序多项式相加

【练习3.6】

编写将两个多项式相加的函数。不要毁坏输入数据。用一个链表实现。

如果这两个多项式分别有M项和N项，那么你程序的时间复杂度是多少？

两个按幂次升序的多项式链表，分别维护一个指针。

幂较小者将元素的副本拷贝入节点并加入新链表，指针向后移动。

幂同样大时，将两者的系数相加后的结果加入新链表，两个多项式链表的指针共同向前移动。

其中一个多项式到达尾部时，如另一个未到达尾部，则一边后移一边将相同元素的新节点加入新链表。

时间复杂度O(M+N)。

测试代码如下：

#include <iostream>
#include "linklist.h"
using linklist::List;
using namespace std;
int main(void)
{
    //测试多项式加法
    List<Poly> a;
    a.additem(Poly(3, 1));
    a.additem(Poly(1, 2));
    a.additem(Poly(4, 3));
    a.additem(Poly(7, 4));
    a.additem(Poly(2, 5));
    cout << "  ( " << flush;
    a.traverse();
    cout << ")  +
" << flush;
    List<Poly> b;
    b.additem(Poly(5, 2));
    b.additem(Poly(2, 3));
    b.additem(Poly(1, 5));
    b.additem(Poly(3, 7));
    b.additem(Poly(1, 11));
    cout << "  ( " << flush;
    b.traverse();
    cout << ") =
" << flush;

    List<Poly> answer = linklist::polyplus(a, b);
    cout << "
  ( " << flush;
    answer.traverse();
    cout << ") 
" << flush;
    system("pause");
}

实现方面，首先定义了多项式类，以及必要的构造函数及运算符重载，放在poly.h头文件中

#ifndef POLY
#define POLY
#include <iostream>
using namespace std;

namespace poly
{
//练习3.6新增，多项式元素定义
class Poly
{
    friend bool operator<(const Poly& poly1, const Poly& poly2);
    friend bool operator==(const Poly& poly1, const Poly& poly2);
    friend bool operator!=(const Poly& poly1, const Poly& poly2);
    friend ostream& operator<<(ostream &os, const Poly& poly);
    friend Poly operator+(const Poly& poly1, const Poly& poly2);
public:
    Poly() = default;
    Poly(int coe, int exp) :coefficient(coe), exponent(exp){}
private:
    //多项式系数
    int coefficient;
    //多项式指数
    int exponent;
};
//练习3.6新增，多项式元素对应操作符重载，包括<<、<、==、!=，+
bool operator<(const Poly& poly1, const Poly& poly2)
{
    return poly1.exponent < poly2.exponent;
}
bool operator==(const Poly& poly1, const Poly& poly2)
{
    return poly1.exponent == poly2.exponent;
}
bool operator!=(const Poly& poly1, const Poly& poly2)
{
    return !(poly1 == poly2);
}
ostream& operator<<(ostream &os, const Poly& poly)
{
    cout << poly.coefficient << "x^" << poly.exponent << flush;
    return os;
}
Poly operator+(const Poly& poly1, const Poly& poly2)
{
    if (poly1 != poly2)
        throw runtime_error("Undefined operation!");
    else
    {
        Poly answer;
        answer.coefficient = poly1.coefficient + poly2.coefficient;
        answer.exponent = poly1.exponent;
        return answer;
    }
}
}
#endif

在原链表例程中包含该头文件，并将Poly类与polyplus函数（该函数不是List的成员函数）设为友元

#ifndef LINKLIST
#define LINKLIST
#include <iostream>
#include "poly.h"　　　　　　//包含poly头文件
using namespace std;
using namespace poly;

namespace linklist
{
        /…………/
 template <typename T> class List
{
    　　/…………/
        //练习3.6新增，友元声明
    friend List<Poly> polyplus(const List<Poly> &inorder_a, const List<Poly> &inorder_b);
    friend struct Poly;   
       /…………/
}

       /…………/
}

最后是具体实现代码：

//练习3.6新增，不覆盖原传入数据，多项式相加
List<Poly> polyplus(const List<Poly> &inorder_a, const List<Poly> &inorder_b)
{
    List<Poly> answer;
    Node<Poly>* pwrite = answer.front;
    Node<Poly>* pread_a = inorder_a.front;
    Node<Poly>* pread_b = inorder_b.front;
    while (pread_a != nullptr && pread_b != nullptr)
    {
        //为实现升序排列，元素较小者加入新的链表，并向前移动指针
        if (pread_a->data < pread_b->data)
        {
            answer.additem(pread_a->data, pwrite);
            if (pwrite == nullptr)
                pwrite = answer.front;
            else
            pwrite = pwrite->next;
            pread_a = pread_a->next;
        }
        else if (pread_b->data < pread_a->data)
        {
            answer.additem(pread_b->data, pwrite);
            if (pwrite == nullptr)
                pwrite = answer.front;
            else
                pwrite = pwrite->next;
            pread_b = pread_b->next;
        }
        //元素一样大时共同向前移动指针
        else
        {
            answer.additem(pread_a->data + pread_b->data, pwrite);
            if (pwrite == nullptr)
                pwrite = answer.front;
            else
                pwrite = pwrite->next;
            pread_a = pread_a->next;
            pread_b = pread_b->next;
        }
    }
    //如果其中任一链表未遍历，将剩余的元素复制入新的链表
    while (pread_a != nullptr)
    {
        answer.additem(pread_a->data, pwrite);
        if (pwrite == nullptr)
            pwrite = answer.front;
        else
            pwrite = pwrite->next;
        pread_a = pread_a->next;
    }
    while (pread_b != nullptr)
    {
        answer.additem(pread_b->data, pwrite);
        if (pwrite == nullptr)
            pwrite = answer.front;
        else
            pwrite = pwrite->next;
        pread_b = pread_b->next;
    }
    return answer;
}