3.一元多项式相加

题目说明：

编写一元多项式加法运算程序。要求用线性链表存储一元多项式（参照课本）。该程序有以下几个功能：

1. 多项式求和

输入：输入三个多项式，建立三个多项式链表Pa、Pb、Pc

（提示：调用CreatePolyn(polynomial &P,int m)。

输出：显示三个输入多项式Pa、Pb、Pc、和多项式Pa+Pb、多项式Pa+Pb+Pc

（提示：调用AddPolyn(polynomial &Pa, polynomial Pb), 调用PrintPolyn(polynomial P))。

0. 退出

输入

根据所选功能的不同，输入格式要求如下所示（第一个数据是功能选择编号，参见测试用例）：

• 1

多项式A包含的项数，以指数递增的顺序输入多项式A各项的系数（整数）、指数（整数）

多项式B包含的项数，以指数递增的顺序输入多项式B各项的系数（整数）、指数（整数）

多项式C包含的项数，以指数递增的顺序输入多项式C各项的系数（整数）、指数（整数）

• 0 －－－操作终止，退出。

输出

对应一组输入，输出一次操作的结果（参见测试用例）。

• 1 多项式输出格式：以指数递增的顺序输出: <系数,指数>,<系数,指数>,<系数,指数>,参见测试用例。零多项式的输出格式为<0,0>

• 0 无输出

C++代码（含注释） 

#include 
using namespace std;

struct Node {
    int coef; // 系数
    int exp; // 指数
    Node* next; // 指向下一个节点的指针
};

// 创建多项式
void CreatePolyn(Node*& p, int m) {
    Node* head = new Node(); // 创建头节点
    Node* tail = head; // 尾指针指向头节点

    for (int i = 0; i < m; i++) {

        Node* newNode = new Node(); // 创建新节点
        cin >> newNode->coef >> newNode->exp; // 赋值系数、指数
        newNode->next = nullptr;        // 将新节点的next指针置空

        tail->next = newNode;           // 尾指针的next指向新节点
        tail = newNode;                 // 更新尾指针为新节点
    }

    p = head->next;                     // 头指针指向下一个节点，即第一个节点
    delete head;                        // 释放头节点的内存空间
}

// 多项式相加
void AddPolyn(Node*& p1, Node* p2) {
    Node* head = new Node(); // 创建头节点
    Node* tail = head; // 尾指针指向头节点
    Node* node1 = p1; // 指向多项式p1的节点
    Node* node2 = p2; // 指向多项式p2的节点

    while (node1 && node2) {
        if (node1->exp < node2->exp) {   // 如果p1的指数小于p2的指数
            int coef = node1->coef;
            int exp = node1->exp;
            node1 = node1->next;         // p1的节点指针向后移动

            Node* newNode = new Node();
            newNode->coef = coef;
            newNode->exp = exp;
            newNode->next = nullptr;

            tail->next = newNode;        // 新节点插入到尾指针的后面
            tail = newNode;              // 更新尾指针
        }
        else if (node1->exp > node2->exp) {  // 如果p1的指数大于p2的指数
            int coef = node2->coef;
            int exp = node2->exp;
            node2 = node2->next;         // p2的节点指针向后移动

            Node* newNode = new Node();
            newNode->coef = coef;
            newNode->exp = exp;
            newNode->next = nullptr;

            tail->next = newNode;        // 新节点插入到尾指针的后面
            tail = newNode;              // 更新尾指针
        }
        else {                           // 如果p1和p2的指数相等
            int coef = node1->coef + node2->coef;
            int exp = node1->exp;
            node1 = node1->next;         // p1的节点指针向后移动
            node2 = node2->next;         // p2的节点指针向后移动

            if (coef != 0) {             // 如果系数不为0
                Node* newNode = new Node();
                newNode->coef = coef;
                newNode->exp = exp;
                newNode->next = nullptr;

                tail->next = newNode;    // 新节点插入到尾指针的后面
                tail = newNode;          // 更新尾指针
            }
        }
    }

    while (node1) {                    // 如果p1还有剩余节点
        int coef = node1->coef;
        int exp = node1->exp;
        node1 = node1->next;            // p1的节点指针向后移动

        Node* newNode = new Node();
        newNode->coef = coef;
        newNode->exp = exp;
        newNode->next = nullptr;

        tail->next = newNode;           // 新节点插入到尾指针的后面
        tail = newNode;                 // 更新尾指针
    }

    while (node2) {                    // 如果p2还有剩余节点
        int coef = node2->coef;
        int exp = node2->exp;
        node2 = node2->next;            // p2的节点指针向后移动

        Node* newNode = new Node();
        newNode->coef = coef;
        newNode->exp = exp;
        newNode->next = nullptr;

        tail->next = newNode;           // 新节点插入到尾指针的后面
        tail = newNode;                 // 更新尾指针
    }

    p1 = head->next;                   // 头指针指向下一个节点，即第一个节点
    delete head;                       // 释放头节点的内存空间
}

// 打印多项式
void PrintPolyn(Node* p) {
    if (p == nullptr) {
        cout << "<0,0>";
    }
    else {
        Node* node = p;
        while (node) {
            cout << "<" << node->coef << "," << node->exp << ">";
            if (node->next) {
                cout << ",";
            }
            node = node->next;
        }
    }
    cout<next;
        delete temp;
    }
}

int main() {
    Node* Pa = nullptr;
    Node* Pb = nullptr;
    Node* Pc = nullptr;

    int choice;

    while (cin >> choice) {
            int m;
            cin >> m;
            CreatePolyn(Pa, m);     // 创建多项式Pa
            cin >> m;
            CreatePolyn(Pb, m);     // 创建多项式Pb
            cin >> m;
            CreatePolyn(Pc, m);     // 创建多项式Pc

            PrintPolyn(Pa);         // 打印多项式Pa
            PrintPolyn(Pb);         // 打印多项式Pb
            PrintPolyn(Pc);         // 打印多项式Pc

            AddPolyn(Pa, Pb);       // Pa = Pa + Pb
            PrintPolyn(Pa);         // 打印多项式Pa

            AddPolyn(Pa, Pc);       // Pa = Pa + Pc
            PrintPolyn(Pa);         // 打印多项式Pa

            FreeList(Pa);           // 释放Pa链表的内存空间
            FreeList(Pb);           // 释放Pb链表的内存空间
            FreeList(Pc);           // 释放Pc链表的内存空间

        }
    

    return 0;
}