多项式加法

多项式加法

总时间限制: 1000ms  

内存限制: 5000kB

描述

    我们经常遇到两多项式相加的情况，在这里，我们就需要用程序来模拟实现把两个多项式相加到一起。首先，我们会有两个多项式，每个多项式是独立的一行，每个多项式由系数、幂数这样的多个整数对来表示。

如多项式2x20- x17+ 5x9- 7x7+ 16x5+ 10x4 + 22x2- 15

对应的表达式为：2 20 -1 17 5 9 - 7 7 16 5 10 4 22 2 -15 0。  

为了标记每行多项式的结束，在表达式后面加上了一个幂数为负数的整数对。

同时输入表达式的幂数大小顺序是随机的。

我们需要做的就是把所给的两个多项式加起来。

输入

输入包括多行。
第一行整数n,表示有多少组的多项式需要求和。(1 < n < 100)
下面为2n行整数，每一行都是一个多项式的表达式。表示n组需要相加的多项式。
每行长度小于300。

输出

输出包括n行，每行为1组多项式相加的结果。
在每一行的输出结果中，多项式的每一项用“[x y]”形式的字符串表示，x是该项的系数、y 是该项的幂数。要求按照每一项的幂从高到低排列，即先输出幂数高的项、再输出幂数低的项。
系数为零的项不要输出。

样例输入

2

-1 17 2 20 5 9 -7 7 10 4 22 2 -15 0 16 5 0 -1

2 19 7 7 3 17 4 4 15 10 -10 5 13 2 -7 0 8 -8

-1 17 2 23 22 2 6 8 -4 7 -18 0 1 5 21 4 0 -1

12 7 -7 5 3 17 23 4 15 10 -10 5 13 5 2 19 9 -7

样例输出

[ 2 20 ] [ 2 19 ] [ 2 17 ] [ 15 10 ] [ 5 9 ] [ 6 5 ] [ 14 4 ] [ 35 2 ] [ -22 0 ]

[ 2 23 ] [ 2 19 ] [ 2 17 ] [ 15 10 ] [ 6 8 ] [ 8 7 ] [ -3 5 ] [ 44 4 ] [ 22 2 ] [ -18 0 ]

提示

第一组样例数据的第二行末尾的8 -8，因为幂次-8为负数，所以这一行数据结束，8 -8不要参与计算。

 

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1  
#define OVERFLOW -2

typedef struct    //项的表示，多项式的项作为LinkList的数据元素
{
    float coef;   //系数
    int expn;   //指数
}term, ElemType;   //两个类型名：term用于本ADT，ElemType为LinkList的数据对象名 

typedef struct LNode   //结点类型
{
    ElemType data;
    struct LNode *next;
}LNode, *Link, *Position;

typedef struct   //链表类型
{
    Link head, tail;
    int len;
}LinkList;

typedef LinkList polynomial;   //用带头结点的有序链表表示多项式
typedef int Status;

Status InitList(LinkList *L)  
{  
//     操作结果：构造一个空的线性链表  
    Link p;  
    p = (Link)malloc(sizeof(LNode));  //生成头结点  
    if(p)  
    {  
        p->next = NULL;  
        (*L).head = (*L).tail = p;  
        (*L).len = 0;  
        return OK;  
    }  
    else  
        return ERROR;  
}  

Status MakeNode(Link *p,ElemType e)  
{  
//     操作结果：分配由p指向的值为e的结点，并返回OK；若分配失败。则返回ERROR  
    (*p) = (Link)malloc(sizeof(LNode));  //分配新结点  
    if(!(*p)) return ERROR;              //分配失败  
    (*p)->data = e;  
    return OK;  
}  

Status InsFirst(LinkList *L,Link h,Link s)   //形参增加L,因为需修改L  
{  
//     操作结果：h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前  
    s->next = h->next;  
    h->next = s;  
    if(h==(*L).tail)         //h指向尾结点  
        (*L).tail = h->next; //修改尾指针  
    (*L).len++;  
    return OK;  
}  

Status DelFirst(LinkList *L,Link h,Link *q) //形参增加L,因为需修改L  
{  
//     操作结果：h指向L的一个结点，把h当做头结点，删除链表中的第一个结点并以q返回。若链表为空(h指向尾结点)，q=NULL，返回FALSE  
    *q = h->next;  
    if(*q)                     //链表非空  
    {  
        h->next = (*q)->next;  
        if(!h->next)           //删除尾结点  
            (*L).tail = h;     //修改尾指针, 此时链表已为空表
        (*L).len--;  
        return OK;  
    }  
    else  
        return FALSE;          //链表空  

}

//置空链表L
Status ClearList(LinkList *L)
{
    Link p, q;

    if(L->head != L->tail)
    {
        p = q = L->head->next;
        L->head->next = NULL;

        while(p != L->tail)
        {
            p = q->next;
            free(q);
            q = p;
        }

        free(q);

        L->tail = L->head;
        L->len = 0;
    }
    return OK;
}

Position GetHead(LinkList *L)
{
    return L->head;
}

Position NextPos(Link p)  
{  
    return p->next;  
}  
Position PriorPos(LinkList L, Link p)
{
    Link q;
    q = L.head;

    while(q->next != p)
    {
        q = q->next;
    }
    return q;

}

