Polynomial() : head(nullptr) {}

这是一个 C++ 中的构造函数，它定义了一个名为 Polynomial 的类。构造函数的作用是在创建 Polynomial 类的对象时，将 head 指针初始化为 nullptr，即一个空指针。这里的 Polynomial 类是一个多项式类，head 指向多项式的头结点，表示多项式的第一个项。通过将 head 初始化为空指针，表示这是一个空的多项式。

相关问题

class Polynomial { public: Polynomial() : head(nullptr) {} ~Polynomial() { Node* curr = head; while (curr) { Node* temp = curr->next; delete curr; curr = temp; } } void insert(int

coefficient, int exponent) {
Node* newNode = new Node(coefficient, exponent);
if (!head) {
head = newNode;
return;
}
Node* curr = head;
Node* prev = nullptr;
while (curr && curr->exponent > exponent) {
prev = curr;
curr = curr->next;
}
if (!curr) {
prev->next = newNode;
} else if (curr->exponent == exponent) {
curr->coefficient += coefficient;
delete newNode;
} else if (!prev) {
head = newNode;
newNode->next = curr;
} else {
prev->next = newNode;
newNode->next = curr;
}
}
private:
class Node {
public:
int coefficient;
int exponent;
Node* next;
Node(int c, int e) : coefficient(c), exponent(e), next(nullptr) {}
};
Node* head;
};

这段代码实现了一个多项式类，其中包含插入方法 insert，用于按照指定的指数将系数插入多项式中。具体实现是通过遍历链表，找到合适的位置插入新节点，如果指数已存在则将系数相加。多项式的数据结构是一个链表，每个节点包含系数和指数。

自行为普通一元多项式设计存储结构，实现如下功能：\n\n① 输入：从键盘输入一元多项式的各项系数，创建一元多项式；\n\n② 输出：按给定格式输出一元多项式；（例如：3*x^2-x+10）\n\n③ 多项式加法：

可以使用链表来设计一元多项式的存储结构，每个节点存储一个项的系数和指数。具体实现如下：

1. 定义一个结构体，包含两个成员变量：系数和指数。

struct PolyNode {
    int coef;   // 系数
    int exp;    // 指数
    PolyNode* next; // 指向下一个节点的指针
};

2. 定义一个链表类，包含头节点和尾节点。

class Polynomial {
public:
    Polynomial();   // 构造函数，初始化头节点和尾节点
    ~Polynomial();  // 析构函数，释放链表内存
    void input();   // 输入多项式
    void output();  // 输出多项式
    Polynomial add(Polynomial& b);  // 多项式加法
private:
    PolyNode* head; // 头节点
    PolyNode* tail; // 尾节点
};

3. 实现链表类的各个方法。

构造函数：

Polynomial::Polynomial() {
    head = new PolyNode;
    tail = head;
    head->next = nullptr;
}

析构函数：

Polynomial::~Polynomial() {
    PolyNode* p = head;
    while (p != nullptr) {
        PolyNode* q = p->next;
        delete p;
        p = q;
    }
}

输入多项式：

void Polynomial::input() {
    int n;
    cout << "请输入多项式的项数：";
    cin >> n;
    for (int i = 0; i < n; i++) {
        int coef, exp;
        cout << "请输入第" << i+1 << "项的系数和指数：";
        cin >> coef >> exp;
        PolyNode* node = new PolyNode;
        node->coef = coef;
        node->exp = exp;
        node->next = nullptr;
        tail->next = node;
        tail = node;
    }
}

输出多项式：

void Polynomial::output() {
    PolyNode* p = head->next;
    bool first = true;
    while (p != nullptr) {
        if (p->coef != 0) {
            if (!first && p->coef > 0) {
                cout << "+";
            }
            if (p->coef != 1 && p->coef != -1) {
                cout << p->coef;
            } else if (p->coef == -1) {
                cout << "-";
            }
            if (p->exp == 0) {
                cout << p->coef;
            } else if (p->exp == 1) {
                cout << "x";
            } else {
                cout << "x^" << p->exp;
            }
            first = false;
        }
        p = p->next;
    }
    if (first) {
        cout << "0";
    }
    cout << endl;
}

多项式加法：

Polynomial Polynomial::add(Polynomial& b) {
    Polynomial c;
    PolyNode* p = head->next;
    PolyNode* q = b.head->next;
    while (p != nullptr && q != nullptr) {
        if (p->exp == q->exp) {
            int coef = p->coef + q->coef;
            if (coef != 0) {
                PolyNode* node = new PolyNode;
                node->coef = coef;
                node->exp = p->exp;
                node->next = nullptr;
                c.tail->next = node;
                c.tail = node;
            }
            p = p->next;
            q = q->next;
        } else if (p->exp > q->exp) {
            PolyNode* node = new PolyNode;
            node->coef = p->coef;
            node->exp = p->exp;
            node->next = nullptr;
            c.tail->next = node;
            c.tail = node;
            p = p->next;
        } else {
            PolyNode* node = new PolyNode;
            node->coef = q->coef;
            node->exp = q->exp;
            node->next = nullptr;
            c.tail->next = node;
            c.tail = node;
            q = q->next;
        }
    }
    while (p != nullptr) {
        PolyNode* node = new PolyNode;
        node->coef = p->coef;
        node->exp = p->exp;
        node->next = nullptr;
        c.tail->next = node;
        c.tail = node;
        p = p->next;
    }
    while (q != nullptr) {
        PolyNode* node = new PolyNode;
        node->coef = q->coef;
        node->exp = q->exp;
        node->next = nullptr;
        c.tail->next = node;
        c.tail = node;
        q = q->next;
    }
    return c;
}

以上就是一元多项式的存储结构和实现方法。