順序表實現一元稀疏多項式

***********************一元稀疏多項式。h**********************************

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define OK 1
#define FLASE 0
#define OVERFLOW -1
typedef int Status;

/*typedef struct {
    float coef; //係數
    int expn;  //指數
}ElemType, Term;

typedef struct {
    Term *elem;  //存儲空間基址
    int length;  //長度
}Poly;*/

    /*
    //接口定義
    Status CreatePoly(Poly &P, Term e[], int n);
    //有數組e的前n項構建一元稀疏多項式P
    Status DestroyPoly(Poly &P);//銷燬一元稀疏多項式P
    Status PrintPoly(Poly P);//打印輸出一元稀疏多項式P
    int PolyLength(Poly P);//一元稀疏多項式P存在，則返回P中的項數
    Status AddPoly(Poly pa, Poly pb, Poly &pc);
    //兩個一元稀疏多項式做加法，即pc = pa + pb
    Status SubPoly(Poly pa, Poly pb, Poly &pc);
    //兩個一元稀疏多項式做減法，即pc = pa - pb
    Status MulPoly(Poly pa, Poly pb, Poly &pc);
    //兩個一元稀疏多項式做乘法，即pc = pa * pb
    Status DivPoly(Poly pa, Poly pb, Poly &pc);
    //兩個一元稀疏多項式做除法，即pc = pa / pb
    */
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define OK 1
#define FLASE 0
#define OVERFLOW -1
typedef int Status;

/*typedef struct {
    float coef; //係數
    int expn;  //指數
}ElemType, Term;

typedef struct {
    Term *elem;  //存儲空間基址
    int length;  //長度
}Poly;*/

    /*
    //接口定義
    Status CreatePoly(Poly &P, Term e[], int n);
    //有數組e的前n項構建一元稀疏多項式P
    Status DestroyPoly(Poly &P);//銷燬一元稀疏多項式P
    Status PrintPoly(Poly P);//打印輸出一元稀疏多項式P
    int PolyLength(Poly P);//一元稀疏多項式P存在，則返回P中的項數
    Status AddPoly(Poly pa, Poly pb, Poly &pc);
    //兩個一元稀疏多項式做加法，即pc = pa + pb
    Status SubPoly(Poly pa, Poly pb, Poly &pc);
    //兩個一元稀疏多項式做減法，即pc = pa - pb
    Status MulPoly(Poly pa, Poly pb, Poly &pc);
    //兩個一元稀疏多項式做乘法，即pc = pa * pb
    Status DivPoly(Poly pa, Poly pb, Poly &pc);
    //兩個一元稀疏多項式做除法，即pc = pa / pb
    */

*********************************************源代碼.h********************************************************

#include "一元稀疏多項式.h"

typedef struct {
    float coef; //係數
    int expn;  //指數
}ElemType, Term;

typedef struct {
    Term *elem;  //存儲空間基址
    int length;  //長度
}Poly;

//構建一元稀疏多項式
Status CreatePoly(Poly &P, Term e[], int n) {
    int i;
    P.elem = (Term*)malloc(sizeof(Term)*n);
    if (NULL == P.elem) return OVERFLOW;
    for (i = 0; i < n; i++) P.elem[i] = e[i];
    P.length = n;
    return OK;
}


//銷燬一元稀疏多項式P
Status DestroyPoly(Poly &P) {
    if (P.elem == NULL)
        return OVERFLOW;
    else
        free(P.elem);
    printf("\n銷燬成功\n");
    return OK;
}

//打印輸出一元稀疏多項式P
Status PrintPoly(Poly P) {
    int i;
    printf("多項式:");
    for (i = 0; i < P.length; i++) {
        if (i == P.length - 1)
            printf("%4.2fx^%d\n", P.elem[i].coef, P.elem[i].expn);
        else
            printf("%4.2fx^%d + ", P.elem[i].coef, P.elem[i].expn);
        
    }
    return OK;
}

//一元稀疏多項式P存在，則返回P中的項數
int PolyLength(Poly P) {
    return P.length;
}

