数据结构之一元多项式的加法和乘法

#define _CRT_SECURE_NO_DEPRECATE
#include "Polynomial.h"
#include <stdio.h>
#include <stdlib.h>

int ListLength(NormLinkList *L)
{
    int num = 0;
    Link p = NextPos(L, GetHead(L));
    while(p)
    {
        num++;
        p = NextPos(L, p);
    }
    return num;
}//PolynLength()个人觉得这两个函数功能一样

Status MakeNode(Link *p, ElemType e)
{
    //分配由*p指向的值为e的节点，并返回OK；若分配失败，则返回ERROR（此处使用了指向指针的指针p，*p为节点的地址）
    *p = (Link)malloc(sizeof(NormLNode));
    if(!(*p))
        return ERROR;
    (*p)->data = e;
    (*p)->next = NULL;
    return OK;
}

void FreeNode(Link p)
{
    //释放p所指节点
    free(p);
}


Status InitList(NormLinkList *L)
{
    //构造一个空的线性链表L
    L->head = (Link)malloc(sizeof(NormLNode));//生成头节点
    if(!(L->head))
        return ERROR;
    L->head->next = NULL;
    L->tail = L->head;
    L->len = 0;
    return OK;
}


Status DestroyList(NormLinkList *L)
{
    //销毁线性链表L，L不再存在
    Link p = L -> head -> next;//p指向L的第一个节点
    Link q;
    while(p)
    {
        q = p -> next;
        free(p);
        p = q;
    }
    free(L -> head);//释放头节点空间
    free(L);
    return OK;
}


Status ClearList(NormLinkList *L)
{
    //将线性链表L重置为空表(仅有头节点)，并释放原链表的存储空间
    Link p = L -> head -> next;//p指向L的第一个节点
    Link q;
    while(p)
    {
        q = p -> next;
        free(p);
        p = q;
    }
    L -> head -> next = NULL;
    L -> tail = L -> head;
    L -> len = 0;
    return OK;
}


Status InsFirst(Link h, Link s)
{
    //将s所指节点插入在第一个节点之前
    if(h && s)
    {
        s -> next = h -> next;
        h -> next = s;
        return OK;
    }
    else
        return ERROR;
}


Status DelFirst(Link h, Link *q)
{
    //删除链表中的第一个节点，并用q返回
    *q = h -> next;//*q指向待删除节点
    h -> next = (*q) -> next;
    (*q)->next = NULL;//非常重要，否则*q会链接到剩余的节点
    return OK;
}


Status Append(NormLinkList *L, Link s)
{
    //将指针s所指（彼此以指针相链接）的一串节点链接在线性链表L的最后一个节点之后，
    //并改变链表L的尾指针指向新的尾节点
    Link p = s, q = s;//p指向s，q保持在p前面
    int j = 0;//指示s中的节点个数，用于更新L->len，考虑到了s为空的情况，此时while条件不满足，j为0
    if(!UpdateTail(L))
        return ERROR;
    L -> tail -> next = s;
    while(p)
    {
        //退出时，q指向s中最后一个节点，j为s中的节点个数
        j++;
        q = p;
        p = p -> next;
    }
    L -> tail = q;
    L -> len += j;
    return OK;
}


Status UpdateTail(NormLinkList *L)
{
    //注意L为空表的情况
    //更新L的尾节点，并更新链表长度
    Link p = L -> head -> next, q = L -> head -> next;//p指向链表第一个节点，q保持在p前面
    int j = 0;//指示s中的节点个数，用于更新L->len，考虑到了s为空的情况，此时while条件不满足，j为0
    if(!(L->head->next))//考虑L为空的情况，此时若执行后面语句，会导致L->tail指向NULL，使得Append函数的L->tail->next = s;语句访存冲突
        return OK;
    while(p)
    {
        //退出时，q指向L中最后一个节点，j为L中的节点个数(仅在L非空时有效)
        j++;
        q = p;
        p = p -> next;
    }
    L -> tail = q;
    L -> len = j;
    return OK;
}


Position GetHead(NormLinkList *L)
{
    //返回线性链表L中头节点的位置
    return L -> head;
}


Position NextPos(NormLinkList *L, Link p)
{
    //已知p指向线性链表L中的一个节点，返回p所指节点的直接后继的位置，若无后继，则返回NULL
    return p->next;
}


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


