}
voidmain（）{
inta,b,c,d;
cout<<"请输入球心坐标"<<"x=";
cin>>a;
cout<<"y=";
cin>>b;
cout<<"z=";
cin>>c;
cout<<"请输入半径"<<"r=";
cin>>d;
TBallball（a,b,c,d）;
ball.output_S（）;
ball.output_V（）;
ball.output_P（）;
}
【实验过程】
首先定义一个点的类作为一个基类，在定义个球的类，并且公共继承点类
将球的类的公共函数作为一个调用类的私有成员的接口
具体公共函数的实现在类的外面。
使用公共模版类
【实验体会】
通过这次实验我掌握了点的类定义、空间中一个球体的定义和从点到球体公有继承的方法以及输入输出的方法！
实验里首先定义一个PI，接着在实验中就能很好的简化实验操作步骤和代码量！
2链表的建立、合并与拆分
【实验简介】链表是用链接存储的方式来表达线性表，它用指针表示结点间的逻辑关系，链表适用于插入或删除频繁，存储空间需求不定的情形。
【实验内容】定义一个链表存储的线性表，除已给出的表元素插入、删除、查找等基本操作外，再提供表的合并、拆分和逆置等操作。
在应用程序中建立两个整型的单链表对象A和B，应用线性表的基本操作对表的实例对象进行操作测试。
1.设线性链表A=（a1,a2,…,am）,，B=（b1,b2,…bm），按下列规则合并A，B为线性表C的算法，即使得
C=（a1,b1,…,am,bm,b（m+1）,…,bn）当m<=n
或C=（a1,b1,…,an,bn,a（n+1）,…,am）当m>n
C表利用A表和B表中的结点空间构成。
2.将C表原地逆置。
3.将C表的中偶数和奇数分别链接为两个循环链表D和E。
说明：
每一次合并、拆分和逆置等操作的结果均要输出。
【主要代码】
#include
template//定义在"LinkedList.h"
structLinkNode//链表结点类的定义
{Tdata;//数据域
LinkNode*link;//链指针域
LinkNode（LinkNode*ptr=NULL）
{link=ptr;}//构造函数
LinkNode（constT&item,LinkNode*ptr=NULL）
{data=item;link=ptr;}//构造函数
};
template
classList//单链表类定义
{protected:
LinkNode*first;//表头指针
public:
List（）{first=newLinkNode;}//构造函数
List（constT&x）{first=newLinkNode（x）;}
List（List&L）;//复制构造函数
~List（）{makeEmpty（）;}//析构函数
voidmakeEmpty（）;//将链表置为空表
intLength（）const;//计算链表的长度
LinkNode*getHead（）const{returnfirst;}
LinkNode*Search（Tx）;//搜索含x元素
LinkNode*Locate（inti）;//定位第i个元素
boolgetData（inti,T&x）;//取出第i元素值
voidsetData（inti,T&x）;//更新第i元素值
boolInsert（inti,T&x）;//在第i元素后插入x
boolRemove（inti,T&x）;//删除第i个元素，x返回该元素值
booluniom（List&A,List&B,List&C）;//合并A，B为线性表C,C利用A和B的存储空间
voidchangeover（）;//将L链表原地逆转
voidclassify（List&C,List&D,List&E）;//将C表的中偶数和奇数分别链接为两个循环链表D和E。
boolIsEmpty（）const//判表空否
{returnfirst->link==NULL?
true:
false;}
voidSort（）;//排序
voidinput（）;
voidoutput（）;
List&operator=（List&L）;
};
voidmain（）
{ListA,B;
}
voidList:
:
classify（List&C,List&D,List&E）
{
D.makeEmpty（）;E.makeEmpty（）;//置空D、E链表
LinkNode*current=C.first;
LinkNode*p=current->link；
LinkNode*pd=D.first;
LinkNode*pe=E.first;
while（p!
=null）//循环地分别连接C中的结点到循环链表D和E中
{
current->link=p->link;//拿出p结点
if（（p->data）%2==0）
{pd->link=p;//D链表存放偶数结点
pd=pd->link;
pd->link=D.first;}
else
{pe->link=p;//E链表存放奇数结点
pe=pe->link;
pe->link=E.first;}
p=current->link;//p结点后移一个
}
}；
template
boolList:
:
changeover（）
{
LinkNode*aq,*pr;
aq=first->link;
first->link=null;
while（aq!
=null）
{
pr=aq->link;
aq->link=first;
first=aq;
aq=pr;//把C转置
}
};
template
boolList:
:
uniom（List&A,List&B）;
{
ListC=A;
intm,n,min,i=1,
min=（m<=n?
m:
n）
m=A.length（）;n=B.length（）;
LinkNode*p=A.first;
while（i<=min）
{
LinkNode*current=B.first;
LinkNode*aiq=current->link;
current->link=aiq->link;//拿出aiq结点
LinkNode*pt=A.locate（i）;
aiq->link=pt->link;
pt->link=aiq;//把aiq结点插入到A的第i个结点后
i++;
}//A链表比B链表长的情况不用再调整
if（m<=n）{aiq->link=B.first->link;}//B链表比A链表长的情况
if（C.length（）=m+n）
returntrue;
else
returnfalse;
}；
template
voidList:
:
makeEmpty（）
{LinkNode*q;
while（first->link!
=NULL）
{q=first->link;//保存被删结点
first->link=q->link;//从链上摘下该结点
deleteq;//删除
}
}；
template
intList:
:
Length（）const{
ListNode*p=first->link;
intcount=0;
while（p!
=NULL）//逐个结点检测
{p=p->link;count++;}
returncount;
}
template
LinkNode*List:
:
Search（Tx）{
//在表中搜索含数据x的结点,搜索成功时函数返该结点地址;否则返回NULL。
LinkNode*current=first->link;
while（current!
=NULL&¤t->data!
=x）current=current->link;
returncurrent;
};
template
LinkNode*List:
:
Locate（inti）
{//函数返回表中第i个元素的地址。
若i<0或i超出表中结点个数，则返回NULL。
if（i<0）returnNULL;//i不合理
LinkNode*current=first;intk=0;
while（current!
=NULL&&k{current=current->link;k++;}
returncurrent;//返回第i号结点地址或NULL
};
template
boolList:
:
getData（inti,T&x）//取出链表中第i个元素的值
{if（i<=0）returnfalse;
LinkNode*current=Locate（i）;
if（cunent==NULL）returnfalse;
else{x=current->data;returntrue;}
template
voidList:
:
setData（inti,T&x）//给链表中第i个元素的赋值x
{if（i<=0）return;
LinkNode*current=Locate（i）;
if（cunent==NULL）return;
elsecurrent->data=x;}
template
boolList:
:
Insert（inti,T&x）
//将新元素x插入在链表中第i个结点之后。
{LinkNode*current=Locate（i）;
if（current==NULL）returnfalse;//无插入位置
LinkNode*newNode=newLinkNode（x）;
if（newNode==NULL）
{cerr<<"内存分配错误！
"<（1）;}
newNode->link=current->link;//链入
current->link=newNode;
returntrue;//插入成功
};
template
boolList:
:
Remove（inti,T&x）
//删除链表第i个元素,通过引用参数x返回元素值
{LinkNode*current=Locate（i-1）;
if（current==NULL||current->link==NULL）
returnfalse;//删除不成功
LinkNode*del=current->link;
current->link=del->link;
x=del->data;deletedel;
returntrue;
};
template
voidList:
:
output（）
{LinkNode*current=first->link;
while（current!
=NULL）
{cout<data<current=current->link;
}
}
template
voidList:
:
inputFront（TendTag）
{LinkNode*newNode;Tval;
makeEmpty（）;
cin>>val;
while（val!
=endTag）
{newNode=newLinkNode（val）;
if（newNode==NULL）
{cerr<<"内存分配错误！
"<（1）;}
newNode->link=first->link;//插在表前端
first->link=newNode;
cin>>val;
}
};
【实验过程】
对实验内容进行分析，由1）设线性链表A=（a1,a2,…,am）,，B=（b1,b2,…bm），按下列规则合并A，B为线性表C的算法，即使得
C=（a1,b1,…,am,bm,b（m+1）,…,bn）当m<=n
或C=（a1,b1,…,an,bn,a（n+1）,…,am）当m>n设计出函数uniom；由2）将C表原地逆置,设计出了函数changeover；由3）将C表的中偶数和奇数分别链接为两个循环链表D和E设计出了函数classify。
然后再设计主函数，逐步进行调试。
【实验体会】
通过该实验，我能了解链表的概念、功能及应用。
链表是用链接存储的方式来表达线性表，它用指针表示结点间的逻辑关系，链表适用于插入或删除频繁，存储空间需求不定的情形。
6图元识别和替换（用队列实现）
【问题描述】对于点阵式的图，在程序中可以用二维数组来表示。
图中一片连续的具有相同颜色的点称为“图元”。
现给出的问题是，对图中指定的图元用另一种颜色来替换。
用队列实现。
输入输出界面与实验指导书中算法实现_程序3.1相同。
【主要代码】
#include
#include
#defineQMAX30//设栈空间最大为30单元
#defineM8//设方阵大小为8行8列
typedefstruct{//像素结构
introw;//像素的行下标
intcol;//像素的列下标
}Pixel;//像素类型名
Pixeloffset[4];//矩阵中四个方向的移动修正表
classStack{
private:
Pixelst[QMAX];//像素类型的栈空间
inttop;//栈顶
public:
Stack（）{top=0;}
voidpush（Pixel&e）;//像素e进栈
Pixelpop（）;//出栈一个像素
intIsEmpty（）;//判断栈是否为空，若空则返回1，否则返回0
};
voidStack:
:
push（Pixel&e）{//像素e进栈
if（top==QMAX）exit（0）;
st[top].row=e.row;
st[top].col=e.col;
top++;
}
PixelStack:
:
pop（）{//出栈一个像素，由e返回
Pixele;
if（top==0）exit（0）;
top--;
e.row=st[top].row;
e.col=st[top].col;
returne;
}
intStack:
:
IsEmpty（）{//判断栈是否为空
if（top<=0）return1;
elsereturn0;
}
voidInit（Pixelpos[]）{//初始化移动修正表数组，pos[]即offset[4]
pos[0].row=0;pos[0].col=1;//right
pos[1].row=1;pos[1].col=0;//down
pos[2].row=0;pos[2].col=-1;//left
pos[3].row=-1;pos[3].col=0;//up
}
intseekp（intarra[][8],intai,intaj,intx,inty）{//使用栈的图元替换算法
Pixelnbr,here;//进栈变量和出栈变量
Stackms;//栈
inti,ni,nj;//工作变量，下一个工作点的行下标和列下标
cout<<"搜索到的图元像素：
"<cout<arra[ai][aj]=x;//替换
arra[ai][aj+1]=x;//替换
return1;
}
voidmain（）{
intarra[8][8]={//存储图的数组初始化
0,0,0,0,0,0,0,0,
0,0,3,3,0,5,2,0,
0,0,3,3,0,0,2,0,
0,6,2,3,8,8,8,0,
0,0,2,3,8,0,0,0,
0,2,2,8,8,7,3,0,
0,0,2,5,8,3,3,0,
0,0,0,0,0,0,0,0
};//四周设一圈围墙（值为0）以保证数据处理的可靠性
inti,j,x,y;
Init（offset）;//初始化移动修正表数组
cout<<"像素矩阵：
"<for（i=0;ifor（j=0;jcout<cout<}
cout<<"请输入指定图元的坐标和新像素值（ijx用空格分隔）:
";
cin>>i>>j>>x;//输入数据用空格分隔
y=arra[i][j];//取指定像素的值
if（y!
=x）{
seekp（arra,i,j,x,y）;//进行图元替换
cout<<"替换后的像素矩阵：
"<for（i=0;ifor（j=0;jcout<cout<}
cout<<"图元替换完毕！
"<}
elsecout<<"未做替换!
"<}
实验成果：
【实验体会】
在二叉树中正确地理解和应用递归思想是很重要。
由于二叉树的结构的特殊性，所以能充分发挥递归函数的强大功能。
9字符串
【实验简介】字符串是由零个或多个字符的顺序排列所组成的数据结构，字符串在计算机处理中使用非常广泛。
通过本次实验理解字符串运算的原理，掌握主要算法的实现。
【实验内容】
建立字符串类，并实现求子串、字符串赋值、字符串连接等运算符重载函数，实现字符串的模式匹配功能。
编写一个能够统计字符串中各个字符出现频度的函数。
【主要代码】
#include
usingnamespacestd;
#include
intconstdefaultSize=128;//常量
classAString{
public:
AString（）;//构造函数
AString（constchar*init）;//构造函数
AString（constAString&ob）;//复制构造函数
升级会员 