测绘软件实习报告文档格式.docx
《测绘软件实习报告文档格式.docx》由会员分享，可在线阅读，更多相关《测绘软件实习报告文档格式.docx（63页珍藏版）》请在冰豆网上搜索。
elsereturnfalse;
}
boolGraphFull（）//判断图是否为满
{if（numVertices==maxVertices||numEdges==maxVertices*（maxVertices-1）/2）
returntrue;
else
returnfalse;
intNumberOfVertices（）//返回当前顶点数
{returnnumVertices;
intNumberOfEdges（）//返回当前边数
{returnnumEdges;
chargetValue（inti）//取顶点i的值，i不合理返回0
{returni>
=0&
&
i<
=numVertices?
VerticesList[i]:
NULL;
intgetWeight（intv1,intv2）//取边（v1,v2）上的权值
{returnv1!
=-1&
v2!
=-1?
Edge[v1][v2]:
0;
intgetFirstNeighbor（intv）;
//取顶点v的第一个邻接顶点
intgetNextNeighbor（intv,intw）;
//取v的邻接顶点w的下一邻接顶点
boolinsertVertex（charvertex）;
//插入顶点vertex
boolinsertEdge（intv1,intv2,intweight）;
//插入边（v1,v2）,权为weight
boolremoveVertex（intv）;
//删去顶点v和所有与它相关联的边
boolremoveEdge（intv1,intv2）;
//在图中删去边（v1,v2）
intgetVertexPos（charvertex）//给出顶点vertex的位置,如果该顶点不在图内则返回-1
{for（inti=0;
numVertices;
i++）
if（VerticesList[i]==vertex）returni;
return-1;
intmini（）;
//求图中所有边的最小权值
boolinput（）;
//输入函数
booloutput（）;
//输出函数
voidkruskal（）;
//kruskal算法
voidprim（）;
//prim算法
protected:
intmaxVertices;
//图中最大顶点数
intnumEdges;
//图中当前边数
intnumVertices;
//图中当前顶点数
private:
char*VerticesList;
//顶点表
int**Edge;
//邻接矩阵
intvisit[50];
//便利时的辅助工具
primnodecloseedge[50];
//为实现prim函数的辅助结点};
KJL_Graphmtx:
:
KJL_Graphmtx（intsz）//构造函数
{maxVertices=sz;
numVertices=0;
numEdges=0;
inti,j;
VerticesList=newchar[maxVertices];
//创建顶点表数组
Edge=（int**）newint*[maxVertices];
//创建邻接矩阵数组
for（i=0;
maxVertices;
Edge[i]=newint[maxVertices];
for（i=0;
i++）//邻接矩阵初始化
for（j=0;
j<
j++）
Edge[i][j]=（i==j）?
0:
maxWeight;
intKJL_Graphmtx:
getFirstNeighbor（intv）//给出顶点位置v的第一个邻接顶点的位置，如果找不到，则函数返回-1
{if（v!
=-1）
if（Edge[v][i]>
0&
Edge[v][i]<
maxWeight）returni;
return-1;
getNextNeighbor（intv,intw）//给出顶点v的某邻接顶点w的下一个邻接顶点的位置，如果找不到，则函数返回-1
w!
{for（inti=w+1;
maxWeight）returni;
boolKJL_Graphmtx:
insertVertex（charvertex）//插入顶点vertex
{if（numVertices==maxVertices）returnfalse;
//顶点表满，不插入
VerticesList[numVertices++]=vertex;
returntrue;
insertEdge（intv1,intv2,intweight）//插入边（v1,v2）,权为weight
{if（v1!
v1<
numVertices&
v2<
Edge[v1][v2]==maxWeight）////插入条件（?
?
）
{Edge[v1][v2]=Edge[v2][v1]=weight;
numEdges++;
returntrue;
else
returnfalse;
removeVertex（intv）//删去顶点v和所有与它相关联的边
{if（v<
v>
=numVertices）returnfalse;
//v不在图中，不删除
VerticesList[v]=VerticesList[numVertices-1];
//顶点表中删除该结点
i++）//减去与v相关联的边数
if（Edge[i][v]>
Edge[i][v]<
maxWeight）numEdges--;
i++）//用最后一列填补第v列
Edge[i][v]=Edge[i][numVertices-1];
numVertices--;
//顶点个数减1
for（j=0;
j++）//用最后一行填补第v行
Edge[v][j]=Edge[numVertices-1][j];
removeEdge（intv1,intv2）//在图中删去边（v1,v2）
{if（v1>
-1&
v2>
Edge[v1][v2]>
Edge[v1][v2]<
maxWeight）
{Edge[v1][v2]=Edge[v2][v1]=maxWeight;
//删除边（v1,v2）
numEdges--;
input（）
{inti,j,k,n,m;
chare1,e2;
intweight;
cout<
<
"
请输入顶点数和边数:
endl;
cin>
>
n>
m;
//输入顶点数n和边数m
请输入顶点的值：
n;
i++）//依次输入顶点的值
{cin>
e1;
this->
insertVertex（e1）;
i=0;
while（i<
m）
{cout<
请输入端点信息:
e1>
e2>
weight;
//输入端点信息
j=this->
getVertexPos（e1）;
//查顶点号
k=this->
getVertexPos（e2）;
if（j==-1||k==-1）
cout<
边两端点信息输入有误，请重新输入！
else
{this->
insertEdge（j,k,weight）;
i++;
}}
output（）//输出函数
{inti,j,n,m;
intw;
n=this->
NumberOfVertices（）;
m=this->
NumberOfEdges（）;
顶点的个数为：
n<
边的条数为：
m<
所有边的信息为：
for（j=i+1;
{w=this->
getWeight（i,j）;
if（w>
w<
{e1=this->
getValue（i）;
e2=this->
getValue（j）;
（"
e1<
"
e2<
）"
}}
mini（）//求图中所有边的最小权值，并返回
{staticinti;
intmin=0;
for（intj=0;
{if（!
visit[j]）
{if（closeedge[min].lowcost>
closeedge[j].lowcost）
{min=j;
}}}
i=min;
cout<
包括边（"
closeedge[i].begvex<
closeedge[i].endvex<
;
returni;
//图的深度优先搜索函数////////
voidDFS（KJL_Graphmtx&
G,intv,boolvisited[]）;
//先声明函数，后使用
G,char&
v）//从顶点v出发，对图G进行深度优先遍历的主要过程
{inti,loc,n=G.NumberOfVertices（）;
//取图中顶点的个数
bool*visited=newbool[n];
//创建辅助数组
i++）//初始化辅助数组visited
{visited[i]=0;
loc=G.getVertexPos（v）;
//取得v结点在图中的位置
DFS（G,loc,visited）;
//从顶点0开始深度优先搜索
delete[]visited;
G,intv,boolvisited[]）//从顶点v出发，对图G进行深度优先遍历的子过程
//从顶点位置v出发，以深度优先的次序访问所有可读入的尚未访问过的顶点。
//算法中用到一个vistied，对已访问过的顶点做访问标记。
{cout<
G.getValue（v）<
//访问顶点v
visited[v]=1;
//顶点v作访问标记
intw=G.getFirstNeighbor（v）;
//找v的第一个邻接顶点w
while（w!
=-1）//若邻接顶点w存在
{if（visited[w]==0）
DFS（G,w,visited）;
//若w未被访问，递归访问顶点w
w=G.getNextNeighbor（v,w）;
//取v排在w后的下一个邻接顶点}}
//图的广度优先搜索函数////////
voidBFS（KJL_GraphmtxG,charv）//从顶点v出发，以广度优先的次序横向搜索图，算法中使用了一个队列。
{inti,w,n=G.NumberOfVertices（）;
//去图中的定点个数
bool*visited=newbool[n];
//用来记录顶点是否被访问过，被访问值为1，为被访问值为0
i++）//初始化
visited[i]=0;
intloc=G.getVertexPos（v）;
//取顶点v的位置号
G.getValue（loc）<
visited[loc]=1;
//做已访问标记
KJL_QueueQ;
//定义一个辅助队列
Q.EnQueue（loc）;
//顶点进队，实现分层访问
while（!
Q.IsEmpty（））//循环访问所有结点，判断队列是否为空
{Q.DeQueue（loc）;
//从队列中退出顶点loc
w=G.getFirstNeighbor（loc）;
//找顶点loc的第一个邻接点w
while（w!
=-1）//若邻接点w存在
{if（visited[w]==false）//若未被访问
{cout<
G.getValue（w）<
//访问顶点w
visited[w]=1;
//标记w已经被访问
Q.EnQueue（w）;
//顶点w进队列w=G.getNextNeighbor（loc,w）;
//找顶点loc的下一个邻接顶点，重复检测v的所有邻接顶点}}
delete[]visited;
//////kruskal函数的实现//////
voidKJL_Graphmtx:
kruskal（）
{inta,b,k=0;
intmin=maxWeight;
intEdge1[20][20];
for（intm=0;
m++）
visit[m]=m;
//每一个顶点属于一颗树
for（inti=0;
for（intj=0;
Edge1[i][j]=Edge[i][j];
while（k<
numVertices-1）
{min=maxWeight;
{for（intj=0;
{if（Edge1[i][j]<
min）
{a=i;
b=j;
min=Edge1[i][j];
}}}
if（visit[a]!
=visit[b]）
VerticesList[a]<
VerticesList[b]<
k++;
for（intn=0;
n++）
{if（visit[n]==visit[b]）visit[n]=visit[a];
}}
elseEdge1[a][b]=Edge[b][a]=maxWeight;
////////////Prim函数的实现////
prim（）
{charu;
请输入起始顶点：
u;
inti=this->
getVertexPos（u）;
visit[i]=1;
{closeedge[j].begvex=u;
closeedge[j].endvex=VerticesList[j];
closeedge[j].lowcost=Edge[i][j];
for（intm=1;
{intn=mini（）;
visit[n]=1;
closeedge[n].lowcost=maxWeight;
for（intp=0;
p<
p++）
visit[p]）
{if（Edge[p][n]<
closeedge[p].lowcost）
{closeedge[p].lowcost=Edge[p][n];
closeedge[p].begvex=VerticesList[n];
}}}}}
实验结果
实验体会
经过这次实验让我更深刻的理解了C++类的的结构，能够对二维数组的动态开辟空间和释放空间有了更深刻的理解，对图的遍历及构建最小生成树也有了深刻的体会。
总之，在这次试验中，学到了许多，也提高了自己的编程能力。
实验二、快速排序算法的实现
选取表中一个元素r[k]（一般选第一个元素），令x=r[k]称为控制关键字，用控制关键字和无序区中其余元素关键字进行比较
设置两个指示器i，j，分别表示线性表第一个和最后一个元素位置
将j逐渐减小，逐次比较r[j]与x，直到出现一个r[j]<
x，然后将r[j]移动到r[i]位置。
将i逐渐增大，并逐次比较r[i]与x，直到发现一个r[i]>
x，然后将r[i]移动到r[j]位置
重复上述过程，知道i=j位置，并将x移动到r[j]位置，此时线性表以x为界分割成两个子区间
实现快速排序功能
constmaxSize=100;
intpartition（intdata[],intfirst,intend）//在实现快速排序函数时要用，这是快速排序的一趟算法
{
inti=first;
intj=end;
inttemp;
j）
{
while（i<
j&
data[i]<
=data[j]）//向右扫描
j--;
if（i<
{
temp=data[i];
data[i]=data[j];
data[j]=temp;
}
=data[j]）//向左扫描
classKJL_CSort
public:
KJL_CSort（）;
~KJL_CSort（）;
//排序算法的具体实现
voidQuickSort（）;
voidinput（）;
voidoutput（）;
//成员变量
int*data;
intfirst,end;
intsize;
//当前数组大小
};
KJL_CSort:
KJL_CSort（）
first=0;
end=0;
size=0;
data=newint[maxSize];
maxSize;
data[j]=0;
~KJL_CSort（）
delete[]data;
voidKJL_CSort:
inti;
请输入数组大小：
size;
end=size-1;
输入数组的值：
intm;
cin>
data[i];
output（）
"
QuickSort（）
intpivot;
if（first<
end）
pivot=partition（data,first,end）;
end=pivot-1;
QuickSort（）;
first=pivot+1;
first=0;
voidmain（）
KJL_CSortbiao;
biao.input（）;
快速排序前的顺序：
biao.output（）;
biao.QuickSort（）;
快速排序后的顺序：
快速排序法，是众多排序方法中的一种，这种方法的优点在于它的比较次数少，每经过一趟比较，都可以把一个无序的数组分成两个部分，左边的部分全部小于（大于）右边的部分。
在实现这个算法过程中，采用的时递归调用的方式。
这让我对递归又有了更深层次的理解，对数组的排序，也不仅仅局限于冒泡，选择排序，在快速排序的基础上设计了以个快速排序类。
实验三、矩阵类的设计与实现
按照上述矩阵类的设计，完成相应函数的编码
对于矩阵数据的存储，可以
升级会员 