void FreeNode(Link *p)
{
    free((*p));
    (*p) = NULL;
}

Status ListEmpty(LinkList L)  
{  
// 若线性链表L为空表，则返回TRUE，否则返回FALSE  
    return L.len==0;  
}  

ElemType GetCurElem(Link p)  
{  
//已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值  
    return p->data;  
}  

Status Append(LinkList *L,Link s)  
{  
//将指针s(s->data为第一个数据元素)所指(彼此以指针相链,以NULL结尾)的一串结点链接在线性链表L的最后一个结点之后,并改变链表L的尾指针指向新的尾结点  
    int i=1;  
    (*L).tail->next = s;  //s接到L的尾部  
    while(s->next)        //计算s的长度  
    {  
        i++;  
        s = s->next;  
    }  
    (*L).tail = s;        //L的尾指针变成s的尾指针  
    (*L).len+=i;          //增加长度  
    return OK;  
}
//销毁一元多项式P
void DestroyPolyn(LinkList *L)
{
    ClearList(L);          //清空链表  
    FreeNode(&(*L).head);  //释放头结点  
    (*L).tail = NULL;  
    (*L).len = 0;
}

//依e1的指数的值<,=,>e2的指数值， 分别返回-1,0,1 ，此为升序
int cmp(term e1, term e2)
{
    if(e1.expn == e2.expn) return 0;
    if(e1.expn < e2.expn) return -1;
    return 1;
}

//若有序链表L中存在于e满足判定函数compare()取值为0的元素，则q指示L中第一个值为e
//的结点的位置， 并返回TRUE；否则q指示第一个与e满足判定函数compare()取值>0的元素的前驱的位置，并返回FALSE
Status LocateElem(LinkList L, ElemType e, Position *q, int (*compare)(ElemType, ElemType))
{
    Link p, pp;
    p = L.head;
    do
    {
        pp = p;
        p = p->next;
    }while(p && compare(p->data, e) < 0);   //找到第一个大于等于e的位置

    if(!p || compare(p->data, e) >0)   //到表尾或者找到的位置的值并不相等
    {
        (*q) = pp;   //使q指示第一个大于e的结点的直接前驱
        return FALSE;
    }
    else   //找到相等
    {
        (*q) = p;
        return TRUE;
    }
}

void CreatPolyn(polynomial *P)
{
    //输入m项的系数和指数，建立表示一元多项式系数的有序链表P
    Position q, s;
    int i;
    term e;

    InitList(P);    //初始化P

    //printf("请输入%d个系数，指数：\n", m);
    for(i = 1; ; i++)
    {
        scanf("%f %d", &e.coef, &e.expn);
        if(e.expn<0) break;
        if(!LocateElem(*P, e, &q, cmp))   //当前链表中不存在该指数项。cmp是实参
        {
            if(MakeNode(&s, e))   //生成结点并插入链表
                InsFirst(P, q, s);   //将s插入到q的后一个结点
        }
    }
}

//打印输出一元多项式P
void PrintPolyn(polynomial P)
{
    Link q;
    q = P.head->next;   //q指向第一个结点
    while(q)
    {
        printf("[%.0f  %d] ", q->data.coef, q->data.expn);
        q = q->next;
    }
    printf("\n");
}

//完成多项式相加运算：Pa = Pa + Pb,并销毁一元多项式
void AddPolyn(polynomial *Pa, polynomial *Pb)
{
    Position ha, hb, qa, qb;
    term a, b;

    ha = GetHead(Pa);
    hb = GetHead(Pb);
    qa = NextPos(ha);
    qb = NextPos(hb);
    while(!ListEmpty(*Pa) && !ListEmpty(*Pb) && qa)
    {
        a = GetCurElem(qa);
        b = GetCurElem(qb);
        switch(cmp(a, b))
        {
        case -1:   //Pa中的值较小
            ha = qa;
            qa = NextPos(qa);   //ha和qa均向后移动一个结点
            break;
        case 0:   //Pa和Pb中指数相等
            qa->data.coef += qb->data.coef;
            if(qa->data.coef)
            {
                ha = qa;
            }
            else   //为0则删除多项式Pa中当前结点
            {
                DelFirst(Pa, ha, &qa);
                FreeNode(&qa);
            }
            DelFirst(Pb, hb, &qb);
            FreeNode(&qb);
            qa = NextPos(ha);
            qb = NextPos(hb);
            break;
        case 1:   //多项式Pb中当前结点系数小
            DelFirst(Pb, hb, &qb);
            InsFirst(Pa, ha, qb);
            qb = NextPos(hb);
            ha = NextPos(ha);  
        }
    }
    if(!ListEmpty(*Pb))
    {
        Pb->tail = hb;   //使Pb的指向尾结点的指针指向头结点
        Append(Pa, qb);
    }
    DestroyPolyn(Pb);
}

int main()
{
    polynomial p, q;
    int m;
    scanf("%d",&m);
    for(int i=0;i<m;i++){
    	CreatPolyn(&p);
    	CreatPolyn(&q);
    	AddPolyn(&p, &q);
    	PrintPolyn(p);
    	DestroyPolyn(&p); 
	}
    return 0;
}

该代码输出的指数系数是从小到大输出的，但是题目要求指数系数从大到小输出。