【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(, ));
     a.additem(Poly(, ));
     a.additem(Poly(, ));
     a.additem(Poly(, ));
     a.additem(Poly(, ));
     cout << "  ( " << flush;
     a.traverse();
     cout << ")  +\n" << flush;
     List<Poly> b;
     b.additem(Poly(, ));
     b.additem(Poly(, ));
     b.additem(Poly(, ));
     b.additem(Poly(, ));
     b.additem(Poly(, ));
     cout << "  ( " << flush;
     b.traverse();
     cout << ") =\n" << flush;

     List<Poly> answer = linklist::polyplus(a, b);
     cout << "\n  ( " << flush;
     answer.traverse();
     cout << ") \n" << 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;
 }