《数据结构》课程设计报告

分类：数据结构作者：编程之家用户

  1. 课程设计题目

题目0：校园最短路径问题

  1. 功能

    1. 输出顶点信息：将校园内各位置输出。

    2. 输出边的信息：将校园内每两个位置（若两个位置之间有直接路径）的距离输出。

    3. 修改：修改两个位置（若两个位置之间有直接路径）的距离，并重新输出每两个位置（若两个位置之间有直接路径）的距离。

    4. 求最短路径：输出给定两点之间的最短路径的长度及途径的地点或输出任意一点与其它各点的最短路径。

    5. 删除：删除任意一条边。

    6. 插入：插入任意一条边。

  2. 课程设计要求

GDOU是真是一个好地方，校园如一座大花园，美丽而宽广。校园有许多建筑如教学楼、饭堂、宿舍楼、图书馆、体育馆、运动场、商业街、医院等，还有一些著名的风景点。现请根据学校的平面图，找出一些重要的场所，画出学校的平面图（场所可以根据其重要性适当减少），根据实际画出不同点间的路径，并估算每两个场所间的路径长。请设计数据结构并编程，当给出一个出发点和要到达另外一个场所的信息时，请给出最佳路径，并输出路径相关信息。

  1. 分析

  1. 问题描述

图的最短路径问题是指从指定的某一点v开始，求得从该地点到图中其它各地点的最短路径，并且给出求得的最短路径的长度及途径的地点。除了完成最短路径的求解外，还能对该图进行修改，如顶点以及边的增删、边上权值的修改等。

