一元多项式的加/减法运算

问题描述 :

假设2个稀疏一元多项式分别由带头结点的有序单链表A和B存储（指数项递增有序）。现要求设计一个算法，实现稀疏一元多项式的加减法计算。要求使用A和B的原存储空间（运算后B不再存在，A链表中保存结果多项式）。输入中的单链表的长度不得在计算算法中利用，仅作为建表使用。

注意：加/减法计算后，如某一项的结果系数为0，则该项要从多项式链表中删除。

 

输入说明 :

第一行：加/减法选择（0：加法  1：减法）

第二行：一元多项式A的项数

第三行：一元多项式A的各项的系数（系数之间以空格分隔）

第四行：一元多项式A的各项的指数（指数之间以空格分隔）

第五行：一元多项式B的项数

第六行：一元多项式B的各项的系数（系数之间以空格分隔）

第七行：一元多项式B的各项的指数（指数之间以空格分隔）

如果A或B的项数为0，则认为输入的多项式只包含数字“0”，即系数为0，指数也为0。

输出说明 :

第一行：多项式A的第一项的系数、指数（以空格分隔）

第一行：多项式A的第二项的系数、指数（以空格分隔）

...

第n行：多项式A的第n项的系数、指数（以空格分隔） （假设多项式A的项数为n）

（空行）

第一行：多项式B的第一项的系数、指数（以空格分隔）

第一行：多项式B的第二项的系数、指数（以空格分隔）

...

第m行：多项式B的第m项的系数、指数（以空格分隔） （假设多项式B的项数为m）

（空行）

第一行：加/减法计算后，结果多项式A的第一项的系数、指数（以空格分隔）

第一行：加/减法计算后，结果多项式A的第二项的系数、指数（以空格分隔）

...

第p行：加/减法计算后，结果多项式A的第n项的系数、指数（以空格分隔） （假设结果多项式的项数为p）

 

（多项式之间以空行分隔，如果多项式只包含“0”，则相应的多项式输出"0 0"，不包含引号。）

 

输入范例 :

1
6
7 3 -22 9 5 -8
0 1 7 8 17 100
3
8 22 -9
1 7 8
 

输出范例 :

7 0
3 1
-22 7
9 8
5 17
-8 100

8 1
22 7
-9 8

7 0
-5 1
-44 7
18 8
5 17
-8 100

#include<iostream>
using namespace std;
struct ListNode{
    int xs,zs;
    struct ListNode *next;
};
ListNode *create(ListNode *head){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        ListNode *p=new ListNode;
        p->next=head->next;
        head->next=p;
    }
    ListNode *p1=head;
    while(p1->next){
        p1=p1->next;
        cin>>p1->xs;
    }
    ListNode *p2=head;
    while(p2->next){
        p2=p2->next;
        cin>>p2->zs;
    }
    return head;
}
void Print(ListNode *head){
    ListNode *p=head;
    int n=0;
    while(p->next){
        p=p->next;
        if(p->xs!=0){
        cout<<p->xs<<" "<<p->zs<<endl;
        n=1;
        }
    }
    if(n==0)
        cout<<"0 0"<<endl;
}
ListNode *Plus(ListNode *headA,ListNode *headB,ListNode *headC,int flag){
    ListNode *pA=headA;
    ListNode *pB=headB;
    ListNode *pC=headC;
    while(pA->next&&pB->next){
        if(pA->next->zs==pB->next->zs){
            //链表A与链表B的指数相同时，对系数进行加减
            pA=pA->next;
            pB=pB->next;
            ListNode *r=new ListNode;
            r->zs=pA->zs;
            if(flag==1)
                r->xs=pA->xs-pB->xs;
            else
                r->xs=pA->xs+pB->xs;
            pC->next=r;
            pC=r;
        }
        else if(pA->next->zs<pB->next->zs){
            //链表A的指数小于链表B的指数时，直接将链表A该结点的复制到链表C上
            pA=pA->next;
            ListNode *r=new ListNode;
            r->zs=pA->zs;
            r->xs=pA->xs;
            pC->next=r;
            pC=r;
        }
        else if(pB->next->zs<pA->next->zs){
            //链表B的指数小于链表A的指数时，直接将链表B该结点的复制到链表C上
            pB=pB->next;
            ListNode *r=new ListNode;
            r->zs=pB->zs;
            r->xs=pB->xs;
            pC->next=r;
            pC=r;
        }
    }
    //当链表A或链表B长度过长时
    while(pA->next){
        pA=pA->next;
        ListNode *r=new ListNode;
        r->zs=pA->zs;
        r->xs=pA->xs;
        pC->next=r;
        pC=r;
    }
    while(pB->next){
        pB=pB->next;
        ListNode *r=new ListNode;
        r->zs=pB->zs;
        r->xs=pB->xs;
        pC->next=r;
        pC=r;
    }
    pC->next=NULL;
    return headC;
}
int main()
{
    int flag;
    cin>>flag;
    ListNode *headA=new ListNode;
    ListNode *headB=new ListNode;
    ListNode *headC=new ListNode;
    headA->next=NULL;
    headB->next=NULL;
    headC->next=NULL;
    headA=create(headA);
    headB=create(headB);
    headC=Plus(headA,headB,headC,flag);
    Print(headA);
    cout<<endl;
    Print(headB);
    cout<<endl;
    Print(headC);
    return 0;
}