//實現一元稀疏多項式加法
Status AddPoly(Poly pa, Poly pb, Poly &pc) {//兩個一元稀疏多項式做加法，即pc=pa+pb
    int i = 0, j = 0, k = 0;
    float c;
    pc.elem = (Term*)malloc((pa.length + pb.length) * sizeof(Term));
    if (NULL == pc.elem) return OVERFLOW;
    while (i < pa.length&&j < pb.length) {//兩個多項式均未處理結束
        if (pa.elem[i].expn < pb.elem[j].expn)//pa項的指數較小，添加pc
            pc.elem[k++] = pa.elem[i++];
        else if (pa.elem[i].expn > pb.elem[j].expn)//pb項的指數較小，添加到pc
            pc.elem[k++] = pb.elem[j++];
        else {//pa，pb指數相等
            c = pa.elem[i].coef + pb.elem[j].coef;//係數相加
            if (c != 0) {//係數和不爲0，構建和項，並添加到pc
                pc.elem[k].expn = pa.elem[i].expn;
                pc.elem[k].coef = c;
                k++;
            }
            i++;
            j++;//pa和pb均取下一項
        }
    }
    if (i == pa.length)//pa已處理完，將pb剩餘部分添加到pc
        while (j < pb.length)
            pc.elem[k++] = pb.elem[j++];
    if (j == pb.length)//pb已處理完，將pa剩餘部分加到pc
        while (i < pa.length)
            pc.elem[k++] = pa.elem[i++];
    if (k < pa.length + pb.length)
        if (NULL == (pc.elem = (Term*)realloc(pc.elem, k * sizeof(Term))))
            return OVERFLOW;
    pc.length = k;
}

//兩個一元稀疏多項式做減法，即pc = pa - pb
Status SubPoly(Poly pa, Poly pb, Poly &pc) {//兩個一元稀疏多項式做減法，即pc=pa-pb
    int i = 0, j = 0, k = 0;
    float c;
    pc.elem = (Term*)malloc((pa.length + pb.length) * sizeof(Term));
    if (NULL == pc.elem) return OVERFLOW;
    while (i < pa.length&&j < pb.length) {//兩個多項式均未處理結束
        if (pa.elem[i].expn < pb.elem[j].expn)//pa項的指數較小，添加pc
            pc.elem[k++] = pa.elem[i++];
        else if (pa.elem[i].expn > pb.elem[j].expn)//pb項的指數較小，添加到pc
            pc.elem[k++] = pb.elem[j++];
        else {//pa，pb指數相等
            c = pa.elem[i].coef - pb.elem[j].coef;//係數相減
            if (c != 0) {//係數和不爲0，構建和項，並添加到pc
                pc.elem[k].expn = pa.elem[i].expn;
                pc.elem[k].coef = c;
                k++;
            }
            i++;
            j++;//pa和pb均取下一項
        }
    }
    if (i == pa.length)//pa已處理完，將pb剩餘部分添加到pc
        while (j < pb.length)
            pc.elem[k++] = pb.elem[j++];
    if (j == pb.length)//pb已處理完，將pa剩餘部分加到pc
        while (i < pa.length)
            pc.elem[k++] = pa.elem[i++];
    if (k < pa.length + pb.length)
        if (NULL == (pc.elem = (Term*)realloc(pc.elem, k * sizeof(Term))))
            return OVERFLOW;
    pc.length = k;
}

//兩個一元稀疏多項式做乘法，即pc = pa * pb
Status MulPoly(Poly pa, Poly pb, Poly &pc) {//兩個一元稀疏多項式做乘法，即pc=pa*pb
    int i = 0, j = 0, k = 0, m = 0;
    int flag;
    float c;
    Poly temp;
    temp.elem = (Term*)malloc((pa.length*pb.length) * sizeof(Term));
    pc.elem = (Term*)malloc((pa.length*pb.length) * sizeof(Term));
    if (NULL == pc.elem || NULL == temp.elem)
        return OVERFLOW;
    while (i < pa.length) {
        while (j < pb.length) {//pa中的每一項去乘於pb中的每一項
            temp.elem[k].coef = (pa.elem[i].coef) * (pb.elem[j].coef);//係數相乘
            temp.elem[k].expn = (pa.elem[i].expn) + (pb.elem[j].expn);//指數相加
            k++;
            j++;//指向下一項
        }
        i++;
        j = 0;//將j重新賦值爲0
    }
    while (j < k) {//將一元稀疏多項式temp中可合併的項合併賦給pc
        flag = 1;
        if (temp.elem[j].coef == 0) {
            j++;
            continue;
        }
        i = j + 1;//i指向j的下一項
        while (i < k) {
            if (temp.elem[j].expn == temp.elem[i].expn) {//如果指數相同，則將係數相加
                c = temp.elem[j].coef + temp.elem[i].coef;
                if (c != 0) {//如果係數和不爲0，則構建和項，並添加到pc
                    pc.elem[m].expn = temp.elem[j].expn;
                    pc.elem[m].coef = c;
                    temp.elem[i].coef = 0;
                    m++;
                    flag = 0;
                }
            }
            i++;
        }
        if (flag) 
            pc.elem[m++] = temp.elem[j];
            j++;    
    }
    if (m < pa.length*pb.length)
        if (NULL == (pc.elem = (Term*)realloc(pc.elem, m * sizeof(Term))))
            return OVERFLOW;
    pc.length = m;
    free(temp.elem);
    return OK;
}