校园最短路径问题中的数据元素有：

    1. 顶点数

    2. 边数

    3. 边的长度

  1. 实现要点

    1. 对图的创建采用邻接矩阵的存储结构，而且对图的操作设计成了模板类。为了便于处理，对于图中的每一个顶点和每一条边都设置了初值。

    2. 为了便于访问，用户可以先输出所有的地点和距离。

    3. 用户可以随意修改两点之间好的距离。

    4. 用户可以增加及删除边。

    5. 当用户操作错误时，系统会出现出错提示。

  2. 调试分析

  1. 本程序在求最短路径的问题上采用迪杰斯特拉算法解决，虽然该算法与弗洛伊德算法相比时间复杂度低，但每求一条最短路径都必须重新搜索一遍，在频繁查询时会导致查询效率低，而弗洛伊德算法只要计算一次，即可求得每一对顶点之间的最短路径，虽然时间复杂度为高，但以后每次查询只要查表即可，会极大地提高查询的效率，而且，弗洛伊德算法还支持带负权的图的最短路径的计算。由此可见，选用算法时必须综合各方面因素考虑。

  2. 由于功能函数较多，在编写程序时将函数逐个添加完成的，就是说，每增加一个函数，进行一次编译运行，此函数通过了再写下一个函数。或许这种方法比较麻烦，但当有错误时只要针对新加函数进行修改即可。同时，要充分利用软件所提供的调试功能，这也会大大减少编程人员的负担。

  1. 程序设计

  1. 概要设计

  1. 抽象数据类型图的定义如下：

    ADT Graph{

    数据对象V：V是具有相同特性数据元素的集合，称为顶点集。

    数据关系R：

    R={VR}

    VR={（v，w）| v,w∈V,(v,w)表示v和w之间存在路径}

    基本操作P：

    CreatGraph(&G,V,VR)

    初始条件：V是图的顶点集，VR是图中边的集合。

    操作结果：按定义(V,VR)构造图G。

    DestroyGraph(&G)

    初始条件：图G已存在。

    操作结果：销毁图。

    LocateVex(G,u)

    初始条件：图G存在，u和G中顶点具有相同特征。

    操作结果：若G中存在顶点u，则返回该顶点在图中“位置”；否则返回

    其它信息。

    GetVex(G,v)

    初始条件：图G存在，v是G中某个顶点。

    操作结果：返回v的信息。

    InsertVex(&G,sans-serif; font-size:10.5pt; font-style:normal; font-weight:normal; margin-top:0cm; margin-bottom:0pt"> 初始条件：图G存在，v和G中顶点具有相同特征。

    操作结果：在图G中增添新顶点v。

    DeleteVex(&G,v)

    操作结果：删除G中顶点v及其相关的边。

    InsertArc(&G,v,w)

    初始条件：图G存在，v和w是G中两个顶点。

    操作结果：在G中增添弧<v,w>，若G是无向的，则还增添对称弧<w,v>。

    DeleteArc(&G,sans-serif; font-size:10.5pt; font-style:normal; font-weight:normal; margin-top:0cm; margin-bottom:0pt"> 操作结果：在G中删除弧<v,w>，若G是无向的，则还删除对称弧<w,sans-serif; font-size:10.5pt; font-style:normal; font-weight:normal; margin-top:0cm; margin-bottom:0pt"> } ADT Graph

  2. 主程序

    voidmain()

    {

    初始化；

    while(“命令”!=“退出”)

    Switch语句

    接受命令（输入选择项序号）；

    处理命令；

    }

    }

  3. 本程序运用函数的调用，只有两个模块，它们的调用关系为：

    主程序模块

带权无向图模块

  1. 详细设计

typedef struct//图中顶点表示点，存放点名称

void Menu()//输出菜单

void PutOutVex(MGraph *G)//输出每个顶点的信息

void PutOutArc(MGraph *G)//输出每条边的信息

void Dijkstra(MGraph * G)//迪杰斯特拉算法求最短路径

void DeleteVex(MGraph *G)//删除某个顶点

void DeleteArc(MGraph *G)//删除某条边

void InsertArc(MGraph *G)//插入某条边

void main()//主函数

  1. 源程序代码

#include <stdio.h> 
#include <iostream.h>
#include<stdlib.h> 
#include<conio.h> 
#include <malloc.h> 
#include<string.h> 
#define MAX 10000 
#define MAXLEN 10 
#define ADJTYPE int 
typedef struct                            //图中顶点表示点，存放点名称 
{ 
char name[30]; 
 int num; 
}VEXTYPE; 
typedef struct 
{ 
VEXTYPE vexs[MAXLEN];               //顶点的信息 
ADJTYPE arcs[MAXLEN][MAXLEN];      //邻接矩阵 
int vexnum,arcnum ;                      //顶点数和边数 
}MGraph;
MGraph b; 
MGraph InitGraph()
{                                      /*建立无向网的邻接矩阵结构*/ 
int i,j; 
MGraph G; 
G.vexnum =10;                            //存放顶点数
G.arcnum =24;                            //存放边点数 
for(i=0;i<G.vexnum;i++) 
G.vexs[i].num=i; 
strcpy(G.vexs[0].name,"   广东海洋大学正门"); 
strcpy(G.vexs[1].name,"   商业中心"); 
strcpy(G.vexs[2].name,"   主楼"); 
strcpy(G.vexs[3].name,"   图书馆"); 
strcpy(G.vexs[4].name,"   体育馆"); 
strcpy(G.vexs[5].name,"   钟海楼"); 
strcpy(G.vexs[6].name,"   第一饭堂"); 
strcpy(G.vexs[7].name,"   第三饭堂"); 
strcpy(G.vexs[8].name,"   第四饭堂"); 
strcpy(G.vexs[9].name,"   校医院"); 
for(i=0;i<G.vexnum;i++) 
    for(j=0;j<G.vexnum;j++) 
       G.arcs[i][j]=MAX;
G.arcs[0][1]=395;
G.arcs[0][2]=380; 
G.arcs[0][3]=504; 
G.arcs[0][4]=415; 
G.arcs[0][5]=703; 
G.arcs[0][6]=436;
G.arcs[0][7]=840; 
G.arcs[0][8]=1000; 
G.arcs[0][9]=1100;  
G.arcs[1][2]=264; 
G.arcs[1][3]=170; 
G.arcs[1][4]=86; 
G.arcs[1][6]=81; 
G.arcs[2][3]=230;
G.arcs[2][4]=209;
G.arcs[2][5]=328; 
G.arcs[2][6]=310;   
G.arcs[3][4]=87;
G.arcs[3][5]=295;
G.arcs[3][6]=146;   
G.arcs[4][6]=102; 
G.arcs[5][7]=153; 
G.arcs[7][8]=393; 
G.arcs[7][9]=359;
G.arcs[8][9]=645; 
for(i=0;i<G.vexnum;i++) 
    for(j=0;j<G.vexnum;j++) 
     G.arcs[j][i]=G.arcs[i][j];
return G;
}
void Menu()                               //输出菜单
{ 
  cout<<"        ********** 欢迎来到广东海洋大学 ********** \n";
  cout<<"       ┏━━━━━━━━━━━━━━━━━━━━┓\n";
  cout<<"       ┃          0. 输出顶点(地点)的信息   ┃\n";
  cout<<"       ┃          1. 输出边(路径)的信息     ┃\n"; 
  cout<<"       ┃          2. 修改                 ┃\n"; 
  cout<<"       ┃          3. 求出最短路径          ┃\n";
  cout<<"       ┃          4. 删除某个顶点(地点)     ┃\n"; 
  cout<<"       ┃          5. 删除某条边(路径)       ┃\n"; 
  cout<<"       ┃          6. 需要插入某条边(路径)   ┃\n"; 
  cout<<"       ┃          7. 退出系统              ┃\n";
  cout<<"       ┗━━━━━━━━━━━━━━━━━━━━┛\n";
} 
void PutOutVex(MGraph *G)                 //输出每个顶点的信息
{
int v; 
for(v=0;v<G->vexnum;v++) 
 cout<<G->vexs[v].num<<G->vexs[v].name<<endl; 
}
void PutOutArc(MGraph *G)                 //输出每条边的信息
{
for(int i=0;i<G->vexnum;i++) 
    for(int j=0;j<G->vexnum;j++) 
       if(G->arcs[i][j]<MAX)
    {cout<<"     从 " <<G->vexs[i].name<<" 到 "<<G->vexs[j].name<<"的距离是 "<<G->arcs[i][j]<<"米"<<endl;
     cout<<"     ━━━━━━━━━━━━━━━━━━━━━━━━━━"<<endl;
    }
}
void Change(MGraph *G)                    //修改
{ int v0,v1,length;
  cout<<"change\n"; 
  cin>>v0; 
  cin>>v1; 
  cout<<"length:"; 
  cin>>length;
  G->arcs[v0][v1]=G->arcs[v1][v0]=length;
}

void Dijkstra(MGraph * G)                  //迪杰斯特拉算法求最短路径
{
 int v,w,i,min,t=0,x,v0,v1; 
 int final[40],D[40],p[40][40]; 
 cout<<"请输入源顶点:\n"; 
 cin>>v0; 
 if(v0<0||v0>G->vexnum) 
 { 
  cout<<"此点编号不存在!请重新输入顶点编号:"; 
  cin>>v0; 
 } 
 cout<<"请输入结束顶点:\n"; 
 cin>>v1; 
 if(v1<0||v1>G->vexnum) 
 { 
  cout<<"此点编号不存在!请重新输入顶点编号:"; 
  cin>>v1; 
 } 
 for(v=0;v<G->vexnum;v++) 
 {// 初始化final[40],p[40][40],final[v]=1即已经求得v0到v的最短路径，
  //p[v][w]=1则是w从v0到v当前求得最短路径上的顶点，D[v]带权长度
  final[v]=0; 
  D[v]=G->arcs[v0][v]; 
  for(w=0;w<G->vexnum;w++) 
   p[v][w]=0; 
  if(D[v]<MAX) 
  { 
   p[v][v0]=1;p[v][v]=1; 
  } 
 } 
 D[v0]=0;final[v0]=1; 
 for(i=1;i<G->vexnum;i++) 
 { 
  min=MAX; 
  for(w=0;w<G->vexnum;w++) 
   if(!final[w])                                                                                     
    if(D[w]<min){v=w;min=D[w];} 
    final[v]=1; 
    for(w=0;w<G->vexnum;w++) 
     if(!final[w]&&(min+G->arcs[v][w]<D[w])) 
     { 
      D[w]=min+G->arcs[v][w]; 
      for(x=0;x<G->vexnum;x++) 
       p[w][x]=p[v][x]; 
      p[w][w]=1; 
     }
 }
 cout<<"     从 "<<G->vexs[v0].name<<" 到 "<<G->vexs[v1].name<<" 的最短路径长度为："<<D[v1]<<"米"<<endl;
 cout<<"     路径为：";
 for(int j=0;j<G->vexnum;j++)
 {
  if(p[v1][j]==1)
   cout<<G->vexs[j].name<<endl;
 }
}
void DeleteVex(MGraph *G)                  //删除某个顶点
{
	int row,col;
	int v0;
	cout<<"请输入要删除的顶点";
	cin>>v0;
	for(int i=v0;i<G->vexnum;i++)
		G->vexs[i]=G->vexs[i+1];
	G->vexnum--;
	for(row=0;row<G->vexnum;row++)
		{
			for(col=v0;col<G->vexnum;col++)
				G->arcs[row][col]=G->arcs[row][col+1];
		}
	for(col=0;col<G->vexnum;col++)
		{
			for(row=v0;row<G->vexnum;row++)
			G->arcs[col][row]=G->arcs[col][row+1];
		}
}

void DeleteArc(MGraph *G)                  //删除某条边
{
 int v0,v1;
 cout<<"请输入两顶点:\n"; 
 cin>>v0>>v1;
 G->arcs[v0][v1]=MAX;
 G->arcs[v1][v0]=MAX;
}
void InsertArc(MGraph *G)                  //插入某条边
{
 int v0,l=0;
 cout<<"请输入两顶点:\n"; 
 cin>>v0>>v1;
 cout<<"请输入路径长度:\n"; 
 cin>>l;
 G->arcs[v0][v1]=l;
 G->arcs[v1][v0]=l;
}

void main()                                //主函数
{ int a; 
 b=InitGraph(); 
 Menu(); 
 cin>>a; 
 while(a!=7) 
 { 
  switch(a) 
  {
  case 0:PutOutVex(&b);Menu();break;  
  case 1:PutOutArc(&b);Menu();break; 
  case 2:Change(&b);Menu();break; 
  case 3:Dijkstra(&b);Menu();break;
  case 4:DeleteVex(&b);Menu();break;    
  case 5:DeleteArc(&b);Menu();break; 
  case 6:InsertArc(&b);Menu();break;
  case 7:exit(1);break; 
  default:break; 
  } 
  cin>>a; 
 } 
}
  1. 调试结果

开始界面


输出顶点（地点）信息


输出边（路径）的信息



修改


求出最短路径



删除某个顶点（地点）




删除某条边（路径）


需要插入某条边（路径）


退出系统



  1. 总结体会


课程设计是培养学生综合运用所学知识，发现、提出、分析和解决实际问题，锻炼实践能力的重要环节，是对学生实际工作能力的具体训练和考察过程。通过这次课程设计，使我懂得了理论与实际相结合是很重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，将结论用于实践，从而提高自己的实际动手能力和独立思考的能力。在设计的过程中遇到了很多问题，可以说得是困难重重，但这是不可避免的。在这次课程设计的过程中，我发现了自己的不足之处，对以前所学过的知识理解得不够深刻，掌握得不够牢固，知识面太窄。由于编程水平有限，其中迪杰斯特拉算法的C++程序是参考网上的资料，有关校园地图的输出也没有实现。我想在以后的学习中，我要更注重实践这一环节。








版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

【啊哈！算法】算法3：最常用的排序——快速排序
【啊哈！算法】算法3：最常用的排序——快速排序       上一节的冒泡排序可以说是我们学习第一个真正的排序算法，并且解决了桶排序浪费空间的问题，但在算法的执行效率上却牺牲了很多，它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次，那么对1亿个数进行排序，桶排序则只需要0.1秒，而冒泡排序则需要1千万秒，达到115天之久，是不是很吓人。那有没有既不浪费空间又可以快一点的排序算法
[数据结构与算法]模式匹配与文本处理-匿名组与命名组
匿名组 这里可能用到几个不同的分组构造。通过括号内围绕的正则表达式就可以组成第一个构造。正如稍后要介绍的一样，既然也可以命名组，大家就有考虑把这个构造作为匿名组。作为一个实例，请看看下列字符串： “08/14/57 46 02/25/59 45 06/05/85 18 03/12/88 16 09/09/90 13“ 这个字符串就是由生日和年龄组成的。如果需要匹配年两而不要生日，就可以把正则
[C#]选择排序
选择排序：从数组的起始位置处开始，把第一个元素与数组中其他元素进行比较。然后，将最小的元素方式在第0个位置上，接着再从第1个位置开始再次进行排序操作。这种操作一直到除最后一个元素外的每一个元素都作为新循环的起始点操作过后才终止。 public void SelectionSort() { int min, temp;
[数据结构与算法]队列的优先级
public struct Pqitem { public int priority; public string name; } class CQueue { private ArrayList pqueue; public CQueue() { pqueue
[数据结构与算法]模式匹配-数量词
在编写正则表达式的时候，经常会向要向正则表达式添加数量型数据，诸如”精确匹配两次”或者”匹配一次或多次”。利用数量词就可以把这些数据添加到正则表达式里面了。 数量词(+):这个数量词说明正则表达式应该匹配一个或多个紧紧接其前的字符。 string[] words = new string[] { "bad", "boy", "baad", "baaad" ,"bear", "b
[数据结构与算法]白话经典算法系列之五 归并排序的实现
来自：http://blog.csdn.net/morewindows/article/details/6678165/归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列
[C#]插入排序
插入排序算法有两层循环。外层循环会啄个遍历数组元素，而内存循环则会把外层循环所选择的元素与该元素在数组内的下一个元素进行比较。如果外层循环选择的元素小于内存循环选择的元素，那么瘦元素都想右移动以便为内存循环元素留出位置。 public void InsertionSort() { int inner, temp;
[C#]二叉查找法
public int binSearch(int value) { int upperBround, lowerBound, mid; upperBround = arr.Length - 1; lowerBound = 0; while (lowerBound <= upper
[数据结构与算法]双向链表
虽然从表内第一个节点到最后一个节点的遍历操作是非常简单的，但是反向遍历链表却不是一件容易的事情。如果为Node类添加一个字段来存储指向前一个节点的连接，那么久会使得这个反向操作过程变得容易许多。当向链表插入节点的时候，为了吧数据复制给新的字段会需要执行更多的操作，但是当腰吧节点从表移除的时候就能看到他的改进效果了。 首先需要修改Node类来为累增加一个额外的链接。为了区别两个连接，这个把指
[数据结构]树及树的遍历
八、树（Tree）树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂：当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图：面试的时候我们经常被考到的是一种叫“二叉树”的结构，二叉
[数据结构]队列的操作
Queue的实现： 就像Stack类的实现所做的一样，Queue类的实现用ArrayList简直是毋庸置疑的。对于这些数据结构类型而言，由于他们都是动态内置的结构，所以ArrayList是极好的实现选择。当需要往队列中插入数据项时，ArrayList会在表中把每一个保留的数据项向前移动一个元素。 class CQueue { private ArrayLis
[数据结构与算法]常用排序算法的动画效果图
来自：http://yingyingol.iteye.com/blog/13348911 快速排序介绍：快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地
[C#]Stack类的实现
Stack的实现必须采用一种基本结构来保存数据。因为再新数据项进栈的时候不需要担心调整表的大小，所以选择用arrayList.using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Collecti
[C#]冒泡排序
数组类测试环境与排序算法using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace Data_structure_and_algorithm{ class CArray { pr
[数据结构与算法]二叉树与二叉树遍历
一、构造二叉树 二叉树查找树由节点组成，所以需要有个Node类，这个类类似于链表实现中用到的Node类。首先一起来看看Node类的代码。 public class Node { public int Data; public Node Left; public Node Right; public v
【啊哈！算法】算法10：二叉树
二叉树是一种特殊的树。二叉树的特点是每个结点最多有两个儿子，左边的叫做左儿子，右边的叫做右儿子，或者说每个结点最多有两棵子树。更加严格的递归定义是：二叉树要么为空，要么由根结点、左子树和右子树组成，而左子树和右子树分别是一棵二叉树。 下面这棵树就是一棵二叉树。         二叉树的使用范围最广，一棵多叉树也可以转化为二叉树，因此我们将着重讲解二叉树。二叉树中还有连两种特殊的二叉树叫做满二叉树和
【啊哈！算法】算法4：解密QQ号——队列
上一节中我们学习了队列，它是一种先进先出的数据结构。还有一种是后进先出的数据结构它叫做栈。栈限定只能在一端进行插入和删除操作。比如说有一个小桶，小桶的直径只能放一个小球，我们现在向小桶内依次放入2号、1号、3号小球。假如你现在需要拿出2号小球，那就必须先将3号小球拿出，再拿出1号小球，最后才能将2号小球拿出来。在刚才取小球的过程中，我们最先放进去的小球最后才能拿出来，而最后放进去的小球却可以最先拿
[数据结构与算法]模式匹配与文本处理-零宽度正预测先行断言 and 零宽度正回顾后发断言
msdn中的描述如下：(?= 子表达式)（零宽度正预测先行断言。） 仅当子表达式在此位置的右侧匹配时才继续匹配。例如，w+(?=d) 与后跟数字的单词匹配，而不与该数字匹配。此构造不会回溯。(?（零宽度正回顾后发断言。） 仅当子表达式在此位置的左侧匹配时才继续匹配。例如，(?此构造不会回溯。msdn描述的比较清楚，如：w+(?=ing) 可以匹配以ing结尾的单词(匹配结果不包括ing)，(
[数据结构]线索二叉树
1.引入线索二叉树 二叉树的遍历实质上是对一个非线性结构实现线性化的过程，使每一个节点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。但在二叉链表存储结构中，只能找到一个节点的左、右孩子信息，而不能直接得到节点在任一遍历序列中的前驱和后继信息。这些信息只有在遍历的动态过程中才能得到，因此，引入线索二叉树来保存这些从动态过程中得到的信息。 2.建立线索二叉树 为了保
[数据结构与算法]超级详细解读基本排序算法不看后悔，带排序演示动画
排序与我们日常生活中息息相关，比如，我们要从电话簿中找到某个联系人首先会按照姓氏排序、买火车票会按照出发时间或者时长排序、买东西会按照销量或者好评度排序、查找文件会按照修改时间排序等等。在计算机程序设计中，排序和查找也是最基本的算法，很多其他的算法都是以排序算法为基础，在一般的数据处理或分析中，通常第一步就是进行排序，比如说二分查找，首先要对数据进行排序。在Donald Knuth 的计算机程序设
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot