空间数据结构课程设计报告文档格式.docx
《空间数据结构课程设计报告文档格式.docx》由会员分享，可在线阅读，更多相关《空间数据结构课程设计报告文档格式.docx（30页珍藏版）》请在冰豆网上搜索。
"
x="
x<
y="
y<
z="
z<
endl;
}
};
classTBall:
publicTPoint
doubler;
TBall（doublea）:
TPoint（）{r=a;
TBall（doubleb,doublec,doubled,doublee）:
TPoint（b,c,d）{r=e;
doubleArea（）{return4*PI*r*r;
doubleVolume（）{return4*PI*r*r*r/3;
voidShow（）;
voidinput（）;
voidTBall:
:
Show（）
cout<
球的球心坐标为：
（"
"
）"
球的体积为：
Volume（）<
球的表面积为：
Area（）<
voidmain（）
TBallB1（1,2,3,4）;
TBallB2（4）;
B1.Show（）;
B2.Show（）;
【实现界面】
【实践体会】
三维空间球的程序代码我原本是仅由原有代码稍加修改后得到的，但在执行时，输出的数据出现了错误，球的面积和体积计算出的结果出现了负数，所以我对原有的程序代码进行了简化和修改，重新进行了编辑。
链表的建立、合并、逆转和拆分
【实验目的】本例给出了较完整的顺序表的抽象数据类型定义，通过C++类模板的应用体现了数据抽象原理。
【问题描述】定义一个链表存储的线性表，除已给出的表元素插入、删除、查找等基本操作外，再提供表的合并、拆分和逆置等操作。
在应用程序中建立两个整型的单链表对象A和B，应用线性表的基本操作对表的实例对象进行操作测试。
【数据结构】定义一个链表结点类LinkNode和一个线性链表类List，提供表元素的插入、删除、查找和以下操作。
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>
nC表利用A表和B表中的结点空间构成。
2.将C表原地逆置。
3.将C表的中偶数和奇数分别链接为两个循环链表D和E。
【主要功能】可以输入一个单链表，实现单链表的合并、拆分和逆置等操作，且每次结果均可输出。
stdlib.h>
template<
classT>
structLinkNode
Tdata;
LinkNode<
T>
*link;
LinkNode（LinkNode<
*ptr=NULL）{link=ptr;
LinkNode（constT&
item,LinkNode<
*ptr=NULL）
{
data=item;
link=ptr;
}
classList
public:
List（）{h=newLinkNode<
;
List（constT&
x）{h=newLinkNode<
（x）;
List（List<
&
L）;
~List（）{makeEmpty（）;
voidmakeEmpty（）;
intLength（）const;
LinkNode<
*getHead（）const{returnh;
*Search（Tx）;
*Locate（inti）;
boolgetData（inti,T&
x）const;
voidsetData（inti,T&
x）;
boolInsert（inti,T&
boolRemove（inti,T&
boolIsEmpty（）const
{returnh->
link==NULL?
true:
false;
boolIsFull（）const{returnfalse;
voidreverse（）;
voidinput（TendTag）;
voidoutput（）;
List<
&
operator=（List<
L）;
protected:
*h;
List<
List（List<
L）
Tvalue;
*srcptr=L.getHead（）;
*desptr=h=newLinkNode<
while（srcptr->
link!
=NULL）
value=srcptr->
link->
data;
desptr->
link=newLinkNode<
（value）;
desptr=desptr->
link;
srcptr=srcptr->
desptr->
link=NULL;
voidList<
makeEmpty（）
*q;
while（h->
q=h->
h->
link=q->
deleteq;
intList<
Length（）const
*p=h->
intcount=0;
while（p!
{p=p->
count++;
returncount;
LinkNode<
*List<
Search（Tx）
*current=h->
while（current!
if（current->
data==x）break;
elsecurrent=current->
returncurrent;
Locate（inti）
if（i<
0）returnNULL;
*current=h;
intk=0;
=NULL&
k<
i）
{current=current->
k++;
returncurrent;
boolList<
getData（inti,T&
x）const
=0）returnNULL;
*current=Locate（i）;
if（current==NULL）returnfalse;
else{x=current->
returnture;
setData（inti,T&
x）
=0）return;
if（current==NULL）return;
elsecurrent->
data=x;
Insert（inti,T&
*newNode=newLinkNode<
if（newNode==NULL）
{cerr<
存储分配错误！
exit
（1）;
newNode->
link=current->
current->
link=newNode;
returntrue;
Remove（inti,T&
*current=Locate（i-1）;
if（current==NULL||current->
link==NULL）returnfalse;
*del=current->
link=del->
x=del->
deletedel;
output（）
*current=h->
cout<
current->
data<
"
current=current->
operator=（List<
L）
*srcptr=L.getHead（）;
return*this;
input（TendTag）
*newNode,*last;
Tval;
makeEmpty（）;
输入单链表的数据（输入零结束）"
cin>
>
val;
last=h;
while（val!
=endTag）
newNode=newLinkNode<
（val）;
if（newNode==NULL）
{cerr<
last->
last=newNode;
cin>
last->
reverse（）
*last,*led,*q;
last=h->
led=h->
while（last->
last=last->
while（last!
=led）
q=led;
led=led->
link=led;
q->
link=last->
link=q;
voidUnion（List<
int>
A,List<
B）
intm=A.Length（）;
intn=B.Length（）;
*scrptr=A.getHead（）;
*destptr=B.getHead（）;
*p=scrptr->
*q=destptr->
if（m>
n）
while（q!
{
destptr->
q->
link=p->
p->
p=p->
q=destptr->
}
else
for（inti=1;
i<
m;
i++）
voidSplit（List<
intvalue;
List<
D;
E;
*led=L.getHead（）;
*scrptr=D.getHead（）;
*destptr=E.getHead（）;
while（led->
value=led->
if（value%2==0）
scrptr->
scrptr=scrptr->
elseif（value%2==1）
destptr=destptr->
scrptr->
destptr->
原链表拆分成D、E两个链表"
D表元素全为偶数，依次是：
D.output（）;
E表元素全为奇数，依次是：
E.output（）;
A;
B;
A.input（0）;
B.input（0）;
Union（A,B）;
C（A）;
两链表合成后，单链表的元素依次是：
C.output（）;
C.reverse（）;
链表逆转后的元素依次是：
Split（C）;
程序的代码在编辑时，在链表的合并和拆分上，程序的逻辑结构我没有分析明了，开始设计代码时没有成功，之后参考了同学的算法设计才编出代码，同时在主函数的编辑时，有关函数的调用我还是不很清楚，也是询问同学后编译出的。
中缀转后缀
【实验目的】中缀转后缀问题可借助栈来处理。
本实验题有助于掌握栈的应用技术。
【问题描述】表达式转换。
输入的中缀表达式为字符串，转换得到的后缀表达式存入字符数组中并输出。
例如：
a*（x+y）/（b-x）转换后得：
axy+*bx-/
【数据结构】定义一个暂时存放运算符的转换工作栈opst。
中缀表达式字符串char*infix;
后缀表达式字符串char*postfix;
【主要功能】输入一个中缀表达式，输出的是该算法的后缀表达式。
assert.h>
constintstackIncreament=20;
classOpst
Opst（intsz=50）;
~Opst（）{delete[]elements;
voidPush（constT&
boolPop（T&
boolgetTop（T&
boolIsEmpty（）const{return（top==-1）?
boolIsFull（）const{return（top==maxSize-1）?
intgetSize（）const{returntop+1;
voidmakeEmpty（）{top=-1;
friendostream&
operator<
（ostream&
os,Opst<
s）;
private:
T*elements;
inttop;
intmaxSize;
voidoverflowProcess（）;
Opst<
Opst（intsz）:
top（-1）,maxSize（sz）
elements=newT[maxSize];
assert（elements!
=NULL）;
voidOpst<
overflowProcess（）
{*newArray=newT[maxSize+stackIncreament];
if（newArray=NULL）{cerr<
存贮分配失败！
for（inti=0;
=top;
i++）newArray[i]=elements[i];
maxSize=maxSize+stackIncreament;
delete[]elements;
elements=newArray;
Push（constT&
x）
{if（IsFull（）==true）overflowProcess（）;
elements[++top]=x;
boolOpst<
Pop（T&
{if（IsEmpty（）==true）returnfalse;
x=elements[top--];
getTop（T&
if（IsEmpty（）==true）returnfalse;
x=elements[top];
template<
ostream&
operator<
s）
os<
top="
s.top<
=s.top;
os<
s.elements[i]<
returnos;
intisdigit（charch）
switch（ch）
case'
+'
case'
-'
*'
/'
（'
）'
return0;
break;
default:
return1;
break;
intisp（charch）
#'
return0;
return5;
%'
return3;
return6;
default:
break;
inticp（charch）
{switch（ch）
return4;
return2;
b
升级会员 