数据结构 -- 多项式相加和相乘

这是数据结构的实验~~

由于某些实验要上交，所以一部分的程序的代码改为英语注释了

这是求解多项式相加和相乘的算法实现。

采用线性表就可以实现了。

代码可能有点繁杂，因为线性表的实现也包括在里面了。

 

Experiment1_1.h ，算法的实现的头文件。

/* Experiment1_1.h */

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -   
//  实验题1.1  问题描述：   
//  有两个指数递减的一元多项式，写一程序先求这两个多项式的和，再求它们的积。  
//   
//  提示 1 ：
//  用带表头结点的单链表作为多项式的存储表示；
//  要建立两个单链表；
//  多项式相加就是要把一个单链表中的结点插入到另一个单链表中去，要注意插入、删除操作中指针的正确修改。 
//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -   

#include <iostream>
using namespace std;

// - - - - base constant value - - - - - 
const int OK    = 1;
const int FAIL  = 0;
const int EQUAL = 1; // equal to
const int BIG   = 2; // bigger than
const int LESS  = 3; // less than


// - - - - data structure - - - - - 

// element of Polynomial
typedef struct
{
    float coef;
    int   expn;
}term, ElemType;

// node of linklist
typedef struct LinkList
{
    term e;
    struct LinkList* next;
}LinkList, LNode, Polynomial;


// - - - - - - base functions - - - - - - 

int  InitList(LinkList*& L);
int  SetCurElem(LNode*& h, const ElemType e);
int  MakeNode(LNode*& s, const ElemType e);
int  InsFirst(LNode*& q, LNode*& s);
int  compare(const term a, const term b);
int  LocateElem(LinkList* L, const ElemType e, LNode*& q);
void CreatPolyn(Polynomial*& P, const int m);
void DestroyPolyn(Polynomial*& P);
void CopyPolyn(Polynomial*& P, const Polynomial* copy);
int  PrintPolyn(const Polynomial* P);
void AddPolyn(Polynomial*& Pa, Polynomial*& Pb);
void MutilplyPolyn(Polynomial*& Pa, Polynomial*& Pb);


// add pa to pb and destroy pb
void AddPolyn(Polynomial*& Pa, Polynomial*& Pb)
{
    // aCur point to the current node of pa
    // aPrior point to the prior node of aCur
    // bCur point to the current node of pb
    // tmp pointer used temporary 
    LNode* aCur;
    LNode* aPrior;
    LNode* bCur;
    LNode* tmp;

    // initialize the pointers
    aPrior = Pa;
    aCur = aPrior->next;
    bCur = Pb->next;

    // result save the result of the compare function
    // forDelete point to the node to be deleted
    int result;
    LNode* forDelete;

    // polynomial addition
    while (aCur && bCur) {
        result = compare(aCur->e, bCur->e);
        switch (result) {
            // add the b's coef to a
        case EQUAL:
            aCur->e.coef += bCur->e.coef;

            forDelete = bCur;
            bCur = bCur->next;
            delete forDelete;

            if (aCur->e.coef == 0.0) {
                forDelete = aCur;
                aCur = aCur->next;
                aPrior->next = aCur;
                delete forDelete;
            }
            break;
            // aCur point to the next node
        case BIG:
            aPrior = aPrior->next;
            aCur = aPrior->next;
            break;
            // insert bCur to aCur's prior node
        case LESS:
            tmp = bCur;
            bCur = bCur->next;
            aPrior->next = tmp;
            tmp->next = aCur;
            aPrior = aPrior->next;
            break;
        default:
            break;
        }
    }
    // if aCur=NULL then add b's rest nodes to the rear of a
    if (!aCur) {
        aPrior->next = bCur;
    }

    delete Pb;
}

// multiply b to a, and destroy b
void MutilplyPolyn(Polynomial*& Pa, Polynomial*& Pb)
{
    // Pa = A(x) = sum(ai * x ^ aei), i=1...m;
    // Pb = B(x) = sum(bi * x ^ bei), i=1...n;
    // Pa*Pb = sum(bi * A(x) * x^bei) = sum( sum((aj * bi) * x^(aej+bei)), j=1...m ), i=1...n;

    // backupPa save the copy of Pa
    // backupPa = A(x) = sum(ai * x ^ aei), i=1...m;
    // tmp memorize the intermediate result
    // tmp = sum((aj * bi) * x^(aej+bei)), j=1...m
    Polynomial* backupPa;
    Polynomial* tmp;

    // aCur point to backupPa
    LNode* aCur;
    LNode* bCur;
    LNode* tmpCur;

    // copy pa to backupPa and tmp
    CopyPolyn(backupPa, Pa);
    CopyPolyn(tmp, Pa);

    // preprocessing Pa:first destroy Pa then save the first result in Pa
    bCur = Pb->next;
    aCur = backupPa->next;
    tmpCur = tmp->next;
    while (aCur) {
        tmpCur->e.coef = bCur->e.coef * aCur->e.coef;
        tmpCur->e.expn = bCur->e.expn + aCur->e.expn;
        aCur = aCur->next;
        tmpCur = tmpCur->next;
    }
    bCur = bCur->next;
    DestroyPolyn(Pa);
    CopyPolyn(Pa, tmp);

    // multiply the two polynomial,add tmp to Pa when finish a intermediate result
    while (bCur) {
        CopyPolyn(tmp, Pa);
        aCur = backupPa->next;
        tmpCur = tmp->next;
        while (aCur) {
            tmpCur->e.coef = bCur->e.coef * aCur->e.coef;
            tmpCur->e.expn = bCur->e.expn + aCur->e.expn;
            aCur = aCur->next;
            tmpCur = tmpCur->next;
        }
        AddPolyn(Pa, tmp);
        bCur = bCur->next;
    }

    DestroyPolyn(Pb);
}