Status LocatePos(NormLinkList *L, int i, Link *p)
{
    //用*p返回线性链表L中第i个节点的位置并返回OK，i值不合法时返回ERROR。此处p为指向指针的指针，用于返回第i个节点的地址
    //0 <= i <= 表长；（i取0时，返回头节点位置，用于在L的第一个节点前插入元素，ListInsert_NL调用时会用到）
    Link q = L -> head;//q指向L中的头节点
    int j = 0;
    while(q && j < i)
    {
        //退出时，q == NULL，或者j == i
        q = q->next;
        j++;
    }
    if(!q || j > i)//q为空，或者 i < 0，即第i个元素不存在
        return ERROR;
    *p = q;//此时q指向L中第i个节点的位置
    return OK;
}


Status SetCurElem(Link p, ElemType e)
{
    //已知p指向线性链表中的一个节点，用e更新p所指节点中数据元素的值
    if(p)
        p->data = e;
    else
        return ERROR;
    return OK;
}


Status LocateElem(NormLinkList *L, ElemType e, Position *q, Status (* compare)(ElemType, ElemType))
{
    //若有序链表L中存在与e满足判定函数compare()取值为0的元素，则*q指示L中第一个值为e的节点的位置，并返回TRUE
    //否则*q指示第一个与e满足判定函数compare()取值>0的元素的前驱的位置，并返回FALSE。此处p为指向指针的指针，用于返回满足条件的节点的地址
    Position p = L -> head, r = L -> head -> next;//p指向L中的头节点,r作为p的直接后继
    while(r && (* compare)(r -> data, e) < 0)
    {
        //退出时，要么r为NULL，要么r->data的指数项等于或者大于e的指数项
        p = r;
        r = r->next;
    }
    if(r == NULL)
    {
        //要么表为空，要么e的指数项大于L中的最高指数项，此时返回r的直接前驱p
        *q = p;
        return FALSE;
    }
    else
    {
        //r不为空
        if((* compare)(r->data, e) == 0)
        {
            //存在与e指数项相同的节点，此时r指向该节点
            *q = r;
            return TRUE;
        }
        else
        {
            //不存在与e指数项相同的节点，此时r->data的指数项大于e的指数项，此时返回r的直接前驱p
            *q = p;
            return FALSE;
        }
    }

}


Status ListEmpty(NormLinkList *L)
{
    //若线性链表L为空表，则返回TRUE，否则返回FALSE
    if(L -> head -> next == NULL)
        return TRUE;
    else
        return FALSE;
}


Status ListInsert_NL(NormLinkList *L, int i, ElemType e)
{
    //在带头节点的单链线性表L的第i个元素之前插入元素e
    Link *h = (Link *)malloc(sizeof(Link));
    Link *s = (Link *)malloc(sizeof(Link));
    if(!LocatePos(L, i-1, h))//i值在链表范围之外，即i<=0,或者i>表长；否则，通过*h返回L中的第i-1个节点的位置
        return ERROR;
    if(!MakeNode(s, e))//结点存储分配失败；否则，通过*s返回新生成的节点地址
        return ERROR;
    InsFirst(*h, *s);//将节点*s插入到节点*h后面
    return OK;
}


Status MergeList_NL(NormLinkList *La, NormLinkList *Lb, NormLinkList *Lc, int (* compare)(ElemType, ElemType))
{
    //UpdateTail函数中未处理表为空的情况
    //已知单链线性表La和Lb的元素按值非递减排列
    //归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列
    Position ha = GetHead(La);
    Position hb = GetHead(Lb);//ha，hb分别指向La，Lb的头节点
    Position pa = NextPos(La, ha);
    Position pb = NextPos(Lb, hb);//pa,pb分别指向La，Lb的当前节点（第一个节点）
    ElemType a, b;
    Link *q = (Link *)malloc(sizeof(Link));
    while(pa && pb)
    {
        //pa，pb均不为空
        a = GetCurElem(pa);
        b = GetCurElem(pb);//a,b为两表中待比较元素
        if((* compare)(a, b) <= 0)
        {
            //a <= b
            DelFirst(ha, q);
            Append(Lc, *q);
            pa = NextPos(La, ha);
        }
        else
        {
            //a > b
            DelFirst(hb, q);
            Append(Lc,*q);
            pb = NextPos(Lb, hb);
        }
    }
    if(pa)
        Append(Lc, pa);
    else
        Append(Lc, pb);
    FreeNode(ha);
    FreeNode(hb);
    return OK;
}


