链表表示一元多项式，实现一元多项式的相加相乘。c++

代码：

//
//  main.cpp
//  polynomiallink
//
//  Created by Hmq Hmq on 2019/9/18.
//  Copyright © 2019年 Hmq Hmq. All rights reserved.
//
#include <iostream>
using namespace std;
typedef struct {
    int coef;
    int expn;
}Data;
struct Node{
    Data data;
    Node* next;
};//定义了一个结构体指针。
class polynomial{
private:
    Node* headnode;//和Node headnode的区别？这是一个头指针，指向头节点。Node headnode则是一个结点。
public:
    polynomial(){
        headnode=new Node;//指针指向一个新的结点。使用new开辟了一块内存，只能通过指针访问。
        headnode->next=NULL;//为什么headnode*还能指向下一个？ headnode是指针，通过指针访问结构体的元素用->
    };
    void CreatePolyn();
    //可以不传值直接构建吗？利用*this?c.createpolyn()直接改变它的结构？
    //可以直接构建，就直接c.()可以直接改变c的结构。
    void DestroyPolyn();
    void PrintPolyn();
    void length(polynomial a);
    void Addpolyn(polynomial a,polynomial  b);//a,b会被改变吗 会。因为里面有指针，直接改变对应地址上的值。若不想改变则需在里面新建一个一样的复制
    void Multipolyn(polynomial  a,polynomial  b);
    void bubblesort();
    void merge();
    
    
    
};
void polynomial::CreatePolyn(){
    int n;//数量n
    Node* newnode;//新指针，无指向
    Node* last;//尾指针，无指向
    last=headnode;//尾指针=头指针，可以访问头节点。
    cout<<"请输入一个一元多项式：系数从大到小。";
    cin>>n;
    //cout<<n;
    for(int i=0;i<n;i++){
        
        newnode=new Node;//开辟一块内存用作结构体，只能通过newnode指针访问。
        //  cout<<newnode<<endl;//测试，输出newnode的地址。每次都不一样。
        cin>>newnode->data.coef;
        cin>>newnode->data.expn;
        last->next=newnode;//尾指针的下一个是新指针，接上了。
        last=newnode;//尾指针指向新的结点。
    }
    last->next=NULL;
    //PrintPolyn();
}
void polynomial::DestroyPolyn(){
    while(NULL!=headnode->next)
    {   Node *p;
        p=headnode->next;
        headnode->next=p->next;
        free(p);
        p=NULL;
    }}
void polynomial::PrintPolyn(){
    Node *p;//node*指针
    p=headnode->next;//p指向头的下一个结点
    while(NULL!=p){
        cout<<p->data.coef<<" "<<p->data.expn<<endl;
        p=p->next;
    }
}
void polynomial::Addpolyn(polynomial a, polynomial b){
    Node *p, *q;
    Node *newnode;
    Node *current;
    polynomial c;//建立新的链表c
    current=c.headnode;//current指向头节点
    p = a.headnode->next;//p指向a的第一个结点
    q = b.headnode->next;//q指向b的第一个结点
    while (p && q) {
        if (p->data.expn >q->data.expn) {//p>q
            newnode = new Node;
            newnode->data=p->data;
            current->next = newnode;
            current = newnode;
            p = p->next;
        } else if (p->data.expn==q->data.expn) {
            if (p->data.expn+ q->data.expn == 0) {
                p = p->next;
                q = q->next;
            } else {
                newnode = new Node;
                newnode->data.expn= p->data.expn;
                newnode->data.coef = p->data.coef + q->data.coef;
                current->next=newnode;
                current = newnode;
                p = p->next;
                q = q->next;
            }
        } else {
            newnode = new Node;
            newnode->data = q->data;
            current->next = newnode;
            current = newnode;
            q = q->next;
        }
    }
    current->next = NULL;
    if (p != NULL) current->next = p;
    if (q != NULL) current->next = q;
    c.PrintPolyn();
}

