数据结构实习二2

实验要求：

1.设计带表头的结点的单链表表示多项式类。

2.在该类上增加成员函数void PolyMul(Polynominal &r)，并重载*运算符。

3.实现菜单驱动的main函数，测试多项式的各个运算：输入多项式，显示多项式，以及多项式加法和乘法运算。

4.采用带表头的非循环链表存储多项式。

（其中polyadd函数也可以这样实现：

Polynominal::PolyAdd(Polynominal P1,Polynominal P2){
Polynominal front,rear,temp;
int sum;
rear = (Polynominal)malloc(sizeof(struct PolyNode));
front = rear;
whie(P1 && P2){
switch(Compare(P1->exp,P2->exp)){
case 1:
Attach(P1->coef,P1->exp,&rear);
P1 = P1->link;
break;
case -1:
Attach(P2->coef,P2->exp,&rear);
P2 =P2->link;
break;
case 0:
sum = P1->coef + P2->coef;
if(sum) Attach(sum,P1->exp,&rear);
P1 = P1->link;
P2 = P2->link;
break;
}
}
for(;P1;P1=P1->link) Attach(sum,P1->coef,P1->exp,&rear);
for(;P2;P2=P2->link) Attach(sum,P2->coef,P2->exp,&rear);
rear->link = NULL;
temp = front;
front = front->link;
free(temp);
return front;
}


）

完整代码如下，但是关于PolyMul函数的实现，我们这些低能人容易出现一些问题，后将纠结的代码与合理的作比较

#include <iostream>
using namespace std;
class Term
{
public:
Term(int c, int e);
Term(int c, int e, Term *nxt);
Term* InsertAfter(int c, int e);
private:
int coef, exp;
Term* link;
friend ostream & operator << (ostream &, const Term &);
friend class Polynominal;
};

Term::Term(int c, int e) : coef(c), exp(e)
{
link = 0;
}

Term::Term(int c, int e, Term *nxt) : coef(c), exp(e)
{
link = nxt;
}

Term *Term::InsertAfter(int c, int e)
{
link = new Term(c, e, link);
return link;
}

ostream & operator << (ostream& out, const Term& val)
{
if(val.coef == 0) return out;
out << val.coef;
switch(val.exp) {
case 0: break;
case 1: out << "x"; break;
default: out << "x^" << val.exp; break;
}
return out;
}

class Polynominal
{
public:
Polynominal();
~Polynominal();
void AddTerms(istream& in);
void Output(ostream& out) const;
void PolyAdd(Polynominal& r);
void PolyMul(Polynominal& r);
private:
Term* theList;
friend ostream & operator << (ostream &, const Polynominal &);
friend istream & operator >> (istream &, Polynominal &);
friend Polynominal & operator + (Polynominal &, Polynominal &);
friend Polynominal & operator * (Polynominal &, Polynominal &);
};

Polynominal::Polynominal()
{
theList = new Term(0, -1);
theList -> link = NULL;
}

Polynominal::~Polynominal()
{
Term *p = theList -> link;
while(p != NULL) {
theList -> link = p -> link;
delete p;
p = theList -> link;
}
delete theList;
}
void Polynominal::AddTerms(istream& in)
{
Term* q = theList;
int c, e;
while(true) {
cout << "Input a term(coef, exp):\n";
cin >> c >> e;
q = q -> InsertAfter(c, e);
if(e < 0) break;
}
}

void Polynominal::Output(ostream& out) const
{
int first = 1;
Term *p = theList -> link;
for( ; p != NULL && p -> exp >= 0; p = p -> link) {
if(!first && (p -> coef > 0)) out << "+";
first = 0;
out << *p;
}
cout << "\n" << endl;
}