int cmp(term a, term b)
{
    //根据a的指数值<(或=)(或>)b的指数值，分别返回-1,0,+1
    if(a.expn < b.expn)
        return -1;
    else if(a.expn == b.expn)
        return 0;
    else
        return 1;
}


void CreatePolyn(polynomial *P, int m)
{
    //输入m项的系数和指数，建立表示一元多项式的有序链表P
    //最多能输入m项，若输入指数相同的项，则后输入项会被丢弃
    Position h;
    Position *q = (Position *)malloc(sizeof(Position));//指针使用前一定要先初始化
    Position *s = (Position *)malloc(sizeof(Position));
    term e;
    int i;
    InitList(P);
    h = GetHead(P);
    e.coef = 0.0;
    e.expn = -1;
    SetCurElem(h, e);
    for(i = 1; i <= m; i++)
    {
        scanf("%f %d", &(e.coef), &(e.expn));
        if(!(LocateElem(P, e, q, cmp)))
        {
            //当前链表不存在该指数项
            if(MakeNode(s, e))//生成节点并插入链表
                InsFirst(*q, *s);
        }
    }
}


void PrintPolyn(polynomial *P)
{
    //打印输出一元多项式
    Position p = P -> head -> next;//p指向链表P的第一个节点
    int i = 1;
    while(p)
    {
        if(i != 1)
            printf(" + ");
        printf("%fx^%d", p->data.coef, p->data.expn);
        p = p->next;
        i++;
    }
    printf("

");
}


void AddPolyn(polynomial *Pa, polynomial *Pb)
{
    //完成多项式相加运算，即：Pa = Pa + Pb，并销毁一元多项式Pb
    term a, b;
    int diff;
    float sum;
    Position *dp = (Position *)malloc(sizeof(Position));//*dp中用于保存被删除节点的地址
    Position ha = GetHead(Pa);
    Position hb = GetHead(Pb);//ha,hb分别指向Pa,Pb的头节点
    Position qa = NextPos(Pa, ha);
    Position qb = NextPos(Pb, hb);//qa,qb分别指向Pa,Pb的当前待处理结点
    while(qa && qb)
    {
        //qa与qb均为非空
        a = GetCurElem(qa);
        b = GetCurElem(qb);//a,b为当前待比较元素
        diff = cmp(a, b);
        if(diff == -1)
        {
            //多项式Pa中当前结点的指数值小
            ha = qa;
            qa = NextPos(Pa, qa);//ha指向qa，qa往后走
        }
        else if(diff == 0)
        {
            sum = a.coef + b.coef;
            if(sum != 0.0)
            {
                //修改多项式Pa中当前结点的系数值
                a.coef = sum;
                SetCurElem(qa, a);//教材此处有误，第二个参数应为term类型
                ha = qa;//此处为后面qa = NextPos(Pa, ha)做准备，使得当qa指向节点不被删除时，ha即相当于qa
            }
            else
            {
                //删除多项式Pa中当前结点
                DelFirst(ha, dp);//此处使用dp，为了跟DelFirst的函数原型匹配，因此与教材写法不同
                FreeNode(*dp);//实际*dp的内容就是qa
            }
            DelFirst(hb,dp);//此处使用dp，为了跟DelFirst的函数原型匹配，因此与教材写法不同
            FreeNode(*dp);//实际*dp的内容就是qb
            qb = NextPos(Pb, hb);
            qa = NextPos(Pa, ha);
        }
        else
        {
            //多项式Pb中当前结点的指数值小
            DelFirst(hb, dp);//此处使用dp，为了跟DelFirst的函数原型匹配，因此与教材写法不同
            InsFirst(ha, *dp);//将Pb的当前节点接在ha后面,实际*dp的内容就是qb
            qb = NextPos(Pb, hb);
            ha = NextPos(Pa, ha);//ha指向刚插入的节点，即*dp
        }
    }//while
    if(!ListEmpty(Pb))
        Append(Pa, qb);//链接Pb中剩余节点
    FreeNode(hb);
}


void Multpolyn(polynomial *Pa, polynomial *Pb)
{
    //实现两个一元多项式的乘法
    float coef0 = 0.0; int expn0 = 0; ElemType a;
    Link mid0 = NULL, mid1 = NULL, mid2 = NULL;
    Link PaH = GetHead(Pa);
    polynomial *pa = (polynomial *)malloc(sizeof(polynomial));
    polynomial *Pc = (polynomial *)malloc(sizeof(polynomial));
    polynomial *Pd = (polynomial *)malloc(sizeof(polynomial));

    PaH = NextPos(Pa, PaH);//PaH -> next
    a = GetCurElem(PaH);//PaH->data
    coef0 = a.coef;
    expn0 = a.expn;

    InitList(pa); InitList(Pc); InitList(Pd);//init

    pa -> head -> data = GetCurElem(GetHead(Pa));//Pa ->head->data;
    mid0 = NextPos(Pa, (GetHead(Pa)));//mid0 = Pa -> head->next
    pa -> head -> next = NULL;
    mid1 =GetHead(pa);//pa -> head;
    while(mid0)
    {
        //完成Pa的copy
        mid1 -> next = (Link)malloc(sizeof(NormLNode));
        mid1 = NextPos(pa,mid1);//mid1 -> next,
        mid1 ->next = NULL;
        mid1->data = GetCurElem(mid0);
        //mid1 -> data.coef = mid0 -> data.coef, mid1 -> data.expn = mid0 -> data.expn;
        mid0 = NextPos(Pa, mid0);//mid0 -> next;
    }
    pa -> tail = mid1, pa -> len = Pa -> len;//处理pa的尾结点和长度

    mid0 = NextPos(Pa, GetHead(Pa));//Pa -> head -> next
    while(mid0)
    {
        //完成Pa 与 Pb第一项相乘
        mid0 -> data.coef = mid0 -> data.coef * coef0, mid0 -> data.expn = mid0 -> data.expn + expn0;
        mid0 = NextPos(Pa, mid0);//mid0 -> next;
    }

    //完成后续工作
    //mid0 = pa -> head -> next;
    //mid1 = Pc -> head;
    mid2 = NextPos(Pb,NextPos(Pb,GetHead(Pb)));//Pb -> head -> next -> next;
    while(mid2)
    {
        mid1 = GetHead(Pc);//Pc -> head;
        mid0 = NextPos(pa,GetHead(pa));//pa -> head -> next;
        while(mid0)
        {
            mid1 -> next = (Link)malloc(sizeof(NormLNode));
            mid1 = NextPos(Pc, mid1);//mid1 -> next;
            mid1 -> data.coef = mid0 -> data.coef * mid2 -> data.coef;
            mid1 -> data.expn = mid0 -> data.expn +mid2 -> data.expn;
            mid0 = NextPos(pa, mid0);//mid0 -> next;
        }
        mid1 -> next = NULL;//处理尾巴，否则Append（）函数中while循环无法判定
        Pc -> tail = mid1;
        AddPolyn(Pa, Pc);
        Pc = (polynomial *)malloc(sizeof(polynomial));
        InitList(Pc);
        mid2 = NextPos(Pb, mid2);//mid2 -> next;
    }
    Pa -> len = ListLength(Pa);
}


int main()
{
/*******************************测试一元多项式加法*******************************/
    polynomial *Pa = (polynomial *)malloc(sizeof(polynomial));
    polynomial *Pb = (polynomial *)malloc(sizeof(polynomial));
    printf("分别输入一个4项的多项式和一个3项的多项式
");
    CreatePolyn(Pa, 4);
    printf("Pa:
");
    PrintPolyn(Pa);
    CreatePolyn(Pb, 3);
    printf("
Pb:
");
    PrintPolyn(Pb);
    AddPolyn(Pa, Pb);
    printf("
Pa+Pb:
");
    PrintPolyn(Pa);
    DestroyList(Pa);
/*******************************测试一元多项式乘法*******************************/
    Pa = (polynomial *)malloc(sizeof(polynomial));
    Pb = (polynomial *)malloc(sizeof(polynomial));
    printf("分别输入一个4项的多项式和一个3项的多项式
");
    CreatePolyn(Pa, 4);
    printf("Pa:
");
    PrintPolyn(Pa);
    CreatePolyn(Pb, 3);
    printf("
Pb:
");
    PrintPolyn(Pb);
    printf("
Pa * Pb
");
    Multpolyn(Pa, Pb);
    PrintPolyn(Pa);
    DestroyList(Pa);
return 0;
}

这么多行的代码不容易啊，虽然里面还有好多函数还没有实现，等待慢慢补充吧（虽然可能性不大，过段时间估计看着都头疼了吧，还是要给自己个勇气嘛）。