东大树莓数据结构S2Polynomial代码

代码从课件上扒的，做了一些修改补充，没有实现Add和Mult函数（重载了+和*功能代替），+重载为PPT内容；添加*重载，方法直接，用到两层for循环，还未找到优化方法 ，补充了PPT给出的其他函数的定义。

Polynomial.h

#include <iostream>
using namespace std;
#define MaxTerms 15
class Polynomial;
class term {
    friend Polynomial;
private:
    float coef; //系数	   
    int exp; //指数	
};
class Polynomial {
public:
    Polynomial();
    void setStartandFinish(int s, int f);
    int getStart();
    int getFinish();
    int operator! ();//不存在返回1，否则返回0
    Polynomial operator+ (Polynomial B);
    Polynomial operator* (Polynomial B);
    float Coef(int e);//返回指定指数项的系数
    int LeadExp(); //返回多项式中最大指数
    char compare(int a, int b);
    void NewTerm(float c, int e);
    float Eval(float x); //给x求y
    void Display();
private:
    static term termArray[MaxTerms];
    static int free;
    int start;
    int finish;
};

Polynomial.cpp

#include "Polynomial.h"
term Polynomial::termArray[MaxTerms] = {};
int Polynomial::free = 0;

void quick_sort(int arr[], int brr[], int l, int r)
{
    if (l >= r) return;
    int i = l - 1;
    int j = r + 1;
    int x = arr[(l + r) / 2];
    while (i < j)
    {
        do i++; while (arr[i] < x);
        do j--; while (arr[j] > x);
        if (i < j) { swap(arr[i], arr[j]); swap(brr[i], brr[j]); }
    }
    quick_sort(arr, brr, l, j);
    quick_sort(arr, brr, j + 1, r);
}

Polynomial::Polynomial() {
    start = 0;
    finish = 0;
}

void Polynomial::setStartandFinish(int s, int f) {
    start = s;
    finish = f;
}
int Polynomial::operator!() {
    return start == finish;
}

int Polynomial::getStart() {
    return start;
}

int Polynomial::getFinish() {
    return finish;
}

Polynomial Polynomial::operator+(Polynomial B) {
    Polynomial C;
    int a = start; 
    int b = B.start;  
    C.start = free;
    float c;	
    while (a <= finish && b <= B.finish) {
        switch (compare(termArray[a].exp, termArray[b].exp)) {  
            case '=':  
                c = termArray[a].coef + termArray[b].coef; //系数相加
                if (c) NewTerm(c, termArray[a].exp);
                a++;  b++;  break;
            case '>':
                NewTerm(termArray[b].coef, termArray[b].exp); //小的先进入
                b++;  break;
            case '<':
                NewTerm(termArray[a].coef, termArray[a].exp);
                a++;
        }
    }  
    for (; a <= finish; a++) { //剩余项进入
        NewTerm(termArray[a].coef, termArray[a].exp);
    }

    for (; b <= B.finish; b++) {
        NewTerm(termArray[b].coef, termArray[b].exp);
    }
    C.finish = free - 1; //移动C多项式结尾
    return C;
}

Polynomial Polynomial::operator* (Polynomial B) {
    Polynomial C;
    int s = start;
    int f = finish;
    int bs = B.start;
    int bf = B.finish;
    int cc[MaxTerms]; //C系数
    int ce[MaxTerms]; //C指数
    int k = 0;
    C.start = free;

    for (int i = s; i <= f; i++) {
        for (int j = bs; j <= bf; j++) {
            cc[k] = termArray[i].coef * B.termArray[j].coef; // 两项系数相乘
            ce[k] = termArray[i].exp + B.termArray[j].exp; // 两项指数相加
            k++;
        }
    }

    quick_sort(ce, cc, 0, k - 1); //按指数大小排序

    //合并同类项
    for (int i = 0; i < k; i++) {
        for (int j = i + 1; j < k - 1; j++) {
            if (ce[i] == ce[j]) {
                cc[i] += cc[j]; // 系数相加
                cc[j] = 0; 
            }
        }
    }

    // 将结果添加到多项式C中
    for (int i = 0; i < k; i++) {
        if(cc[i]) C.NewTerm(cc[i], ce[i]);
    }
    C.finish = free - 1;

    return C;
}

float Polynomial::Coef(int e) {
    for (int i = start; i < finish; i++) {
        if (termArray[i].exp == e) {
            return termArray[i].coef;
        }
    }
    return 0.0f;
}

int Polynomial::LeadExp() {
    if (!(*this)) {
        cout << "Polynomial is empty." << endl;
        return -1;
    }
    int maxExp = termArray[start].exp;
    for (int i = start + 1; i < finish; i++) {
        if (termArray[i].exp > maxExp) {
            maxExp = termArray[i].exp;
        }
    }
    return maxExp;
}

char Polynomial::compare(int a, int b) {
    if (a == b) return '=';
    return a > b ? '>' : '<';
}

void Polynomial::NewTerm(float c, int e) {

    if (free >= MaxTerms) {
        cout << "Too many terms in polynomials" << endl;
        return;
    }
    termArray[free].coef = c;
    termArray[free].exp = e;
    free++; 
}

float Polynomial::Eval(float x) {
    float count = 0;
    int f = start;
    for (int i = start; i <= finish; i++) {
        count += termArray[i].coef * pow(x, termArray[i].exp);
    }
    return count;
}

void Polynomial::Display() {
    for (int i = start; i <= finish; i++) {
        if (i != start) cout << "+";
        cout << termArray[i].coef << "x^" << termArray[i].exp;
    }
    cout << endl;
}

test.cpp

#include "Polynomial.h"

int main() {

	Polynomial A, B, C, D;
	for (int i = 1; i < 3; i++) {
		A.NewTerm(i, i);
		A.setStartandFinish(0, 1);
	}
	for (int i = 1; i < 4; i++) {
		B.NewTerm(2, 2*i);
		B.setStartandFinish(A.getFinish() + 1, A.getFinish() + 3);
	}
	cout << "A: ";
	A.Display();
	cout << "B: ";
	B.Display();
	C = A + B;
	cout << "C: ";
	C.Display();
	D = A * B;
	cout << "D: ";
	D.Display();
	cout << "x=2.1,fB(x)=" << B.Eval(2.1) << endl;
	return 0;
}

运行结果