数据结构课程设计

环境与测绘学院

1C++面向对象程序设计基础

【实验简介】学会用算法语言C++描述抽象数据类型。理解数据结构的组成分为两部分，第一部分是数据集（数据元素），第二部分是在此数据集上的操作。从面向对象的观点看，这两部分代表了对象的属性和方法。掌握用C++描述数据结构的基本方法，即通过建立类来描述抽象数据类型。类的数据成员提供对象属性，成员函数提供操作方法，方法是公共接口，用户通过调用方法实现对属性的访问。

【实验内容】

1.定义三维空间的坐标点TPoint

2.描述三维空间的球TBall，实现其主要操作（如计算体积和表面积，输出空间坐标

等）。

3.实现功能：输入一点，判断它与球的位置关系。

【主要代码】

#include

#define PI 3.141592653

class TPoint

{ //空间坐标点类protected:

double x,y,z;

public:

//TPoint(){x = 0; y = 0; z = 0;} //构造函数

TPoint(double px,double py,double pz){x = px;y = py;z =pz;} //带参数的构造函数

double Getx(){return x;} //返回坐标点的x值

double Gety(){return y;} //返回坐标点的y值

double Getz(){return z;} //返回坐标点的z值

void Move(double mx,double my,double mz){x = mx;y = my;z = mz;} ;};//移动坐标点的位置

class Tball:public TPoint{

double r;

public:

//Tball(){r=0; x=0;y=0;z=0;} //构造函数

Tball(double a,double b,double c,double d):TPoint(a,b,c) { r = d; }//带参数的构造函数

Tball(TPoint &pn):TPoint(pn){ r = 1; }

double A(){return 4*PI*r*r;} //计算球的面积

double V(){return 4.0/3.0*PI*r*r*r;} //计算球的体积

int Position(TPoint &pt); //判断点pt相对于球的位置

void Judge(TPoint &pt); //判断点pt相对于球的位置void Show(); //输出球的各属性值

};

int Tball::Position(TPoint &pt) //求点pt相对于球的位置{

double t,s;

t=(pt.Getx()-x)*(pt.Getx()-x)+(pt.Gety()-y)*(pt.Gety()-y)+(pt.Getz()-z)*(pt.Getz()-z);

s=r*r;

if(t>s) return 1; //点在球外

else if(t

else return 0; //点在球上

}

void Tball::Judge(TPoint &pt)

{

switch(Position(pt))

{

case -1:

cout<<"此点在球内"<

case 0:

cout<<"此点在球面上"<

case 1:

cout<<"点此在球外"<

}

}

void Tball::Show() //输出球的各属性值{

cout<<"x="<

cout<<"球的半径="<

cout<<"球的表面积="<

cout<<"球的体积="<

}

void main()

{

int x,y,z,R,x0,y0,z0;

cout<<"输入球心坐标(x,y,z)，以及球的半径R"<

cin>>x>>y>>z;

cout<<"输入半径R：";

cin>>R;

Tball A(x,y,z,R); //定义一个球类对象

A.Show(); //输出球的属性值

cout<<"输入空间一点的坐标(x0,y0,z0)"<

cin>>x0>>y0>>z0;

TPoint p(x0,y0,z0); //定义一个Point类对象cout<<"点和球的位置关系为: ";

A.Judge(p);

}

【实验过程】

【实验体会】本题要求学会用算法语言C++描述抽象数据类型，属于一道比较简单的题目，对继承又有了进一步的了解。通过本题的训练，使C++面向对象的编程的基础知识得到了巩固和复习，对面向对象编程的思想有了更加深刻的认识，为以后更复杂的问题的解决奠定了必要的基础。

上机练习4 将中缀表达式转换为后缀表达式

【问题描述】表达式转换。输入的中缀表达式为字符串，转换得到的后缀表达式存入字符

数组中并输出。

例如：a*(x+y)/(b-x) 转换后得：a x y + * b x - /

【数据结构】

●定义一个暂时存放运算符的转换工作栈opst。

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

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

【算法提示】转换规则：把运算符移到它的两个操作数后面，删除掉所有的括号。

从头到尾扫描中缀表达式，对不同类型的字符按不同情况处理：

●数字或小数点，直接写入字符串postfix，并在每个数值后面写入一个空格；

●左括号，进栈，直到遇见相配的右括号，才出栈；

●右括号，表明已扫描过括号内的中缀表达式，把从栈顶直到对应左括号之间的运算

符依次退栈，并把结果推入栈内；

●对于运算符，分两种情况处理：

◆该运算符的优先级大于栈顶符号的优先级，则入栈；

◆若该运算符的优先级小于栈顶优先级，则先弹出栈顶运算符、写入postfix串；继续将该

运算符与栈顶运算符比较，直到能把它推入栈内为止（即优先级大于栈顶运算符）。

说明：自行设计运算符优先级的表示。

【主要代码】

#include

#include

using namespace std;

const int stackIncreament = 20;//栈溢出时扩展空间的增量

template

class SeqStack//顺序栈的类定义

{

public:

SeqStack(int sz =50); //构造函数，建立一个空栈

~SeqStack() {delete[]elements;} //析构函数

void Push(const T& x);//如果IsFull(),则溢出处理；否则把x插入到栈顶

bool Pop(T& x);//如果IsEmpty(),则不执行退栈，返回false;否则退掉位于栈顶的元素，返回true

bool getTop(T& x);

bool IsEmpty() const {return (top== -1)? true:false;}

bool IsFull()const {return(top ==maxSize-1) ? true:false;}

int getSize()const {return top+1;}//函数返回栈中元素个数

void MakeEmpty() {top= -1;}//清空栈中的内容

friend ostream& operator<<(ostream&os,SeqStack& s) ;//输出栈中元素的重载操作<<

private:

T*elements;

int top;

int maxSize;

void overflowProcess();//栈的溢出处理

};

template

SeqStack::SeqStack(int sz):top(-1),maxSize (sz)//建立一个最大尺寸为sz的空栈，若分配不成功则错误处理{

elements = new T[maxSize];//创建栈的数组空间

assert(elements!=NULL);//断言：动态存储分配是否成功

};

template

void SeqStack::overflowProcess()

{

T*newArray =new T[maxSize +stackIncreament];

if (newArray = NULL) {cerr<<"储存分配失败"<

for (int i =0;i<=top;i++)newArray[i]=elements[i];

maxSize =maxSize+stackIncreament;

delete []elements;

elements =newArray;

};

template

void SeqStack::Push(const T& x)//公共函数：若栈不满，则将元素x插入到该栈的栈顶，否则溢出处理{

if (top==maxSize-1)overflowProcess();//栈满则溢出处理

elements[++top]=x;//栈顶指针先加1再进栈

};

template

bool SeqStack::Pop(T& x)

{

if (top==-1) return false;

x=elements[top--];

return true;

};

template

bool SeqStack ::getTop(T& x)

{

if (top==-1) return false;

x=elements[top];

return true;

};

template

ostream& operator<<(ostream& os,SeqStack& s){

os<<"top= "<

for(int i=0;i<=s.top;i++)//逐个输出栈中元素的值

os<

return os;

};

int isdigit(char ch)

{

switch(ch)

{

case'+':case'-':case'*':case'/':case'(':case')':

return 0;

break;

default:return 1;break;

}

}

int isp(char ch)//栈中优先数

{

switch(ch)

{case'#':return 0;break;

case'(':return 1;break;

case'*':return 5;break;

case'/':return 5;break;

case'%':return 5;break;

case'+':return 3;break;

case'-':return 3;break;

case')':return 6;break;

default:break;

}

}

int icp(char ch)//栈外优先数

{

switch(ch)

{

case'#':return 0;break;

case'(':return 6;break;

case'*':return 4;break;

case'/':return 6;break;

case'%':return 4;break;

case'+':return 2;break;

case'-':return 2;break;

case')':return 1;break;

default:break;

}

}