void polynomial::bubblesort(){
    Data t;
    Node* a;
    Node* b;
    for(a=headnode->next;a!=NULL;a=a->next)
    {
        for(b=a->next;b!=NULL;b=b->next)
        {
            if(a->data.expn<b->data.expn)
            {
                t = a->data;
                a->data = b->data;
                b->data = t;
                
            }
        }
        
    } }
void polynomial::merge(){
    Node* a=headnode->next;
    Node* b;
    Node* newnode;
    polynomial c;
    Node* curc=c.headnode;
    newnode=new Node;
    newnode->data=a->data;
    curc->next=newnode;
    curc=newnode;
    for(;a->next!=NULL;a=a->next){
        b=a->next;
        if(a->data.expn==b->data.expn){
            curc->data.coef=curc->data.coef+b->data.coef;
        }else{
            newnode=new Node;
            newnode->data=b->data;
            curc->next=newnode;
            curc=newnode;
        }
    }
    curc->next=NULL;
    headnode=c.headnode;
}
void polynomial::Multipolyn(polynomial a, polynomial b){
    cout<<"乘法！"<<endl;
    // a.PrintPolyn();
    // b.PrintPolyn();
    polynomial c;
    Node* curc=c.headnode;
    Node* newnode;
    Node* cura=a.headnode->next;
    Node* curb=b.headnode->next;
    while(cura!=NULL){
        while(curb!=NULL){
            newnode=new Node;
            newnode->data.coef=cura->data.coef*curb->data.coef;
            newnode->data.expn=cura->data.expn+curb->data.expn;
            curb=curb->next;
            curc->next=newnode;
            curc=newnode;
        }
        curb=b.headnode->next;
        cura=cura->next;
    }
    curc->next=NULL;
    cout<<"无序："<<endl;
    c.PrintPolyn();
    c.bubblesort();
    cout<<"冒泡排序后："<<endl;
    c.PrintPolyn();
    cout<<"合并后："<<endl;
    c.merge();
    
    c.PrintPolyn();
    c.DestroyPolyn();
    
}

int main() {
    polynomial a,b;
    a.CreatePolyn();
    b.CreatePolyn();
    a.Addpolyn(a, b);
    a.Multipolyn(a, b);
    a.DestroyPolyn();
    b.DestroyPolyn();
    return 0;}

运行效果：

加法：

乘法：

无序输出：

冒泡排序以后：

合并同类项：

总结：

• 在c++中，Node* newnode=new Node;表示申请一块内存，该内存可用来存储node结点的数据，但是只能通过newnode这个结点指针访问这块内存，申请成功后系统将这块内存的地址赋给newnode，newnode的值即是地址。
• 在用完new这个关键字申请了一个内存后，要记得删除指针，并且只能用delete删除，否则会造成内存泄漏！！！
• delete和free的区别就是，delete将指针和指针所指的内存都释放，free是将指针所指内存释放，指针的值还是那块释放了内存的地址，这个时候指针变成野指针，需要在free完以后设置指针值为空才行。
• 空指针可以被delete删除。
• 想要改进多项式的加法，只需要将无序的多项式经过bubblesort和merge变成有序链表以后调用加法即可。
• 为了防止内存泄漏，需要在创建链表用完后调用destory函数
• 判断指针为空最好写成NULL!=P,有些编译器会碰到p!=NULL报错。
• merge函数主要是对有序的数字合并同类项：
  设置两个指针，第一个指向第一个结点，第二个指向第一个结点的后一个，如果第一个结点所指的数和第二个结点的一样，则更新链表c的结点数据，如果不一样，则创建一个新的结点，装上后者的数据，接下来循环遍历比较。
• 不要在加法里面轻易调用destory方法，因为虽然新建了一个链表来装，但是尾部多出来的是直接接上某一条链表的尾部，地址没变，删除以后会改变传进来的链表的结构。最好是确定要运算的都算完了再destory。