多项式的乘法

    #include <iostream>  
    using namespace std; 

    // 多项式项节点结构
    typedef struct lnode
    {  // 定义链表节点结构体，并取别名lnode
    int coef;  // 存储多项式项的系数
    int exp;   // 指数
    lnode* next;  // 指向链表下一个节点的指针
    } lnode;  // 结构体别名  ：

    // 多项式类（简单封装相关操作）
    class poly {  // 定义多项式类poly
    lnode* head;  // 私有成员：头指针，指向多项式的头节点（哨兵节点）
    public:
    // 构造函数，初始化头节点
    poly() {  // 类的构造函数
        head = new lnode;  // 为头节点分配内存
        head->next = NULL;  // 头节点的next指针初始化为空
    }
    
    // 创建多项式（输入n项）
    void create(int n);  // 声明创建多项式的函数
    // 比较两个指数大小
    int comp(int a, int b);  // 声明比较指数的函数
    // 多项式加法：ha = ha + hb
    void add(poly& ha, poly hb);  // 声明多项式加法函数
    // 多项式乘法：hc = ha * hb
    void multiply(poly ha, poly hb);  // 声明多项式乘法函数
    // 打印多项式
    void print();  // 声明打印多项式的函数
    // 辅助函数：插入一项到多项式
    void insert(int coef, int exp);  // 声明插入项的函数
    // 辅助函数：清空多项式
    void clear();  // 声明清空多项式的函数
    };

    // 创建多项式（逆序插入，保证存储为降序）
    void poly::create(int n) {  // 实现create成员函数
    lnode* p;  // 定义临时节点指针
    for (int i = 0; i < n; i++) {  // 循环n次，创建n个项
        p = new lnode;  // 为新节点分配内存
        cin >> p->coef >> p->exp;  // 从控制台输入系数和指数
        p->next = head->next;      // 将新节点的next指向头节点的下一个节点
        head->next = p;  // 将头节点的next指向新节点（头插法）
    }
    }

    // 比较指数：a > b返回-1，a == b返回0，a < b返回1
    int poly::comp(int a, int b) {  // 实现comp成员函数
    if (a > b) return -1;  // a大于b时返回-1
    else if (a == b) return 0;  // a等于b时返回0
    else return 1;  // a小于b时返回1
    }

    // 清空多项式
    void poly::clear() {  // 实现clear成员函数
    lnode* p = head->next;  // p指向第一个实际节点
    lnode* q;  // 临时指针，用于释放节点
    while (p != NULL) {  // 循环直到所有节点都被释放
        q = p;  // q暂存当前节点
        p = p->next;  // p移动到下一个节点
        delete q;  // 释放当前节点内存
    }
    head->next = NULL;  // 头节点的next置空，多项式变为空
    }

    // 插入一项到多项式（自动合并同类项）
    void poly::insert(int coef, int exp) {  // 实现insert成员函数
    if (coef == 0) return;  // 系数为0则不插入，直接返回
    
    lnode* pre = head;  // pre指向当前节点的前一个节点
    lnode* cur = head->next;  // cur指向当前节点
    
    // 查找插入位置：找到第一个指数小于等于待插入项指数的节点
    while (cur != NULL && comp(exp, cur->exp) == -1) {
        pre = cur;  // pre向后移动
        cur = cur->next;  // cur向后移动
    }
    
    // 处理同类项（指数相等）
    if (cur != NULL && cur->exp == exp) {
        cur->coef += coef;  // 系数相加
        if (cur->coef == 0) {  // 合并后系数为0则删除该节点
            pre->next = cur->next;  // 跳过当前节点
            delete cur;  // 释放当前节点内存
        }
    } else {  // 不是同类项，插入新节点
        lnode* p = new lnode;  // 创建新节点
        p->coef = coef;  // 设置系数
        p->exp = exp;  // 设置指数
        p->next = cur;  // 新节点的next指向当前节点
        pre->next = p;  // 前一个节点的next指向新节点
    }
     }

    // 多项式加法
    void poly::add(poly& ha, poly hb) {  // 实现add成员函数
    lnode* q = ha.head;  // q指向ha当前节点的前一个节点
    lnode* pa = ha.head->next;  // pa指向ha的当前节点
    lnode* pb = hb.head->next;  // pb指向hb的当前节点
    lnode* r;  // 临时指针，用于创建新节点
    
    // 当两个多项式都还有项时
    while (pa != NULL && pb != NULL) {
        switch (comp(pa->exp, pb->exp)) {  // 根据指数比较结果进行不同操作
            case -1:  // pa的指数大，不需要合并，移动pa指针
                q = pa;
                pa = pa->next;
                break;
            case 0:   // 指数相等，合并系数
                pa->coef += pb->coef;  // 系数相加
                if (pa->coef == 0) {  // 合并后系数为0，删除该节点
                    q->next = pa->next;
                    delete pa;
                    pa = q->next;
                } else {  // 系数不为0，移动指针
                    q = pa;
                    pa = pa->next;
                }
                pb = pb->next;  // pb指针移动
                break;
            case 1:   // pb的指数大，将pb的项插入到ha中
                r = new lnode;  // 创建新节点
                r->coef = pb->coef;  // 复制系数
                r->exp = pb->exp;  // 复制指数
                r->next = pa;  // 新节点指向pa
                q->next = r;  // q指向新节点
                q = r;  // q移动到新节点
                pb = pb->next;  // pb指针移动
                break;
        }
    }
    
    // 处理hb中剩余的项（当ha已经遍历完，hb还有项时）
    while (pb != NULL) {
        r = new lnode;  // 创建新节点
        r->coef = pb->coef;  // 复制系数
        r->exp = pb->exp;  // 复制指数
        r->next = pa;  // 新节点指向pa（此时pa为NULL）
        q->next = r;  // q指向新节点
        q = r;  // q移动到新节点
        pb = pb->next;  // pb指针移动
    }
    }

    // 多项式乘法
    void poly::multiply(poly ha, poly hb) {  // 实现multiply成员函数
    clear();  // 清空当前多项式，作为结果存储区
    
    lnode* pa = ha.head->next;  // pa指向ha的第一个项
    lnode* pb;  // pb用于遍历hb的项
    
    // 遍历ha的每一项
    while (pa != NULL) {
        pb = hb.head->next;  // pb指向hb的第一个项
        // 遍历hb的每一项
        while (pb != NULL) {
            // 计算乘积项的系数（系数相乘）和指数（指数相加）
            int new_coef = pa->coef * pb->coef;
            int new_exp = pa->exp + pb->exp;
            // 将乘积项插入到结果多项式中（自动合并同类项）
            insert(new_coef, new_exp);
            pb = pb->next;  // pb移动到下一项
        }
        pa = pa->next;  // pa移动到下一项
        }
    }

    // 打印多项式
    void poly::print() {  // 实现print成员函数
    lnode* p = head->next;  // p指向第一个项
    if (p == NULL) {  // 如果多项式为空
        cout << "0" << endl;  // 输出0
        return;
    }
    
    // 遍历所有项并打印
    while (p != NULL) {
        cout << p->coef << " " << p->exp << " ";  // 打印系数和指数
        p = p->next;  // 移动到下一项
    }
    cout << endl;  // 换行
    }

    int main() {  // 主函数，程序入口
    poly ha, hb, hc;  // 创建三个多项式对象
    int n, m;  // 存储多项式的项数
    
    cout << "输入第一个多项式的项数: ";
    cin >> n;  // 输入第一个多项式的项数
    cout << "依次输入" << n << "项（系数 指数）: ";
    ha.create(n);  // 创建第一个多项式
    
    cout << "输入第二个多项式的项数: ";
    cin >> m;  // 输入第二个多项式的项数
    cout << "依次输入" << m << "项（系数 指数）: ";
    hb.create(m);  // 创建第二个多项式
    
    cout << "第一个多项式: ";
    ha.print();  // 打印第一个多项式
    cout << "第二个多项式: ";
    hb.print();  // 打印第二个多项式
    
    // 加法运算
    ha.add(ha, hb);  // 计算ha = ha + hb
    cout << "加法结果: ";
    ha.print();  // 打印加法结果
    
    // 乘法运算
    hc.multiply(ha, hb);  // 计算hc = ha * hb
    cout << "乘法结果: ";
    hc.print();  // 打印乘法结果
    
    return 0;  // 程序正常结束
}