void postfix(SeqStack&s) {//定义栈的对象为s，其元素为字符char ch ='#',ch1,op;

s.Push(ch);cin.get(ch);//栈底放入一个#，读入一个字符

cout<<"后缀表达式为:"<

while (s.IsEmpty() == false&&ch!='#')//连续处理

if(isdigit(ch)){cout<

else{

s.getTop(ch1);//取栈顶操作符ch1

if(isp(ch1)

{s.Push(ch);cin.get(ch);}//进栈读入下一字符

else if (isp(ch1)>icp(ch))//新输入操作符优先级低

{s.Pop(op);cout<

else{

s.Pop(op);//输入操作符优先级等于栈顶优先级

if(op=='(')cin.get(ch);

}

}

s.Pop(op);

cout<

};

void main(){

SeqStackinfix;//定义顺序栈的对象中缀表达式

cout<<"输入中缀表达式,以#结束"<

postfix(infix);

}

【实验过程】

【实验体会】本题训练的是对栈这种数据结构的应用。主要掌握的是栈这种数据结构的基本运算和对中缀转后缀的思想的理解。即栈是先进后出的，然后就是栈外字符的优先级和栈顶字符的优先级的比较，这是该算法的主要思想。其他就是面向对象编程的基本知识的应用。

上机练习5 后缀表达式的计算

【实验目的】

通过上机实践使得学生进一步了解运算受限的线性表——栈的应用特点与使用方式。掌握栈的类定义，实现栈的主要操作。并能够应用该数据结构解决简单的应用问题。

【实验内容】

模拟一个简单的计算器+、-、*、/等运算，求解输入的后缀表达式的值。从左向右地扫描后缀表达式，并使用一个栈暂存扫描到的操作数和操作结果。【实验要求】

1.定义SeqStack类或LinkedStack类，实现其主要成员函数；定义Calculator类，

实现其成员函数。

2.输入一组后缀表达式，以“#”结束，计算其并验证其值。例如输入后缀

表达式“5 6 * 20 5 + - #”，输出结果：5。

3.计算器要能够接收浮点数。

4.程序正确运行。

5.认真思考，独立上机实践。

【代码】

#include

#include

#include

#include

const int stackIncreament=20;

template

class SeqStack{ //定义SeqStack类

public:

SeqStack(int sz=50);

~SeqStack(){delete[]elements;}

void Push(const T& x);

bool Pop(T& x);

bool getTop(T& x);

bool IsEmpty()const{return(top==-1)?true:false;}

bool IsFull()const{return(top==maxSize-1)?true:false;}

void makeEmpty(){top=-1;}

friend ostream& operator<<(ostream& os,SeqStack& s);

private:

T *elements;

int top;

int maxSize;

void overflowProcess();

};

template

SeqStack::SeqStack(int sz){

top=-1;

maxSize=sz;

elements=new T[maxSize];

assert(elements!=NULL);

};

template

void SeqStack::overflowProcess(){

T *newArray=new T[maxSize+stackIncreament];

if(newArray=NULL){cerr<<""<

for(int i=0;i<=top;i++)newArray[i]=elements[i];

maxSize=maxSize+stackIncreament;

delete[]elements;

elements=newArray;

};

Template

void SeqStack::Push(const T& x){

if(IsFull()==true)overflowProcess();

elements[++top]=x;

};

template

bool SeqStack::Pop(T& x){

if(IsEmpty()==true)return false;

x=elements[top--];

return true;

};

template

bool SeqStack::getTop(T& x){

if(IsEmpty()==true)return false;

x=elements[top];

return true;

};

template

ostream& operator<<(ostream& os,SeqStack& s){ os<<"top="<

for(int i=0;i<=s.top;i++)

os<

return os;

};

class Calculator{ //定义Calculator类public:

Calculator(int sz):s(sz){}

void Run();

void Clear();

private:

SeqStack s;

void AddOperand(double value);

bool Get2Operands(double& left,double& rignt);

void DoOperator(char op);

};

void Calculator::DoOperator(char op){

double left,right,value;

bool result;

result=Get2Operands(left,right);

if(result==true)

switch(op){

case'+':value=left+right;s.Push(value);break;

case'-':value=left-right;s.Push(value);break;

case'*':value=left*right;s.Push(value);break;

case'/':if(right==0.0){

cerr<<"Divide by 0!"<

Clear();

}

else{value=left/right;s.Push(value);}

break;

}

};

bool Calculator::Get2Operands(double& left,double& right){ if(s.IsEmpty()==true)

{cerr<<"缺少右操作数!"<

s.Pop(right);

if(s.IsEmpty()==true)

{cerr<<"缺少左操作数!"<

s.Pop(left);

return true;};

void Calculator::AddOperand(double value){

s.Push(value);

};

void Calculator::Run()

{

char ch;

double newOperand;

while(cin>>ch,ch!='#'){

switch(ch){

case'+':case'-':case'*':case'/':

DoOperator(ch);

break;

default:cin.putback(ch);

cin>>newOperand;

AddOperand(newOperand);

}

}

double result;

s.Pop(result);

cout<<"运算结果为："<<" ";

cout<

};

void Calculator::Clear(){

s.makeEmpty();};

void main(){

cout<<"请输入算式并以#结束"<

Calculator a(100);

a.Run();

cout<

}

【输入、输出界面效果】

【上机总结】本题的解决用到了栈这种数据结构，基本思想是对于一个后缀表达式，应用栈先进后出的特点，先把一个后缀表达式压入栈中，对栈顶元素进行相应的运算，最后得到后缀表达式的结果。本题还是属于比较简单的题目，对栈的认识会有很大的帮助。

7 二叉树的操作

【实验简介】二叉树是树形结构的一种重要类型。通过本次实验，熟悉二叉树结点的结构，掌握二叉树的基本操作以及具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。

【实验内容】

编写程序，实现对二叉树的以下操作：

1．建立二叉树。

2．按任一种遍历次序输出二叉树中的所有结点。

3．求二叉树的深度。

4．求二叉树中的所有节点数。

5．求二叉树中的所有叶子节点数。

6．清除二叉树，使之变成一只空树。

【主要代码】

#include

using namespace std;

template

struct BinTreeNode //二叉树结点类定义

{ T data; //数据域

BinTreeNode *leftChild, *rightChild; //左子女、右子女链域

BinTreeNode () //构造函数

{leftChild = NULL; rightChild = NULL;}

BinTreeNode (T x, BinTreeNode *l = NULL, BinTreeNode * r= NULL)

{data =x;leftChild = l;rightChild = r;}

};

template

class BinaryTree //二叉树类定义

{

public:

BinaryTree (){ root=NULL; }

BinaryTree (T value){RefValue(value);root(NULL); }

void CreateBinTree(){CreateBinTree(root);} //建立二叉树

void PordPrint(){if(root!=NULL) postOrder(root);cout<

int Count(BinTreeNode * subTree);

int Height (BinTreeNode *subTree) //返回树高度

BinTreeNode*getRoot() { return root; }

int Size(BinTreeNode *subTree); //返回结点数

void destroy(BinTreeNode *node); //递归执行删除二叉树

private:

void CreateBinTree (BinTreeNode *& subTree);

void printree(BinTreeNode *t)const; //递归执行输出二叉树

void postOrder(BinTreeNode *t)cons //递归执行后序遍历

BinTreeNode*root; //二叉树根结点

};

template

void BinaryTree::CreateBinTree (BinTreeNode *& subTree)

{ T item;

if ( !cin.eof ())

{ cin >> item;

if (item != '#')

{ subTree = new BinTreeNode(item);

if (subTree == NULL)

{ cerr << "存储分配错!"<< endl;exit (1); }

CreateBinTree (subTree->leftChild);

CreateBinTree (subTree->rightChild);

}

else subTree = NULL;

}

}

template

void BinaryTree::destroy(BinTreeNode*node)

{ //递归删除二叉树if ( node != NULL)

{ destroy ( node->leftChild );

destroy ( node->rightChild );

delete node;

}

}

template

void BinaryTree::postOrder(BinTreeNode*t)const //私有成员函数，后序遍历输出以t为根的二叉树{

if ( t != NULL )

{

postOrder( t->leftChild);

postOrder( t->rightChild);

cout<data<<' ';

}

}

template

int BinaryTree::Height(BinTreeNode*subTree)

//私有函数：利用二叉树后序遍历算法计算二叉树的高度或深度；

{

if (subTree == NULL) return 0; //空树高度为0；

else

{

int i = Height (subTree->leftChild);

int j = Height (subTree->rightChild);

return (i

}

}

template

int BinaryTree::Size (BinTreeNode*subTree) //利用二叉树后序遍历算法计算二叉树的结点个数{

if (subTree == NULL) return 0;

else

return 1+Size(subTree->leftChild)+Size(subTree->rightChild);

}

template

int BinaryTree::Count(BinTreeNode *subTree)

{

if(subTree==NULL) return 0; // 空树叶子节点个数为零else if(!(subTree)->leftChild && !(subTree)->rightChild)

return 1; //仅根节点else

return(Count(subTree->leftChild)+Count(subTree->rightChild)); //递归算法

}

void main(){

BinaryTree A; //定义一个二叉树对象

A.CreateBinTree();

cout<

cout<<"后序遍历输出二叉树的所有节点:"<

A.PordPrint(); //两层函数调用方式递归输出二叉树的后序遍历序列

cout<<"二叉树深度为: "<

cout<<"树的节点数为: "<

cout<<"叶子节点数为: "<

cout<<"成功清除二叉树"<

}

【实验过程】

【实验体会】本题是对树这种非线性结构数据的处理。通过本题的学习，能够更加深刻的理解关于树的一些基本概念，包括树的深度、树的节点、叶子节点等。关键是对树的前序遍历以及后序遍历的掌握，这关系着是否能把一棵树建立起来，然后对其进行遍历，这是本程序最为核心的知识。对本题的学习，可以说是受益匪浅。