if（!
hash[i]）
elements[n++]=elements[i];
delete[]hash;
if（n==tmp）//判断是否有删除的数据
returnfalse;
else
returntrue;
}
五、测试和调试
1.测试用例和结果
1）输入顺序表的长度为10
2）输入10个元素分别为1,3,7,8,4,6,24,15,22，9
3）输出创建好的表：
1,3,7,8,4,6,24,15,22,9
以及逆置后的表：
9,22,15,24,6,4,8,7,3,1
4）输入要删除的数据22，接着输出删除该数据后的
5）重新输入需要删除的数据4,24，如图所示只删除了4
2.
结果分析
1）程序能够正确的实现顺序表的逆置以及删除特定值的元素
2）由测试结果来看，数据无法实现两个数的同时删除，还有改进的空间
六、实验小结
通过这次课程设计，使我对数据结构有了初步的清晰了解，增强了程序的编写能力，在程序的运行与调试过程中出现了很多错误，通过反复地复习课本上的相关知识，不停地修改与调试，终于完成了这段程序。
在调试过程中，我认识到了数据结构的灵活性与严谨性，同一个功能可以由不同的语句来实现，但编写程序时要特别注意细节方面的问题，因为一个小小的疏忽就能导致整个程序不能运行。
我也认识到了自己的薄弱之处，如对c++和链表知识不够熟悉，在以后的学习中我们要集中精力、端正态度，争取把知识学得更扎实、更全面。
实习题名:
多项式的基本运算
班级姓名学号日期2016.03.10
一、问题描述
设计带表头结点的单链表表示的多项式类，在该类上定义和实现教材2.4节中程序2.7的多项式类上的各个运算，在该类上增加成员函数voidPolyMul（Polynominal&r），并重载*运算符，实现菜单驱动的main函数，测试多项式类上各个运算：
输入多项式，显示多项式，多项式加法和乘法运算。
二、概要设计
文件polynominal.cpp中定义了两个类,分别是多项式结点类Term和多项式类polynominal。
三、详细设计
1.类和类的层次结构
为实现多项式的算术运算,在polynominal类之前定义了Term类。
2.核心算法
项结点类中定义了三个私有数据域分别为coef、指数exp和指向下一个项结点的指针域link，多项式polynominal被声明成结点类的友元类。
多项式polynominal其中包括了三个公有成员函数:
AddTerms,Output,PolyAdd,PolyMul,分别实现多项式的输入、输出、相加、相乘。
PolyAdd（Polynominal&r）函数和PolyMul（Polynominal&r）函数的流程图如下。
PolyAdd（Polynominal&r）
PolyMul（Polynominal&r）
3.算法分析
多项式的加法和乘法算术运算程序的主要算法的时间复杂程度和和空间复杂程度为O（n）。
四、程序代码
voidPolynominal:
:
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->expexp）//跳过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
{
q1=q;//若相加后系数不为0，则移动q1和q
q=q->link;
}
}
else//p>exp>q->exp的情况
q1=q1->InsertAfter（p->coef,p->exp）;//以p的系数和指数生成新结点，插入q1后
p=p->link;
}
}
voidPolynominal:
:
PolyMul（Polynominal&r）
{
Polynominalresult;//定义相乘后的数据
Term*n=result.theList;//n指向result的头结点
n=n->InsertAfter（0,0）;//在result的头结点后插入新结点，系数指数均为0
Term*p=r.theList->link;//p指向第一个要处理的结点
while（p->exp>=0）//对r的单循环链表遍历
{
Polynominaltmp;//存储某段相乘后的数据
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））;//生成新结点插入n后
q=q->link;
}
result.PolyAdd（tmp）;//将temp加到result上
p=p->link;
}
Term*q=theList->link;//q指向表头结点的后继结点
while（q!
=NULL）//删除原对象的所有数据
{
theList->link=q->link;
deleteq;
q=theList->link;
}
q=theList;
q=q->InsertAfter（0,0）;
PolyAdd（result）;//将result加到当前对象上
}
五、测试和调试
1.测试用例和结果
1）选择1,计算多项式相加
2）分别输入系数和项数32,46,97,如图所示
3）得到相加的多项式如图
4）选择2,计算多项式相乘
5）输入系数和项数42,63,,得到多项式一,如图
6）再次输入系数和项数73,得到多项式二以及多项一和多项式二的乘积
2.结果分析
1）程序能够正确实现多项式的相加以及相乘
2）但是程序无法实现不能加法乘法混用，下一步改进方向是实现加法乘法混用，是计算更加简便
六、实习小结
这个实验的重难点都在于正确灵活使用，大部分代码在书上都有提供，真正的操作重点在于理解这些代码的意义和使用方法。
通过这次课程设计，使我对数据结构有了初步的清晰了解，增强了程序的编写能力，巩固了专业知识，对程序的模块化观念也又模糊逐渐变的清晰了。
在程序的运行与调试过程中出现了很多错误，通过反复地复习课本上的相关知识，不停地修改与调试，终于完成了这段程序。
在调试过程中，我认识到了数据结构的灵活性与严谨性，同一个功能可以由不同的语句来实现，但编写程序时要特别注意细节方面的问题，因为一个小小的疏忽就能导致整个程序不能运行。
我也认识到了自己的薄弱之处，如对c++和链表知识不够熟悉，在以后的学习中我们要集中精力、端正态度，争取把知识学得更扎实、更全面。
经过这次的实验，我在各个方面都得到了不少的提高，我希望多几次像这样的实验让我们更好的锻炼自己。
附录：
1.线性表的基本运算
#include
usingnamespacestd;
intconstLEN=50;
template
classLinearList
{
public:
virtualboolIsEmpty（）const=0;
virtualintLength（）const=0;
virtualboolFind（inti,T&x）const=0;
virtualintSearch（Tx）const=0;
virtualboolInsert（inti,Tx）=0;
virtualboolDelete（inti）=0;
virtualboolUpdate（inti,Tx）=0;
virtualvoidOutput（ostream&out）const=0;
protected:
intn;//线性表的长度
};
template
classSeqList:
publicLinearList
{
private:
intmaxLength;//线性表的最大长度
T*elements;//动态一维数组的指针
public:
SeqList（intmSize）;
~SeqList（）{delete[]elements;}
boolIsEmpty（）const;
intLength（）const;
boolFind（inti,T&x）const;
intSearch（Tx）const;
boolInsert（inti,Tx）;
boolDelete（inti）;
boolUpdate（inti,Tx）;
voidOutput（ostream&out）const;
voidReverse（）;
boolDeleteX（constT&x）;
};
template
SeqList:
:
SeqList（intmSize）
{
maxLength=mSize;
elements=newT[maxLength];//动态分配顺序表的存储空间
n=0;
}
template
boolSeqList:
:
IsEmpty（）const
{
returnn==0;
}
template
intSeqList:
:
Length（）const
{
returnn;
}
template
boolSeqList:
:
Find（inti,T&x）const
{
if（i<0||i>n-1）
{
cout<<"OutofBounds"<returnfalse;
}
x=elements[i];
returntrue;
}
template
intSeqList:
:
Search（Tx）const
{
for（intj=0;jif（elements[j]==x）
returnj;
return-1;
}
template
boolSeqList:
:
Insert（inti,Tx）
{
if（i<-1||i>n-1）
{
cout<<"OutOfBounds"<returnfalse;
}
if（n==maxLength）
{
cout<<"OverFlow"<returnfalse;
}
for（intj=n-1;j>i;j--）
elements[j+1]=elements[j];
elements[i+1]=x;
n++;
returntrue;
}
template
boolSeqList:
:
Delete（inti）
{
if（!
n）
{
cout<<"UnderFlow"<returnfalse;
}
if（i<0||i>n-1）
{
cout<<"OutOfBounds"<returnfalse;
}
for（intj=i+1;jelements[j-1]=elements[j];
n--;
returntrue;
}
template
boolSeqList:
:
Update（inti,Tx）
{
if（i<0||i>n-1）
{
cout<<"OutOfBounds"<returnfalse;
}
elements[i]=x;
returntrue;
}
template
voidSeqList:
:
Output（ostream&out）const
{
for（inti=0;iout<out<}
template
voidSeqList:
:
Reverse（）
{
Ttemp;//临时变量存放数据
for（inti=0;i{
temp=elements[i];
elements[i]=elements[n-i-1];
elements[n-i-1]=temp;
}
}
template
boolSeqList:
:
DeleteX（constT&x）
{
inttmp=n,i;//用于判断是否有删除数据
n=0;
int*hash=newint[tmp];
for（i=0;i{
hash[i]=0;
if（elements[i]==x）
hash[i]++;
}
for（i=0;iif（!
hash[i]）
elements[n++]=elements[i];
delete[]hash;
if（n==tmp）//判断是否有删除的数据
returnfalse;
else
returntrue;
}
intmain（）
{
intdel_data,len,num;
SeqListA（LEN）;
cout<<"Inputthelengthoftheseqlist:
";
cin>>len;
cout<<"\nInputeachelement:
";
for（inti=0;i{
cin>>num;
A.Insert（i-1,num）;
}
cout<<"\nInitialseqlist:
";
A.Output（cout）;
A.Reverse（）;
cout<<"\nReseveredseqlist:
";
A.Output（cout）;
cout<<"\nInputtheelementtobedeleted:
";
cin>>del_data;
if（A.DeleteX（del_data）==true）
{
cout<<"\nSeqlistafterbeingdeleted:
";
A.Output（cout）;
}
else
cout<<"\nNotfound"<return0;
}
2.多项式的基本运算
#include
classTerm
{
public:
Term（intc,inte）;
Term（intc,inte,Term*nxt）;
Term*InsertAfter（intc,inte）;
private:
intcoef;
intexp;
Term*link;
friendostream&operator<<（ostream&,constTerm&）;
friendclassPolynominal;
};
Term:
:
Term（intc,inte）:
coef（c）,exp（e）
{
link=0;
}
Term:
:
Term（intc,inte,Term*nxt）:
coef（c）,exp（e）
{
link=nxt;
}
Term*Term:
:
InsertAfter（intc,inte）
{
link=newTerm（c,e,link）;
returnlink;
}
ostream&operator<<（ostream&out,constTerm&val）
{
if（val.coef==0）
returnout;
out<switch（val.exp）
{
case0:
break;
case1:
out<<"X";break;
default:
out<<"X^"<}
returnout;
}
classPolynominal
{
public:
Polynominal（）;
~Polynominal（）;
voidAddTerms（istream&in）;
voidOutput（ostream&out）const;
voidPolyAdd（Polynominal&r）;
voidPolyMul（Polynominal&r）;
private:
Term*theList;
friendostream&operator<<（ostream&,constPolynominal&）;
friendistream&operator>>（istream&,Polynominal&）;
friendPolynominal&operator+（Polynominal&,Polynominal&）;
friendPolynominal&operator*（Polynominal&,Polynominal&）;
};
Polynominal:
:
Polynominal（）
{
theList=newTerm（0,-1）;//头结点
theList->link=NULL;//单链表尾结点指针域为空
}
Polynominal:
:
~Polynominal（）
{
Term*p=theList->link;
while（p!
=NULL
升级会员 