// initialize the linklist
int InitList(LinkList*& L)
{
    L = new LinkList;
    if (!L) {
        return FAIL;
    }
    L->next = NULL;
    return OK;
}

// set the node h to the value e
int SetCurElem(LNode*& h, const ElemType e)
{
    if (!h) {
        return FAIL;
    }
    else {
        h->e.coef = e.coef;
        h->e.expn = e.expn;
        return OK;
    }
}

// make a node using value e, use the pointer s to point to the node
int MakeNode(LNode*& s, const ElemType e)
{
    s = new LNode;
    if (!s) {
        return FAIL;
    }
    else {
        s->e.coef = e.coef;
        s->e.expn = e.expn;
        s->next = NULL;
    }
    return OK;
}

// to insert the node s after node q
int InsFirst(LNode*& q, LNode*& s)
{
    if (q == NULL || s == NULL) {
        return FAIL;
    }
    else {
        s->next = q->next;
        q->next = s;
        return OK;
    }
}

// compare two term
int compare(const term a, const term b)
{
    if (a.expn == b.expn) {
        return EQUAL;
    }
    else if (a.expn > b.expn) {
        return BIG;
    }
    else {
        return LESS;
    }
}

// locate the value e, if successed, return OK and q point to the position;
// else return FAIL and q point to the position which node first less than e
int LocateElem(LinkList* L, const ElemType e, LNode*& q)
{
    LinkList* h;
    h = L->next;
    q = L;
    int result;
    while (h) {
        result = compare(h->e, e);
        if (result == EQUAL) {
            q = h;
            return OK;
        }
        else if (result == LESS) {
            return FAIL;
        }
        else {
            h = h->next;
            q = q->next;
        }
    }
    return FAIL;
}

// create the polunomial with the input value
void CreatPolyn(Polynomial*& P, const int m)
{
    InitList(P);

    term e;
    e.coef = 0.0;
    e.expn = -1;
    SetCurElem(P, e);

    int i;
    LNode* q;
    LNode* s;
    for (i = 1; i <= m; i++) {
        cout << "/ - ";
        cin >> e.coef >> e.expn;
        if (e.coef == 0.0) {
            continue;
        }
        if (LocateElem(P, e, q) == FAIL) {
            if (MakeNode(s, e)) {
                InsFirst(q, s);
            }
        }
    }
}

// destroy the polynomial
void DestroyPolyn(Polynomial*& P)
{
    if (P) {
        LNode* q;
        LNode* s;
        q = P;
        while (q->next) {
            s = q;
            q = q->next;
            delete s;
        }
        delete q;
    }
}

// print the polynomial
int PrintPolyn(const Polynomial* P)
{
    if (!P) {
        return FAIL;
    }
    LNode* s;
    s = P->next;
    if (s) {
        cout << s->e.coef << "*X^" << s->e.expn;
        s = s->next;
    }
    while (s) {
        cout << " + " << s->e.coef << "*X^" << s->e.expn;
        s = s->next;
    }
    return OK;
}

// copy the polynomial 'copy' to the polynomial p
void CopyPolyn(Polynomial*& P, const Polynomial* copy)
{
    InitList(P);

    term e;
    e.coef = 0.0;
    e.expn = -1;
    SetCurElem(P, e);

    LNode* q;
    LNode* r;
    LNode* s;
    r = P;
    s = copy->next;
    while (s) {
        q = new LNode;
        q->e.coef = s->e.coef;
        q->e.expn = s->e.expn;
        q->next = NULL;
        r->next = q;
        r = r->next;

        s = s->next;
    }
}

test.cpp，应用算法完成多项式的加法和乘法

/* test.cpp */

#include "Experiment1_1.h"

void main()
{
    Polynomial* P1;
    Polynomial* P2;
    Polynomial* backupP1;
    Polynomial* backupP2;
    int m1;
    int m2;

    cout << "/ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - /" << endl;
    cout << "/ -            实验题1.1  求两多项式的和，积                  - /" << endl;
    cout << "/ -                                                       - /" << endl;
    cout << "/ -    输入规则：系数 指数                                   - /" << endl;
    cout << "/ -    例：多项式：3 * x ^ 5，输入3 5                        - /" << endl;
    cout << "/ -                                                       - /" << endl;
    cout << "/ -    注：各项的指数不能相同，否则会忽略相同项                  - /" << endl;
    cout << "/ -    注：系数不能为0，否则会忽略该项                         - /" << endl;
    cout << "/ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - /" << endl;

    cout << endl;
    cout << "/ - 输入多项式P1的项数：";
    cin >> m1;
    cout << "/ - 输入多项式的数据：" << endl;
    CreatPolyn(P1, m1);
    cout << "/ - P1 = ";
    PrintPolyn(P1);
    cout << endl;
    cout << endl;

    cout << "/ - 输入多项式P2的项数：";
    cin >> m2;
    cout << "/ - 输入多项式的数据：" << endl;
    CreatPolyn(P2, m2);
    cout << "/ - P2 = ";
    PrintPolyn(P2);
    cout << endl;
    cout << endl;

    CopyPolyn(backupP1, P1);
    CopyPolyn(backupP2, P2);

    cout << "/ - P1 + P2 = ";
    AddPolyn(P1, P2);
    PrintPolyn(P1);
    cout << endl;
    cout << endl;
    DestroyPolyn(P1);

    cout << "/ - P1 * P2 = ";
    MutilplyPolyn(backupP1, backupP2);
    PrintPolyn(backupP1);
    cout << endl;
    cout << endl;

    DestroyPolyn(backupP1);
}