测绘软件实习报告文档格式.docx
《测绘软件实习报告文档格式.docx》由会员分享,可在线阅读,更多相关《测绘软件实习报告文档格式.docx(63页珍藏版)》请在冰豆网上搜索。
![测绘软件实习报告文档格式.docx](https://file1.bdocx.com/fileroot1/2023-1/27/dc407adc-4928-45a2-91e5-fc5a522f7079/dc407adc-4928-45a2-91e5-fc5a522f70791.gif)
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();
快速排序后的顺序:
快速排序法,是众多排序方法中的一种,这种方法的优点在于它的比较次数少,每经过一趟比较,都可以把一个无序的数组分成两个部分,左边的部分全部小于(大于)右边的部分。
在实现这个算法过程中,采用的时递归调用的方式。
这让我对递归又有了更深层次的理解,对数组的排序,也不仅仅局限于冒泡,选择排序,在快速排序的基础上设计了以个快速排序类。
实验三、矩阵类的设计与实现
按照上述矩阵类的设计,完成相应函数的编码
对于矩阵数据的存储,可以