//兩個一元稀疏多項式做除法，即pc = pa / pb
Status DivPoly(Poly pa, Poly pb, Poly &pc) {//兩個一元稀疏多項式做除法，即pc=pa/pb
    int i = 0, j = 0, k = 0, m = 0;
    float c = 0;
    int flag;
    Poly temp;
    temp.elem = pc.elem = (Term*)malloc((pa.length*pb.length) * sizeof(Term));
    if (NULL == pc.elem || NULL == temp.elem)
        return OVERFLOW;
    while (i < pa.length) {
        while (j < pb.length) {//pa中的每一項去除於pb中的每一項
            temp.elem[k].coef = pa.elem[i].coef / pb.elem[j].coef;//係數相除
            temp.elem[k].expn = pa.elem[i].expn - pb.elem[j].expn;//指數相減
            k++;
            j++;//指向下一項
        }
        i++;
        j = 0;//將j重新賦值爲0
    }
    while (j < k) {//將一元稀疏多項式temp中可合併的項合併賦給pc
        flag = 1;
        if (temp.elem[j].coef == 0) {
            j++;
            continue;
        }
        i = j + 1;//i指向j的下一項
        while (i<k) {
            if (temp.elem[j].expn == temp.elem[i].expn) {//如果指數相同，則將係數相加
                c = temp.elem[j].coef + temp.elem[i].coef;
                if (c != 0) {//如果係數和不爲0，則構建和項，並添加到pc
                    pc.elem[m].expn = temp.elem[j].expn;
                    pc.elem[m].coef = c;
                    m++;
                    flag = 0;
                }
            }
            i++;
        }
        if(flag)
        pc.elem[m++] = temp.elem[j];
        j++;
    }
    if (m < pa.length*pb.length)
        if (NULL == (pc.elem = (Term*)realloc(pc.elem, m * sizeof(Term))))
            return OVERFLOW;
    pc.length = m;
    return OK;
}

void menu()  //菜單 
{
    printf("        一元稀疏多項式試驗統一界面          \n");
    printf("********************************************\n");
    printf("1 建立一元稀疏多項式!                      *\n");
    printf("2 打印輸出一元稀疏多項式                   *\n");
    printf("3 返回一元稀疏多項式P中的項數              *\n");
    printf("4 兩個一元稀疏多項式做加法                 *\n");
    printf("5 兩個一元稀疏多項式做減法                 *\n");
    printf("6 兩個一元稀疏多項式做乘法                 *\n");
    printf("7 兩個一元稀疏多項式做除法                 *\n");
    printf("8 銷燬一元稀疏多項式!                      *\n");
    printf("0 退出!                                    *\n");
    printf("********************************************\n");
}

**********************************************************Test.cpp************************************************************

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include "一元稀疏多項式.h"
#include "源代碼.h"

int main() {
    ElemType *e,*e2;
    Poly pa,pb,pc;
    int i;
    int n,length,order;
    //建立pa
    printf("\n請輸入多項式的項數\n");
    scanf_s("%d", &n);
    printf("請輸入%d個項，按照先係數後項數的順序：\n", n);
    e= (Term*)malloc(n*sizeof(Term));
    for (i = 0; i < n; i++) {
        scanf_s("%f %d", &e[i].coef, &e[i].expn);
    }
    CreatePoly(pa, e, n);
    PrintPoly(pa);

    //建立pb
    printf("\n請輸入多項式的項數\n");
    scanf_s("%d", &n);
    printf("請輸入%d個項，按照先係數後項數的順序：\n", n);
    e2 = (Term*)malloc(n * sizeof(Term));
    for (i = 0; i < n; i++) {
        scanf_s("%f %d", &e2[i].coef, &e2[i].expn);
    }
    CreatePoly(pb, e2, n);
    PrintPoly(pb);

    menu();//輸出菜單
    while (1) {
        printf("\n請輸入你要操作的序號：\n");
        scanf_s("%d", &order);
        switch (order)
        {
        case 1:CreatePoly(pa, e, n); break;
        case 2:PrintPoly(pc); break;
        case 3:length = PolyLength(pa);
                printf("\nP的項數爲:%d\n", length); break;
        case 4:AddPoly(pa, pb, pc);
                PrintPoly(pc); break;
        case 5:SubPoly(pa, pb, pc);
                PrintPoly(pc); break;
        case 6:MulPoly(pa, pb, pc);
                PrintPoly(pc); break;
        case 7:DivPoly(pa, pb, pc); 
                PrintPoly(pc); break;
        case 8:DestroyPoly(pc); break;
        case 0:exit(1); break;
        default:printf("輸入命令錯誤!請重新輸入:\n");
            break;
        }
    }
    
    return 0;
}