數據結構之一元多項式的加法和乘法

#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("\n\n");
}


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項的多項式\n");
    CreatePolyn(Pa, 4);
    printf("Pa:\n");
    PrintPolyn(Pa);
    CreatePolyn(Pb, 3);
    printf("\nPb:\n");
    PrintPolyn(Pb);
    AddPolyn(Pa, Pb);
    printf("\nPa+Pb:\n");
    PrintPolyn(Pa);
    DestroyList(Pa);
/*******************************測試一元多項式乘法*******************************/
    Pa = (polynomial *)malloc(sizeof(polynomial));
    Pb = (polynomial *)malloc(sizeof(polynomial));
    printf("分別輸入一個4項的多項式和一個3項的多項式\n");
    CreatePolyn(Pa, 4);
    printf("Pa:\n");
    PrintPolyn(Pa);
    CreatePolyn(Pb, 3);
    printf("\nPb:\n");
    PrintPolyn(Pb);
    printf("\nPa * Pb\n");
    Multpolyn(Pa, Pb);
    PrintPolyn(Pa);
    DestroyList(Pa);
return 0;
}

這么多行的代碼不容易啊，雖然里面還有好多函數還沒有實現，等待慢慢補充吧（雖然可能性不大，過段時間估計看着都頭疼了吧，還是要給自己個勇氣嘛）。