空间数据结构课程设计报告.docx

空间数据结构课程设计报告.docx

《空间数据结构课程设计报告.docx》由会员分享，可在线阅读，更多相关《空间数据结构课程设计报告.docx（30页珍藏版）》请在冰豆网上搜索。

空间数据结构课程设计报告

《空间数据结构基础》

课程实习报告

（测绘09级）

姓名李冬伟

班级采矿09-9班

学号07092951

矿业与工程学院

三维空间球

【实验目的】

了解复合数据结构的描述方法。

球是一个包含坐标点的复合数据结构，在C++程序中将坐标点和球分别定义为具有继承关系的两个类，即定义球类Tball为Point的派生类。

使用派生类的形式定义一个数据结构，其主要目的是提高基类的代码利用率，并使派生类的结构得到简化。

基类和派生类的定义体现了C++继承机制的运用，最大程度地提高了数据结构的利用率。

【问题描述】定义三维空间的坐标点TPoint并且描述三维空间的球Tball。

【数据结构】定义Tpoint类和Tball类。

【主要功能】实现其主要操作：

计算体积和表面积，输出空间坐标等。

【程序代码】

#include

constdoublePI=3.14159;

classTPoint

{

protected:

doublex;

doubley;

doublez;

public:

TPoint（）{x=0;y=0;z=0;}

TPoint（doublepx,doublepy,doublepz）{x=px;y=py;z=pz;}

doubleGetx（）{returnx;}

doubleGety（）{returny;}

doubleGetz（）{returnz;}

voidMove（doublemx,doublemy,doublemz）;

voidShow（）{cout<<"x="<

};

classTBall:

publicTPoint

{

doubler;

public:

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<<"球的球心坐标为：

"<<"（"<

cout<<"球的体积为：

"<

cout<<"球的表面积为：

"<

}

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。

【主要功能】可以输入一个单链表，实现单链表的合并、拆分和逆置等操作，且每次结果均可输出。

【程序代码】

#include

#include

template

structLinkNode

{

Tdata;

LinkNode*link;

LinkNode（LinkNode*ptr=NULL）{link=ptr;}

LinkNode（constT&item,LinkNode*ptr=NULL）

{

data=item;

link=ptr;

}

};

template

classList

{

public:

List（）{h=newLinkNode;}

List（constT&x）{h=newLinkNode（x）;}

List（List&L）;

~List（）{makeEmpty（）;}

voidmakeEmpty（）;

intLength（）const;

LinkNode*getHead（）const{returnh;}

LinkNode*Search（Tx）;

LinkNode*Locate（inti）;

boolgetData（inti,T&x）const;

voidsetData（inti,T&x）;

boolInsert（inti,T&x）;

boolRemove（inti,T&x）;

boolIsEmpty（）const

{returnh->link==NULL?

true:

false;}

boolIsFull（）const{returnfalse;}

voidreverse（）;

voidinput（TendTag）;

voidoutput（）;

List&operator=（List&L）;

protected:

LinkNode*h;

};

template

List:

:

List（List&L）

{

Tvalue;

LinkNode*srcptr=L.getHead（）;

LinkNode*desptr=h=newLinkNode;

while（srcptr->link!

=NULL）

{

value=srcptr->link->data;

desptr->link=newLinkNode（value）;

desptr=desptr->link;

srcptr=srcptr->link;

}

desptr->link=NULL;

}

template

voidList:

:

makeEmpty（）

{

LinkNode*q;

while（h->link!

=NULL）

{

q=h->link;

h->link=q->link;

deleteq;

}

}

template

intList:

:

Length（）const

{

LinkNode*p=h->link;

intcount=0;

while（p!

=NULL）

{p=p->link;count++;}

returncount;

}

template

LinkNode*List:

:

Search（Tx）

{

LinkNode*current=h->link;

while（current!

=NULL）

if（current->data==x）break;

elsecurrent=current->link;

returncurrent;

}

template

LinkNode*List:

:

Locate（inti）

{

if（i<0）returnNULL;

LinkNode*current=h;

intk=0;

while（current!

=NULL&&k

{current=current->link;k++;}

returncurrent;

}

template

boolList:

:

getData（inti,T&x）const

{

if（i<=0）returnNULL;

LinkNode*current=Locate（i）;

if（current==NULL）returnfalse;

else{x=current->data;returnture;}

}

template

voidList:

:

setData（inti,T&x）

{

if（i<=0）return;

LinkNode*current=Locate（i）;

if（current==NULL）return;

elsecurrent->data=x;

}

template

boolList:

:

Insert（inti,T&x）

{

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）

{

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=h->link;

cout<

while（current!

=NULL）

{

cout<data<<"";

current=current->link;

}

cout<

}

template

List&List:

:

operator=（List&L）

{

Tvalue;

LinkNode*srcptr=L.getHead（）;

LinkNode*desptr=h=newLinkNode;

while（srcptr->link!

=NULL）

{

value=srcptr->link->data;

desptr->link=newLinkNode（value）;

desptr=desptr->link;

srcptr=srcptr->link;

}

desptr->link=NULL;

return*this;

}

template

voidList:

:

input（TendTag）

{

LinkNode*newNode,*last;

Tval;

makeEmpty（）;

cout<<"输入单链表的数据（输入零结束）"<

cin>>val;

last=h;

while（val!

=endTag）

{

newNode=newLinkNode（val）;

if（newNode==NULL）

{cerr<<"存储分配错误！

"<

（1）;}

last->link=newNode;

last=newNode;

cin>>val;

}

last->link=NULL;

}

template

voidList:

:

reverse（）

{

LinkNode*last,*led,*q;

last=h->link;

led=h->link;

while（last->link!

=NULL）

{

last=last->link;

}

while（last!

=led）

{

q=led;

led=led->link;

h->link=led;

q->link=last->link;

last->link=q;

}

}

voidUnion（List&A,List&B）

{

intm=A.Length（）;

intn=B.Length（）;

LinkNode*scrptr=A.getHead（）;

LinkNode*destptr=B.getHead（）;

LinkNode*p=scrptr->link;

LinkNode*q=destptr->link;

if（m>n）

{

while（q!

=NULL）

{

destptr->link=q->link;

q->link=p->link;

p->link=q;

p=p->link->link;

q=destptr->link;

}

}

else

{

for（inti=1;i

{

destptr->link=q->link;

q->link=p->link;

p->link=q;

p=p->link->link;

q=destptr->link;

}

while（q!

=NULL）

{

destptr->link=q->link;

q->link=p->link;

p->link=q;

q=destptr->link;

p=p->link;

}

}

}

voidSplit（List&L）

{

intvalue;

ListD;

ListE;

LinkNode*led=L.getHead（）;

LinkNode*scrptr=D.getHead（）;

LinkNode*destptr=E.getHead（）;

while（led->link!

=NULL）

{

value=led->link->data;

if（value%2==0）

{

scrptr->link=newLinkNode（value）;

scrptr=scrptr->link;

}

elseif（value%2==1）

{

destptr->link=newLinkNode（value）;

destptr=destptr->link;

}

led=led->link;

}

scrptr->link=NULL;

destptr->link=NULL;

cout<<"原链表拆分成D、E两个链表"<

cout<<"D表元素全为偶数，依次是：

"<

D.output（）;

cout<<"E表元素全为奇数，依次是：

"<

E.output（）;

}

voidmain（）

{

ListA;

ListB;

A.input（0）;

B.input（0）;

Union（A,B）;

ListC（A）;

cout<<"两链表合成后，单链表的元素依次是：

"<

C.output（）;

C.reverse（）;

cout<<"链表逆转后的元素依次是：

"<

C.output（）;

Split（C）;

}

【实现界面】

【实践体会】

程序的代码在编辑时，在链表的合并和拆分上，程序的逻辑结构我没有分析明了，开始设计代码时没有成功，之后参考了同学的算法设计才编出代码，同时在主函数的编辑时，有关函数的调用我还是不很清楚，也是询问同学后编译出的。

中缀转后缀

【实验目的】中缀转后缀问题可借助栈来处理。

本实验题有助于掌握栈的应用技术。

【问题描述】表达式转换。

输入的中缀表达式为字符串，转换得到的后缀表达式存入字符数组中并输出。

例如：

a*（x+y）/（b-x）转换后得：

axy+*bx-/

【数据结构】定义一个暂时存放运算符的转换工作栈opst。

中缀表达式字符串char*infix;后缀表达式字符串char*postfix;

【主要功能】输入一个中缀表达式，输出的是该算法的后缀表达式。

【程序代码】

#include

#include

#include

constintstackIncreament=20;

template

classOpst

{

public:

Opst（intsz=50）;

~Opst（）{delete[]elements;}

voidPush（constT&x）;

boolPop（T&x）;

boolgetTop（T&x）;

boolIsEmpty（）const{return（top==-1）?

true:

false;}

boolIsFull（）const{return（top==maxSize-1）?

true:

false;}

intgetSize（）const{returntop+1;}

voidmakeEmpty（）{top=-1;}

friendostream&operator<<（ostream&os,Opst&s）;

private:

T*elements;

inttop;

intmaxSize;

voidoverflowProcess（）;

};

template

Opst:

:

Opst（intsz）:

top（-1）,maxSize（sz）

{

elements=newT[maxSize];

assert（elements!

=NULL）;

}

template

voidOpst:

:

overflowProcess（）

{*newArray=newT[maxSize+stackIncreament];

if（newArray=NULL）{cerr<<"存贮分配失败！

"<

（1）;}

for（inti=0;i<=top;i++）newArray[i]=elements[i];

maxSize=maxSize+stackIncreament;

delete[]elements;

elements=newArray;

}

template

voidOpst:

:

Push（constT&x）

{if（IsFull（）==true）overflowProcess（）;

elements[++top]=x;

}

template

boolOpst:

:

Pop（T&x）

{if（IsEmpty（）==true）returnfalse;

x=elements[top--];

returntrue;

}

template

boolOpst:

:

getTop（T&x）

{

if（IsEmpty（）==true）returnfalse;

x=elements[top];

returntrue;

}

template

ostream&operator<<（ostream&os,Opst&s）

{

os<<"top="<

for（inti=0;i<=s.top;i++）

os<

"<

returnos;

}

intisdigit（charch）

{

switch（ch）

{

case'+':

case'-':

case'*':

case'/':

case'（':

case'）':

return0;

break;

default:

return1;break;

}

}

intisp（charch）

{

switch（ch）

{

case'#':

return0;break;

case'（':

return1;break;

case'*':

return5;break;

case'/':

return5;break;

case'%':

return5;break;

case'+':

return3;break;

case'-':

return3;break;

case'）':

return6;break;

default:

break;

}

}

inticp（charch）

{switch（ch）

{

case'#':

return0;break;

case'（':

return6;break;

case'*':

return4;break;

case'/':

return4;break;

case'%':

return4;break;

case'+':

return2;break;

case'-':

return2;break;

case'）':

return1;b