void Polynominal::PolyAdd(Polynominal& r)
{
Term *q, *q1 = theList, *p; // q1指向表头结点
p = r.theList -> link; // p指向第一个要处理的结点
q = q1 -> link; // q1是q的前驱，p和q就指向两个当前进行比较的项
while(p != NULL && p -> exp >= 0) { // 对r的单链表遍历，直到全部结点都处理完
while(p -> exp < q -> exp) { // 跳过q -> exp大的项
q1 = q;
q = q -> link;
}
if(p -> exp == q -> exp) { // 指数相等时，系数相加
q -> coef = q -> coef + p -> coef;
if(q -> coef == 0) { // 若相加后系数为0，则删除q
q1 -> link = q -> link;
delete (q);
q = q1 -> link; // 重置q指针
}
else { // 若相加后系数不为0，则移动q1和q
q1 = q;
q = q -> link;
}
}
else q1 = q1 -> InsertAfter(p -> coef, p -> exp); // 若p -> exp > q -> exp则以p的系数和指数生成新结点，插入q1后
p = p -> link;
}
}
void Polynominal::PolyMul(Polynominal& r)
{
Polynominal result; // 存储结果
Term *n = result.theList; // n指向result的头结点
n = n -> InsertAfter(0, 0); // 将0, 0插入result的头结点之后
Term *p = r.theList -> link; // p指向第一个要处理的结点
while(p -> exp >= 0) { // 对r的单链表遍历，直到全部结点都处理完
Polynominal tmp; // tmp存储当前结果
Term *m = tmp.theList; // m指向tmp头结点
Term *q = theList -> link; // q指向表头结点的后继结点
while(q -> exp >= 0) { // 遍历当前单链表
m = m -> InsertAfter((p -> coef) * (q -> coef), (p -> exp) + (q -> exp)); // 生成新结点插入m后
q = q -> link;
}
result.PolyAdd(tmp); // 当前结果加到result上
p = p -> link;
}
Term *q = theList -> link;
while(q != NULL) { // 清空原数据
theList -> link = q -> link;
delete q;
q = theList -> link;
}
q = theList;
q = q -> InsertAfter(0, 0);
PolyAdd(result); // result加到当前对象上
}
ostream & operator << (ostream &out, Polynominal &x)
{
x.Output(out);
return out;
}

istream & operator >> (istream &in, Polynominal &x)
{
x.AddTerms(in);
return in;
}

Polynominal & operator + (Polynominal &a, Polynominal &b)
{
a.PolyAdd(b);
return a;
}

Polynominal & operator * (Polynominal &a, Polynominal &b)
{
a.PolyMul(b);
return a;
}

int main()
{
Polynominal A,B;
cout << "Please input A：" << endl;
cin >> A;
cout<<"A:\n"<<A;
cout << "Please input B：" << endl;
cin >> B;
cout<<"B:\n"<<B;
cout << "A + B = " << A + B << endl;
cout << "A * B = " << A * B << endl;
return 0;
}

在这里，多项式相乘函数做下比较。一种是：

void Polynominal::PolyMul(Polynominal& r)
{
Polynominal result; // 存储结果
Term *n = result.theList; // n指向result的头结点
n = n -> InsertAfter(0, 0); // 将0, 0插入result的头结点之后
Term *p = r.theList -> link; // p指向第一个要处理的结点
while(p -> exp >= 0) { // 对r的单链表遍历，直到全部结点都处理完
Polynominal tmp; // tmp存储当前结果
Term *m = tmp.theList; // m指向tmp头结点
Term *q = theList -> link; // q指向表头结点的后继结点
while(q -> exp >= 0) { // 遍历当前单链表
m = m -> InsertAfter((p -> coef) * (q -> coef), (p -> exp) + (q -> exp)); // 生成新结点插入m后
q = q -> link;
}
result.PolyAdd(tmp); // 当前结果加到result上
p = p -> link;
}
Term *q = theList -> link;
while(q != NULL) { // 清空原数据
theList -> link = q -> link;
delete q;
q = theList -> link;
}
q = theList;
q = q -> InsertAfter(0, 0);
PolyAdd(result); // result加到当前对象上
}

这是合理且正确的，我遇到了一个问题是：

void Polynominal::PolyMul(Polynominal& r)
{
Term* q,*p,*q1=theList,*m;
q=q1->link;
Polynominal t;
m = t.theList->link;
m = m->InsertAfter(0,0);
int coef = 0;
int exp = 0;
q = r.theList->link;
while(q->exp>=0){
while(p->exp>=0){
coef = p->coef * q->coef;
exp = p->exp + q->exp;
m = m->InsertAfter(coef,exp);
p = p->link;
}
q1 =q->link;
delete(q);
q = q1->link;
}
p = t.theList->link;
q = this->theList;
q = q->InsertAfter(0,0);
while(p->exp>=0){
if(q->exp>=0){
q->coef = p->coef;
q->exp = p->exp;
q1 = q->link;
q = q->link;
}
else{
q = q1;
coef = p->coef;
exp = p->exp;
q = q->InsertAfter(coef,exp);
}
p = p->link;
}
}

一运行就崩溃啦，逻辑上的错误！对比两个函数实现代码，显然前者更清晰明了。后者逻辑上也是有问题的，比如多项式相乘之后指数相同的并没有合并之类的。但是我不知道可不可以再做改动然后达到相乘的效果？求指导！

当然？最上面的全部代码并不是正确的哈啊，在主函数中，输出A+B A*B结果必然是不对诶。这种低级错误恐怕也只有我会犯啦，执行完加法之后，多项式A已经变成了A+B，此A非彼A，所以再做乘法结果必然是不对的！那么怎么解决？傻逼也知道，不能把加法和乘法一次执行，应该区分开来，比如手动选择做加法还是乘法，然后根据输入来执行相应操作。