数据结构与算法大作业（用c语言完成：1.哈夫曼编码/译码器2.内部排序算法的性能分析）

本文目录

• 用c语言完成：1.哈夫曼编码/译码器2.内部排序算法的性能分析
• C语言大作业 学生成绩管理系统
• 数据结构（C语言版）课程设计大作业，急！！！
• 数据结构中G.arcs[i][j]={INFINITY,NULL};什么意思，还有书上的各种算法怎么实现成程序
• 《面向用户的软件界面设计》大作业要求
• 数据结构大作业 寻求帮助. 求高人
• 急求求大仙帮忙！C语言数据结构课程设计，关于旅游图

用c语言完成：1.哈夫曼编码/译码器2.内部排序算法的性能分析

我把网上的程序修改了一下，并整合了，你看看
#include《stdio.h》
#include《string.h》
#include《stdlib.h》
#define M 50
#define MAX 100000;
typedef struct
{
int weight;//结点权值
int parent,lchild,rchild;
}HTNODE,*HUFFMANTREE;
typedef char** HUFFMANCODE;//动态分配数组存储哈夫曼编码表
typedef struct
{
int key; /*关键字*/
}RecordNode; /*排序节点的类型*/
typedef struct
{
RecordNode *record;
int n; /*排序对象的大小*/
}SortObject; //待排序序列
HUFFMANTREE huffmantree(int n,int weight)//构建哈夫曼树
{
int m1,m2,k;
int i,j,x1,x2;
HUFFMANTREE ht;
ht=(HUFFMANTREE)malloc((2*n)*sizeof(HTNODE));
for(i=1;i《(2*n);i++)//初始化哈夫曼树中各结点的数据，没初始值的赋值为0
{
ht.rchild=0;
if(i《=n)
ht;
else
ht.weight=0;
}
for(i=1;i《n;i++)//每一重循环从森林中选择最小的两棵树组建成一颗新树
{
m1=m2=MAX;
x1=x2=0;
for(j=1;j《(n+i);j++)
{
if((ht.parent==0))
{
m2=m1;
x2=x1;
m1=ht.weight;
x1=j;
}
else if((ht.parent==0))
{
m2=ht.weight;
x2=j;
}
}
k=n+i;
ht.parent=k;
ht.weight=m1+m2;
ht.lchild=x1;
ht.rchild=x2;
}
return ht;
}
void huffmancoding(int n,HUFFMANCODE hc,HUFFMANTREE ht,char str)
{
int i,start,child,father;
char *cd;
hc=(HUFFMANCODE)malloc((n+1)*sizeof(char*));//分配n个字符编码的头指针
cd=(char*)malloc(n*sizeof(char));//分配求编码的工作空间
cd=’\0’;//编码结束符
for(i=1;i《=n;++i)//逐个字符求哈夫曼编码
{
start=n-1;
for(child=i,father=ht.parent)/*从叶子结点到根结点求逆向编码*/
if(ht.lchild==child)
cd=’0’;
else
cd=’1’;
hc=(char*)malloc((n-start)*sizeof(char));//为i个字符编码分配空间
strcpy(hc);//从cd复制哈夫曼编码串到hc
}
free(cd);//释放工作空间
for(i=1;i《=n;++i)
{
printf("\n%c的编码:",str);
printf("%s\n",hc);
}
}
void huffman()
{
int i,j,k,m,n;
char str;
int weight;
HUFFMANCODE hc=NULL;
HUFFMANTREE ht;
fflush(stdin);
printf("\n请输入字符(一次性连续输入所求的字符):");/*如:abcjhjg不要输成ab cj hig,即字符间不加空格*/
gets(str);
for(j=0;j《50;j++)
{
if(str==’\0’)
break;
}
n=j;
for(j=n;j》0;j--)
str;
str=’\0’;
for(k=0;k《n;k++)
{
printf("\n请输入%c的权值:",str);
scanf("%d",&weight);
}
for(k=n;k》0;k--)
weight;
weight=0;
ht=huffmantree(n,weight);
huffmancoding(n,hc,ht,str);
}
void InsertSort(SortObject *p,unsigned long *compare,unsigned long *exchange)
{
int i,j,k;
RecordNode temp;
SortObject *pvector;
fflush(stdin);
if((pvector=(SortObject *)malloc(sizeof(SortObject)))==NULL)
{
printf("OverFollow!");
getchar();
exit(1);
}
k=pvector-》n;
pvector-》record=(RecordNode *)malloc(sizeof(RecordNode)*k);
for(i=0;i《p-》n;i++)/* 复制数组*/
pvector-》record;
pvector-》n=p-》n;
*compare=0;
*exchange=0;
for(i=1;i《pvector-》n;i++)
{
temp=pvector-》record;
(*exchange)++;
j=i-1;
while((temp.key《pvector-》record.key)&&(j》=0))
{
(*compare)++;
(*exchange)++;
pvector-》record;
j--;
}
if(j!=(i-1))
{
pvector-》record=temp;
(*exchange)++;
}
}
free(pvector);
}
void SelectSort(SortObject *p,unsigned long *compare,unsigned long *exchange)
{
int i,j,k;
RecordNode temp;
SortObject *pvector;
if((pvector=(SortObject *)malloc(sizeof(SortObject)))==NULL)
{
printf("OverFollow!");
getchar();
exit(1);
}
k=pvector-》n;
pvector-》record=(RecordNode *)malloc(sizeof(RecordNode)*k);
for(i=0;i《p-》n;i++)/*复制数组*/
pvector-》record;
pvector-》n=p-》n;
*compare=0;
*exchange=0;
for(i=0;i《pvector-》n-1;i++)
{
k=i;
for(j=i+1;j《pvector-》n;j++)
{
(*compare)++;
if(pvector-》record.key)
k=j;
}
if(k!=i)
{
temp=pvector-》record;
pvector-》record;
pvector-》record=temp;
( *exchange)+=3;
}
}
free(pvector);
}
void BubbleSort(SortObject *p,unsigned long *compare,unsigned long *exchange)
{
int i,j,noswap,k;
RecordNode temp;
SortObject *pvector;
if((pvector=(SortObject *)malloc(sizeof(SortObject)))==NULL)
{
printf("OverFollow!");
getchar();
exit(1);
}
k=pvector-》n;
pvector-》record=(RecordNode *)malloc(sizeof(RecordNode)*k);
for(i=0;i《p-》n;i++)/* 复制数组*/
pvector-》record;
pvector-》n=p-》n;
*compare=0;
*exchange=0;
for(i=0;i《pvector-》n-1;i++)
{
noswap=1;
for(j=0;j《pvector-》n-i-1;j++)
{
(*compare)++;
if(pvector-》record.key)
{
temp=pvector-》record;
pvector-》record;
pvector-》record=temp;
(*exchange)+=3;
noswap=0;
}
}
if(noswap) break;
}
free(pvector);
}
void ShellSort(SortObject *p,int d,unsigned long *compare,unsigned long *exchange)
{
int i,j,increment,k;
RecordNode temp;
SortObject *pvector;
if((pvector=(SortObject*)malloc(sizeof(SortObject)))==NULL)
{
printf("OverFollow!");
getchar();
exit(1);
}
k=pvector-》n;
pvector-》record=(RecordNode *)malloc(sizeof(RecordNode)*k);
for(i=0;i《p-》n;i++)/* 复制数组*/
pvector-》record;
pvector-》n=p-》n;
*compare=0;
*exchange=0;
for(increment=d;increment》0;increment/=2)
{
for(i=increment;i《pvector-》n;i++)
{
temp=pvector-》record;
(*exchange)++;
j=i-increment;
while(j》=0&&temp.key《pvector-》record.key)
{
(*compare)++;
pvector-》record;
(*exchange)++;
j-=increment;
}
pvector-》record=temp;
(*exchange)++;
}
}
free(pvector);
}
void QuickSort(SortObject *pvector,int left,int right,unsigned long *compare,unsigned long *exchange)
{
int i,j;
RecordNode temp;
if(left》=right)
return;
i=left;
j=right;
temp=pvector-》record;
(*exchange)++;
while(i!=j)
{
while((pvector-》record.key》=temp.key)&&(j》i))
{
(*compare)++;
j--;
}
if(i《j)
{
pvector-》record;
(*exchange)++;
}
while((pvector-》record.key《=temp.key)&&(j》i))
{
(*compare)++;
i++;
}
if(i《j)
{
pvector-》record;
(*exchange)++;
}
}
pvector-》record=temp;
(*exchange)++;
QuickSort(pvector,left,i-1,compare,exchange);
QuickSort(pvector,i+1,right,compare,exchange);
}
void SortMethod(void)
{
int i,j,k,l;
unsigned long num={0};
unsigned long sum={0};
SortObject *pvector;
fflush(stdin);
printf("请输入待排序的随机数个数：\n");
scanf("%d",&k);
pvector=(SortObject *)malloc(sizeof(SortObject));
for(j=0;j《5;j++)
{
pvector-》record=(RecordNode *)malloc(sizeof(RecordNode)*k);
for(i=0;i《k;i++)
pvector-》record.key=rand();
pvector-》n=k;
InsertSort(pvector,#);
SelectSort(pvector,#);
BubbleSort(pvector,#);
ShellSort(pvector,4,#);
QuickSort(pvector,0,k-1,#);
}
printf("\n排序比较如下");
for(j=0;j《5;j++)
{
printf("\n\n对%d个数进行排序，结果为：\n",k);
printf("1.插入排序：比较--》%-7ld次 移动--》%-7ld次\n",num);
printf("2.选择排序：比较--》%-7ld次 移动--》%-7ld次\n",num);
printf("3.冒泡排序：比较--》%-7ld次 移动--》%-7ld次\n",num);
printf("4.希尔排序：比较--》%-7ld次 移动--》%-7ld次\n",num);
printf("5.快速排序：比较--》%-7ld次 移动--》%-7ld次\n",num);
if(j!=5)
printf("按回车继续\n");
getchar();
}
for(j=0;j《5;j++)
{
sum;
sum;
sum;
sum;
sum;
sum;
sum;
sum;
sum;
sum;
}
printf("\n\n对%d个随机数进行5次排序，平均比较次数和平均移动次数为：\n",k);
printf("1.插入排序：平均比较--》%-7ld次 平均移动--》%-7ld次\n",sum/5);
printf("2.选择排序：平均比较--》%-7ld次 平均移动--》%-7ld次\n",sum/5);
printf("3.冒泡排序：平均比较--》%-7ld次 平均移动--》%-7ld次\n",sum/5);
printf("4.希尔排序：平均比较--》%-7ld次 平均移动--》%-7ld次\n",sum/5);
printf("5.快速排序：平均比较--》%-7ld次 平均移动--》%-7ld次\n",sum/5);
free(pvector);
}
void sort()
{
int i;
while(1)
{
SortMethod();
printf("\n是否继续？\n1.继续\n2.返回菜单\n");
scanf("%d",&i);
if(i==2)break;
fflush(stdin);
getchar();
}
}
void huff()
{
int i;
while(1)
{
huffman();
printf("\n是否继续？\n1.继续\n2.返回菜单\n");
scanf("%d",&i);
if(i==2)break;
fflush(stdin);
getchar();
}
}
main()
{
int i,j,k;
while(1)
{
printf("请选择要运行的功能：\n");
printf("1.哈夫曼编码译码器\n");
printf("2.内部排序性能分析\n");
printf("3.退出该程序\n\n");
printf("你的选择为：");
scanf("%d",&i);
switch(i)
{
case 1:huff();break;
case 2:sort();break;
case 3:exit(0);
default:break;
}
fflush(stdin);
getchar();
system("cls");
}
}

C语言大作业 学生成绩管理系统

• 这个有难度啊！！！！

• 祝你成功

• 是vc还是控制台？这个需要时间

• 自己查查撒！！这种东西 还是需要点时间的！！

数据结构（C语言版）课程设计大作业，急！！！

以数组模拟卡片 TRUE向上 FALSE向下
循环模拟翻卡片 满足条件 card;
最后输出值为TRUE的数组元素
#include 《stdio.h》
#include 《string.h》
int main()
{
bool card;
memset(card,true,52);
for (int i=2,n=1;i《=52;i++,n++)
{
for(int j=n;j《52;j++)
{
if((j+1)%i==0) card;
}
}
for(int i=0;i《52;i++)
if(card) printf("%d ",i+1);
return 0;
}
改进 根据题意的翻牌规则 即求约数的过程 一个数的约数如果去掉1 包含自身的个数为奇数 即被翻了奇数次 向下，反之则向上。
#include 《stdio.h》
int main()
{
printf("1 ");
for(int i=4;i《=52;i++)
{
int count=0;
for(int j=2;j《=i/2;j++)
{
if(i%j==0) count++;
}
if(count%2!=0) printf("%d ",i);
}
return 0;
}
可见 在循环上节省了循环次数 而且去掉了申请CARD的空间 只需要一个count变量即可

数据结构中G.arcs[i][j]={INFINITY,NULL};什么意思，还有书上的各种算法怎么实现成程序

G.arcs其实就是一个邻接矩阵中的一个数，INFINITY是无穷的意思，大概意思就是定义顶点i到j是不连通的，所以度当然为NULL了。

书上算法实现的问题，你只要有C语言基础，然后注意每个C语言的结构体需要定义，还有就是书上的算法只是一个函数，不是主函数，主函数需要自己写，而且，书上给的函数中它调用了前面所讲的的函数，所以最好从前面开始写代码。

就线性表那你章，你要把结构体写到程序代码中去，然后要在主函数中定义它，最好从简单的开始，如初始化链表，然后create建立链表，还有写程序时要注意有些算法中的宏定义是没有给出的，需要自己定义。

PS：要实现书上的算法要学会自己调试程序，自己看着哪里错误，然后去修改，一步一步来，就能行的，相信自己

《面向用户的软件界面设计》大作业要求

软件设计师考试的总体要求
软件设计师主要完成三项工作：（1）编写文档；（2）组织指导程序员开展工作；（3）软件优化和集成测试，开发高质量软件。本工作要求具有工程师的实际工作能力和业务水平。具体讲就是，通过本考试的合格人员，能根据软件开发项目管理和软件工程的要求，按照系统总体设计规格说明书进行软件设计，编写程序设计规格说明书等相应的文档，组织和指导程序员编写、调试程序，并对软件进行优化和集成测试，开发出符合系统总体设计要求的高质量软件。
考试内容要求
知识点的掌握程度从深到浅可分五个层次，分别要求为熟练掌握、掌握、理解、熟悉和了解。其中包括2个熟练掌握（常用数据结构和常用算法、软件设计的方法和技术）、8个掌握、2个熟悉，1个正确理解，具体体现在以下12个方面：
(1) 掌握数据表示、算术和逻辑运算；
(2) 掌握相关的应用数学、离散数学的基础知识；
(3) 掌握计算机体系结构以及各主要部件的性能和基本工作原理；
(4) 掌握操作系统、程序设计语言的基础知识，了解编译程序的基本知识；
(5) 熟练掌握常用数据结构和常用算法；
(6) 熟悉数据库、网络和多媒体的基础知识；
(7) 掌握C程序设计语言，以及C++、Java、Visual Basic、Visual C++中的一种程序设计语言；
(8) 熟悉软件工程、软件过程改进和软件开发项目管理的基础知识；
(9) 熟练掌握软件设计的方法和技术；
(10) 掌握常用信息技术标准、安全性，以及有关法律、法规的基本知识；
(11) 了解信息化、计算机应用的基础知识；
(12) 正确阅读和理解计算机领域的英文资料。
分析：相对于2001年考试大纲，新大纲对知识面的要求更宽，更注重软件设计开发的实践能力，这一点充分体现在下午考试中。考试内容除了技术要求外，还增加了对软件工程实践能力、安全性、标准化、法律法规等方面知识的要求，毕竟软件设计师是软件产业的骨干，因此考试要求相对较高。
二、考试范围
考试科目1：计算机与软件工程知识
本部分包含以下内容：
l 计算机科学基础
l 计算机系统知识
l 系统开发和运行知识
l 安全性知识
l 标准化知识
l 信息化基础知识
l 计算机专业英语
1．计算机科学基础
1.1 数制及其转换
· 二进制、十进制和十六进制等常用制数制及其相互转换
1.2 数据的表示
·（原码、反码、补码、移码表示，整数和实数的机内表示，精度和溢出）
· 非数值表示（字符和汉字表示、声音表示、图像表示）
· 校验方法和校验码（奇偶校验码、海明校验码、循环冗余校验码）
1.3 算术运算和逻辑运算
· 计算机中的二进制数运算方法
· 逻辑代数的基本运算和逻辑表达式的化简
本部分要求与程序员考试大纲基本一致
重点：数的表示、校验码
难点：数的四种编码：原码、反码、补码、移码及相互之间的变换方法。浮点数的表示以及其规格化。
考试题型一般分布在：数制表示、数据表示、校验码的长度、逻辑表达式（公式、等效变换），明确“与”、“非”、“异或”的运算规则。
考试出现频率较高的内容：浮点数规格化、进制转换、求反补码。
1.4 数学基础知识
· 命题逻辑、谓词逻辑、形式逻辑的基础知识
· 常用数值计算（误差、矩阵和行列式、近似求解方程、插值、数值积分）
· 排列组合、概率论应用、应用统计（数据的统计分析）
· 运算基本方法（预测与决策、线性规划、网络图、模拟）
考纲要求掌握相关的应用数学、离散数学的基础知识
本部分内容作为背景知识，虽不专门考察，但在其他题目中尤其是程序设计中出现。
1.5 常用数据结构
· 数组（静态数组、动态数组）、线性表、链表（单向链表、双向链表、循环链表）、队列、栈、树（二叉树、查找树、平衡树、线索树、线索树、堆）、图等的定义、存储和操作
· Hash（存储地址计算，冲突处理）
1.6 常用算法
· 排序算法、查找算法、数值计算方法、字符串处理方法、数据压缩算法、递归算法、图的相关算法
· 算法与数据结构的关系、算法效率、算法设计、算法描述（流程图、伪代码、决策表）、算法的复杂性
因为数据结构是程序设计的基础，算法与数据结构密切相关，因此本部分为考试重点内容，要求熟练掌握。
重点：顺序存储结构和链式存储结构的特点、链表中的头结点、栈的运算与溢出、循环队列的基本操作
数组元素的存储位置、特殊矩阵的压缩存储、广义表的表头和表尾求法
二叉树存储方法、由遍历序列确定二叉树、二叉树的计数问题
图的遍历算法、最小生成树算法、拓朴排序和关键路径、最短路径算法
平均查找长度、折半查找判定树、平衡二叉树的最少结点数、插入运算及平衡化处理、哈希表的构造和查找
排序的稳定问题、快速排序的分析及改进、内部排序的时间下界、算法时间复杂度分析
难点：二叉树节点与深度的关系、图的存储（矩阵、邻接表）与操作、遍历、
考试出现频率较高的内容：树的遍历、数据元素存储方式、查找树、平衡树
考试题型一般分布在：数据元素存储方式、队和栈的性质及其对比、链表操作、二叉树的定义及其性质、二叉树的遍历/节点计算、树的遍历、查找树、平衡树等，图的概念及其性质。
常见的排序算法、查找算法、递归算法、算法的基本特点、常用算法思想、算法效率的比较（时间、空间复杂度）、算法描述、算法复杂性比较
2．计算机系统知识
2.1 硬件知识
2.1.1 计算机系统的组成、体系结构分类及特性
· CPU和存储器的组成、性能和基本工作原理
· 常用I/O设备、通信设备的性能，以及基本工作原理
· I/O接口的功能、类型和特性
·（中断系统、DMA、I/O处理机方式）
· CISC/RISC，流水线操作，多处理机，并行处理
2.1.2 存储系统
· 主存-Cache存储系统的工作原理
· 虚拟存储器基本工作原理，多级存储体系的性能价格
· RAID类型和特性
分析：磁盘存储器的容量计算、地址映射、流水线、系统结构分类
重点：Cache替换算法、内存与接口的编址方式、流水线操作
难点：I/O控制方式、地址计算、并行处理的概念和层次
考试出现频率较高的内容：指令的寻址方式以及指令的执行过程；存储容量的计算、
流水线处理机的主要指标、CISC/RISC比较等
2.1.3 安全性、可靠性与系统性能评测基础知识
· 诊断与容错
· 系统可靠性分析评价
· 计算机系统性能评测方式
本部分内容多为记忆型内容
重点：数据加密/解密知识、计算机安全等级、认证技术、数字签名等
平均无故障时间、平均修复时间定义、计算机可靠性模型、性能评价
难点：数据加密/解密知识、密钥体制
考试出现频率较高的内容：可靠性能评价、数据安全知识、计算机可靠性及性能评价
2.2 软件知识
2.2.1 操作系统知识
· 操作系统的内核（中断控制）、进程、线程概念
· 处理机管理（状态转换、共享与互斥、分时轮转、抢占、死锁）
· 存储管理（主存保护、动态连接分配、分段、分页、虚存）
· 设备管理（I/O控制、假脱机）
· 文件管理（文件目录、文件组织、存取方法、存取控制、恢复处理）
· 作业管理（作业调度、作业控制语言（JCL）、多道程序设计）
· 汉字处理，多媒体处理，人机界面
· 网络操作系统和嵌入式操作系统基础知识
· 操作系统的配置
重点：操作系统的五大管理功能，其中如处理机管理、存储管理、作业调度、进程调度、页面调度等尤为重要、状态转换、共享与互斥、分时轮转、抢占、死锁
难点：作业调度、进程调度、页面调度算法、PV操作
考试题型一般分布在：操作系统的概述、处理机管理、存储、文件管理、作业、进程调度、进程状态变化
考试出现频率较高的内容：PV操作、进程死锁/同步、内存分配、并发执行程序、进程间状态转换、PV实现进程间的同步与互斥、死锁及其避免、地址变换、页面置换、工作集
2.2.2 程序设计语言和语言处理程序的知识
· 汇编、编译、解释系统的基础知识和基本工作原理
· 程序设计语言的基本成分：数据、运算、控制和传输，过程（函数）调用
· 各类程序设计语言主要特点和适用情况
分析：文法考查、自动机、正则式
重点：编译程序的基本组成、正则表达式和有限自动机、文法及语言的形式描述、中间代码、自动机原理、文法和语言的定义
考试出现频率较高的内容：正则表达式和正则集、有限自动机和正则表达式的转换
2.3 计算机网络知识
· 网络体系结构（网络拓扑、OSI/RM、基本的网络协议）
· 传输介质、传输技术、传输方法、传输控制
· 常用网络设备和各类通信设备
· Client/Server结构、Browser/Server结构
· LAN拓扑，存取控制，LAN的组网，LAN间连接，LAN-WAN连接
· 因特网基础知识以及应用
· 网络软件
· 网络管理
· 网络性能分析
计算机网络中对OSI/RM七层的划分，及各种协议的功能。传输理论、互联设备、Internet知识，除参考模型理论外，其他的比较比较琐碎，需要知识积累。
重点：网络分类、拓扑结构、OSI参考模型层次划分及对应的协议、带宽计算、子网划分、防火墙技术
难点：IP子网划分；传输控制、各层协议的功能
考试题型一般分布在：这部分知识除了上面的难点部分外，基本属于了解记忆性的知识点，知识点比较散乱，但考试中考点均落在大纲中列出的知识点中。
考试出现频率较高的内容：TCP/IP协议、参考模型7层协议、IP地址的分类、各种网络设备的比较；
2.4 数据库知识
· 数据库管理系统的功能和特征
· 数据库模型（概念模式、外模式、内模式）
· 数据模型，ER图，第一范式、第二范式、第三范式
· 数据操作（集合运算和关系运算）
· 数据库语言（SQL）
· 数据库的控制功能（并发控制、恢复、安全性、完整性）
· 数据仓库和分布式数据库基础知识
无论对上午题目还是下午题目，本部分都很重要，这是学习和复习的一个重点。
重点：用E-R模型表示现实问题，扩充的E-R模型、ER图向关系模式的转换、数据库语言（SQL）、对SELECT查询语句的应用、关系代数表达式、关系模型的完整性约束、函数依赖
难点：五种基本的关系运算方法、组合的关系运算方法、规则化理论（）、函数依赖、分解的保持函数依赖、无损连接又保持函数依赖的分解、判断一个分解的无损连接性和保持函数
考试出现频率较高的内容：数据模型、关系运算与SQL语句的转换、函数依赖
2.5 多媒体知识
· 多媒体系统基础知识，多媒体设备的性能特性，常用多媒体文件格式
· 简单图形的绘制，图像文件的处理方法
· 音频和视频信息的应用
· 多媒体应用开发过程
基本属于了解记忆性的知识点。
重点：多媒体的基本概念、声音数字化的过程、图像压缩编码、视频文件的国际标准、流媒体概念、多媒体计算机系统、虚拟现实技术
难点：多媒体信息的容量计算、数据压缩、常用多媒体文件格式、音频和视频的物理特征等
考试出现频率较高的内容：基本知识、信息的容量计算
2.6 系统性能知识
· 性能指标（响应时间、吞吐量、周转时间）和性能设计
· 性能测试和性能评估
· 可靠性指标及计算、可靠性设计
· 可靠性测试和可靠性评估
重点：可靠性评估
考试出现频率较高的内容：系统可靠性的计算、设备周转时间
2.7 计算机应用基础知识
· 信息管理、数据处理、辅助设计、自动控制、科学计算、人工智能等基础知识
· 远程通信服务基础知识
· 常用应用系统
本部分内容不是考试重点，做一般了解即可。
3．系统开发和运行知识
本部分内容涉及上午考试和下午考试，是软件设计师工作能力的考查重点。
3.1 软件工程、软件过程改进和软件开发项目管理知识
· 软件工程知识
· 软件开发生命周期各阶段的目标和任务
· 软件开发项目管理基础知识（时间管理、成本管理、质量管理、人力资源管理、风险管理等）及其常用管理工具
· 主要的软件开发方法（生命周期法、原型法、面向对象法、CASE）
· 软件开发工具与环境知识
· 软件过程改进知识
· 软件质量管理知识
· 软件开发过程评估、软件能力成熟评估基础知识
重点：软件开发方法、CMM、成本估算、风险分析、进度管理、人员管理、软件开发环境
3.2 系统分析基础知识
· 系统分析的目的和任务
· 结构化分析方法（数据流图（DFD）、数据字典（DD）、实体关系图（ERD）、描述加工处理的结构化语言）
· 统一建模语言（UML）
· 系统规格说明书
高度重视UML在系统分析中的应用
重点：数据流图（DFD）、数据字典（DD）、实体关系图（ERD）
考点：UML的各类图
3.3 系统设计知识
· 系统设计的目的和任务
· 结构化设计方法和工具（系统流程图、HIPO图、控制流程图）
· 系统总体结构设计（总体布局、设计原则、模块结构设计、数据存储设计、系统配置方案）
· 系统详细设计（代码设计、数据库设计、用户界面设计、处理过程设计）
· 系统设计说明书
重点：系统流程图、HIPO图、控制流程图
3.4 系统实施知识
· 系统实施的主要任务
· 结构化程序设计、面向对象程序设计、可视化程序设计
· 程序设计风格
· 程序设计语言的选择
· 系统测试的目的、类型，系统测试方法（黑盒测试、白盒测试、灰盒测试）
· 测试设计和管理（错误曲线、错误排除、收敛、注入故障、测试用例设计、系统测试报告）
· 系统转换基础知识
3.5 系统运行和维护知识
· 系统运行管理基础知识
· 系统维护基础知识
· 系统评价基础知识
重点：结构化设计中信息流、变换分析、系统结构设计原则、系统划分、模块设计、数据存储设计、面向对象程序设计、测试方法、系统维护的分类
难点：系统测试方法、测试分类、系统可维护性评价指标
3.6 面向对象开发方法
· 面向对象开发概念（类、对象、属性、封装性、继承性、多态性、对象之间的引用）
· 面向对象开发方法的优越性以及有效领域
· 面向对象设计方法（体系结构、类的设计、用户接口设计）
· 面向对象实现方法（选择程序设计语言、类的实现、方法的实现、用户接口的实现、准备测试数据）
· 面向对象程序设计语言（如C++、Java、Visual、Bsasic、Visual C++）的基本机制
· 面向对象数据库、分布式对象的概念
重点：面向对象开发：类、对象、属性、封装性、继承性、多态性、OMT方法
难点：建议在数据流图、结构化分析方法上多加掌握。
考试题型一般分布在：DFD、软件的生存周期；数据流图；模块间的关系；软件测试的分类、软件质量管理（标准）软件的特性、主要的软件开发方法、系统测试、软件能力成熟评估
考试出现频率较高的内容：数据流图、黑盒/白盒测试、面向对象技术的概念
4．安全性知识
· 安全性基本概念
· 防治计算机病毒、防范计算机犯罪
· 存取控制、防闯入、安全管理措施
· 加密与解密机制
· 风险分析、风险类型、抗风险措施和内部控制
系统安全问题是目前社会关注的问题，也是应用价值较高的知识，可结合现实中的相关问题来加深理解。
考试出现频率较高的内容：加密与解密算法、
5．标准化知识
· 标准化意识、标准化的发展、标准制订过程
· 国际标准、国家标准、行业标准、企业标准基本知识
· 代码标准、文件格式标准、安全标准、软件开发规范和文档标准知识
· 标准化机构
6．信息化基础知识
· 信息化意识
· 全球信息化趋势、国家信息化战略、企业信息化战略和策略
· 有关的法律、法规
· 远程教育、电子商务、电子政务等基础知识
· 企业信息资源管理基础知识
信息化、标准化知识是新增考点。标准化方面有标准标识，标准修订等是对基本素质的考查，也要重视。
考试出现频率较高的内容
7．计算机专业英语
· 掌握计算机技术的基本词汇
· 能正确阅读和理解计算机领域的英文资料
专业英语，是对专业知识和英语水平的考查，考前需有意识阅读点英文专业资料。
考试题型一般分布在：软件行业标准，计算机安全基础知识，信息化基础知识。
考试出现频率较高的内容：行业标准的类别；计算机安全，CMM分类，计算机软件著作权问题。
考试科目2：软件设计
本部分具体内容如下：
l 外部设计
l 内部设计
l 程序设计
l 系统实施
l 软件工程
本部分所涉及内容为软件设计的日常工作，这些内容同样出现在上午考试试题中。
1．外部设计
1.1 理解系统需求说明
1.2 系统开发的准备
· 选择开发方法、准备开发环境、制订开发计划
1.3 设计系统功能
· 选择系统结构，设计各子系统的功能和接口，设计安全性策略、需求和实现方法，制订详细的工作流和数据流
1.4 设计数据模型
· 设计ER模型、数据模型
1.5 编写外部设计文档
· 系统配置图、各子系统关系图、系统流程图、系统功能说明书、输入输出规格说明、数据规格说明、用户手册框架
· 设计系统测试要求
1.6 设计评审
应能由考试说明内容，来阅读
2．内部设计
2.1 设计软件结构
· 按构件分解，确定构件功能规格以及构件之间的接口
· 采用中间件和工具
2.2 设计输入输出
· 屏幕界面设计、设计输入输出检查方法和检查信息
2.3 设计物理数据
· 分析数据特性，确定逻辑数据组织方式、存储介质，设计记录格式和处理方式
· 将逻辑数据结构换成物理数据结构，计算容量，进行优化
2.4 构件的创建和重用
· 创建、重用构件的概念
· 使用子程序库或类库
2.5 编写内部设计文档
· 构件划分图、构件间的接口、构件处理说明、屏幕设计文档、报表设计文档、文件设计文档、数据库设计文档
2.6 设计评审
3．程序设计
3.1 模块划分（原则、方法、标准）
3.2 编写程序设计文档
· 模块规格说明书（功能和接口说明、程序处理逻辑的描述、输入输出数据格式的描述）
· 测试要求说明书（测试类型和目标、测试用例、测试方法）
3.3 程序设计评审
4．系统实施
4.1 配置计算机系统及其环境
4.2 选择合适的程序设计语言
4.3 掌握C程序设计语言，以及C++、Java、Visual Basic、Visual C++中任一种程序设计语言，以便能指导程序员进行编程和测试，并进行必要的优化
4.4 系统测试
· 指导程序员进行模块测试，并进行验收
· 准备系统集成测试环境和测试工具
· 准备测试数据
· 写出测试报告
5．软件工程
· 软件生存期模型（瀑布模型、螺旋模型、喷泉模型）和软件成本模型
· 定义软件需求（系统化的目标、配置、功能、性能和约束）
· 描述软件需求的方法（功能层次模型、数据流模型、控制流模型、面向数据的模型、面向对象的模型等）
· 定义软件需求的方法（结构化分析方法、面向对象分析方法）
· 软件设计（分析与集成、逐步求精、抽象、信息隐蔽）
· 软件设计方法（结构化设计方法、Jackson方法、Warnier方法、面向对象设计方法）
· 程序设计（结构化程序设计、面向对象程序设计）
· 软件测试的原则与方法
· 软件质量（软件质量特性、软件质量控制）
· 软件过程评估基本方法、软件能力成熟度评估基本方法
· 软件开发环境和开发工具（分析工具、设计工具、编程工具、测试工具、维护工具、CASE）
· 软件工程发展趋势（面向构件，统一建模语言（UML））
· 软件过程改进模型和方法
本部分综合分析：
软件设计师，关键是设计软件的能力。考纲要求：要熟悉软件工程、软件过程改进和软件开发项目管理的基础知识；熟练掌握软件设计的方法和技术；掌握C程序设计语言及指定的四种面向对象语言中的一种。这部分专业能力严重依赖工作实践，要求有一定经验的积累，是具有工程师的实际工作能力和业务水平的体现。如无实践经验，要学会借鉴，以取人之长，补已之短。
这部分主要体现在下午考试中，现就如何应对下午考试进行分析：
近几次考试中下午试题分五个题目，一个数据库，一个程序填空题、一个面向对象的语言题，另两个题目分别为数据流图、UML、或流程图等。
数据库题目，要求补全SQL语言，这要求考生熟悉SQL的语言，无论对上午题目还是下午题目都很重要。这是学习和复习的一个重点。
数据流图，DFD是一种分析系统数据流程的图形，意在让用户理解系统的功能、输入、输出和数据存储等。请认真弄清其应用，在画出数据流图的情况下，系统的功能也就确定了，再经过细化，逐步向物理结构迈进。考核时，试题多从父图和子图的平衡来分析。这部分内容，一个解题的关键是高度重视题目说明，务必正确、深入理解其内容，必要时要读几遍，同时对于给出的图表，也要务必看懂。这样答题就轻松了，答案实际就蕴含在说明中。
流程图类题目，是大家再熟悉不过的了，它就一个具体问题的解题思路进行描述，是面向过程的。但所求问题是千差万别的，因此应理解思路，细心作答。
答题形式最简单也是难度最大的是程序填空。为便于阅卷，这类题目以程序填空形式出现，这不仅要求理解问题本质，同时也要弄清作者解题思路，这一点比自己独立完成程序设计要难得的多。针对问题，首先设计自己的思路，如何解决问题，先后顺序怎样；然后试读程序，如何思路大体一致，很好，这题容易解决了。如思路不一致，设法弄清每一段代码的功能，其逻辑结构怎样，进而弄清命题人的解题思路，再顺势解决问题。人们常讲，答案就在题目中，这是对的。在分析问题过程中，找到所求答案。不过前提条件是考生要熟悉这种语言，又要明白解题思路，这样才能正确作答。这个题目比较难，要么不得分，要么得全分。
近年对于统一建模语言UML考查较多，已引起了考生的注意。它代表了软件工程的发展趋势，目前是可视化建模的事实上的工业标准。人们对于图的理解相对其他形式更容易一些，图能更清晰地描述和说明问题的本质，因此，UML体现了这一特点。这类题目难度与数据流图相似，自然解题思想也相同。从形式上看，数据流图更朴实一些，UML类的题目则透出一种新颖、现代的气息。
最后的题目面向对象语言是一个选做题，给考生以自由，可以发挥个人的优势。命题已注意到不同语言的考查难度一致性，要求考生就同一问题回答，实现了形式上的公平，自然是一个进步

数据结构大作业 寻求帮助. 求高人

第五题
#include 《iostream》
using namespace std;
typedef struct ArcCell
{
int adj,weight;
char *info;
}ArcCell,AdjMatrix;
typedef struct
{
char vexs;
AdjMatrix arcs;
int vexnum,arcnum;
}DN;
int LocateVex(DN G,char v)
{
for(int i=0;i《G.vexnum;i++)
if(G.vexs==v)
return i;
return -1;
}
int FirstAdjVex(DN G,int v)
{
for(int i=0;i《G.vexnum;i++)
if(G.arcs.adj《100)
return i;
return -1;
}
int NextAdjVex(DN G,int v,int w)
{
for(int i=w+1;i《G.vexnum;i++)
if(G.arcs.adj《100)
return i;
return -1;
}
void CreatDN(DN &G)
{
int i,j,k,IncInfo;
cin》》G.vexnum》》G.arcnum》》IncInfo;
for(i=0;i《G.vexnum;i++)
cin》》G.vexs;
for(i=0;i《G.vexnum;i++)
for(j=0;j《G.vexnum;j++)
{
G.arcs={100,NULL};
G.arcs.info=NULL;
}
for(k=0;k《G.arcnum;k++)
{
int w;
char v1,v2;
cin》》v1》》v2》》w;
i=LocateVex(G,v1);
j=LocateVex(G,v2);
G.arcs.adj=w;
if(IncInfo)
gets(G.arcs.info);
}
}
void BFSTraverse(DN G)
{
bool Visited;
int q,f=0,r=0,v,u,w;
for(v=0;v《G.vexnum;v++)
Visited=false;
for(v=0;v《G.vexnum;v++)
{
if(!Visited)
{
Visited=true;
cout《《G.vexs《《’ ’;
q=v;
}
while(f!=r)
{
u=q;
for(w=FirstAdjVex(G,u);w》=0;w=NextAdjVex(G,u,w))
if(!Visited)
{
Visited=true;
cout《《G.vexs《《’ ’;
q=w;
}
}
}
}
void DFS(DN G,int v)
{
visited=true;
cout《《G.vexs《《’ ’;
for(int w=FirstAdjVex(G,v);w》=0;w=NextAdjVex(G,v,w))
if(!visited)
DFS(G,w);
}
void DFSTraverse(DN G)
{
int i;
for(i=0;i《G.vexnum;i++)
visited=false;
for(i=0;i《G.vexnum;i++)
if(!visited)
DFS(G,i);
}
int main(int argc, char* argv)
{
DN G;
CreatDN(G);
DFSTraverse(G);
cout《《endl;
BFSTraverse(G);
cout《《endl;
return 0;
}
希望你能满意

急求求大仙帮忙！C语言数据结构课程设计，关于旅游图

#include"stdio.h"
#include"malloc.h"
#include "string.h"
#define INFINITY 32767 /* 图的最大权值,32767是整数表示的最大值*/
#define MAX_VEX 30 /* 最大顶点数目 */
#define MAX_VALUE 999999999

typedef int InfoType;
typedef char VexType;
typedef enum{DG=1, AG=2,WDG=3,WAG=4}GraphKind;/*枚举常量定义旅游景点对应的图类型*/

typedef struct Path
{
intvertex;
intvalue;
intcount;
}GPath;

typedef struct MGraph
{
charvexs; /*存放图的邻接矩阵的的顶点,顶点向量 */
intarcs; /*存放图的邻接矩阵的边 */
intvexnum,arcnum; /*图的当前顶点数和弧数 */
}MGraph; /*图的邻接链表转换为矩阵后,图的结构定义 */
/*图的邻接矩阵存储结构中结点结构体的定义*/
typedef struct Linknode
{
charadjvex; /*邻接点在头结点数组中的位置（邻接边的弧头顶点序号）*/
InfoTypeinfo; /*与边或弧相关的信息, 如权值 */
structLinknode *nextarc; /*指向下一个表结点 */
}LinkNode; /*邻接边单链表的结点结构体 */
typedef struct VexNode
{
char data; /*数据域存储顶点信息 */
int indegree ; /*顶点的度, 有向图是入度或出度或没有 */
LinkNode *firstarc; /*链域指向第一个表结点（邻接边头指针）*/
}VexNode; /*顶点结点类型定义 */
typedef struct
{
GraphKind kind; /*图的种类标志 */
intvexnum; /*顶点个数 */
VexNodeAdjList; /*邻接表数组 */
}ALGraph; /*图的结构定义 */
typedef struct
{
VexType vex1, vex2; /*弧或边所依附的两个顶点 */
InfoTypeinfo; /*与边或弧相关的信息, 如权值 */
}ArcType; /*弧或边的结构定义 */
void Init_Graph(ALGraph * G) /*图的初始化 */
{
do
{
printf("请确认旅游景点的类型(1：无向图。2：有向图。3：带权有向图。4：带权无向图):\n") ;
scanf("%d",&G-》kind) ;
if(G-》kind==4)
printf("旅游区导游图的类型:带权无向图\n");
else
{
printf(" ●您选择的图的类型不对●\n");

}
}
while(G-》kind!=4);
G-》vexnum=0; /* 初始化顶点个数为0 */
}
int
LocateVex(ALGraph *G, VexType vp)
/*图的顶点定位（图的顶点定位实际上是确定一个顶点在AdjList数组中的某个元素的data域内容。）*/
{
int k;
for(k=0;k《G-》vexnum;k++)
if(G-》AdjList.data==vp)
return(k); /*如果存在此顶点返回顶点数组下标值 */
return(-1); /*如果没有则返回-1(图中无此顶点) */
}
int AddVertex(ALGraph *G, char vp) /*向图中增加顶点（向图中增加一个顶点的操作，在AdjList数组的末尾增加一个数据元素。）*/
{ int k;
if (G-》vexnum》=MAX_VEX)
{
printf("图中顶点数已达到最多!\n");
return(-1);
}
if(LocateVex(G,vp)!=-1)
{
printf("所要添加的顶点已存在!\n");
return(-1);
}
G-》AdjList.data=vp;
G-》AdjList.indegree=0 ;
G-》AdjList.firstarc=NULL;
k=++G-》vexnum;
return k;
}
int AddArc(ALGraph *G, ArcType *arc)/*向图中增加一条边(弧)（根据给定的弧或边所依附的顶点，修改单链表：无向图修改两个单链表；）*/
{
int k,j;
LinkNode*p,*q;
k=LocateVex(G,arc-》vex1);
j=LocateVex(G,arc-》vex2);
if(k==-1||j==-1) /*先判断是否两个顶点重复或者是否存在这两个顶点*/
{
printf("该两个景点为一点或两景点都不存在,错误 !\n");
return(-1);
}
p=(LinkNode*)malloc(sizeof(LinkNode));
p-》adjvex=arc-》vex1;
p-》info=arc-》info;
p-》nextarc=NULL; /* 边的起始表结点赋值 */
q=(LinkNode*)malloc(sizeof(LinkNode));
q-》adjvex=arc-》vex2;
q-》info=arc-》info;
q-》nextarc=NULL; /* 边的末尾表结点赋值 */
q-》nextarc=G-》AdjList.firstarc;
G-》AdjList.firstarc=q;
p-》nextarc=G-》AdjList.firstarc;
G-》AdjList.firstarc=p
; /*
是无向图, 用头插入法插入到两个单链表 */
return(1); /*无向图，把p和q互相连接到彼此的边点上 */
}
ALGraph *Create_ALGraph()/*采用邻接链表作为图的存储结构建立带权有向图*/
{
charstack1,vex,k1,k2;
intweight;
ALGraph*G;
ArcType*p;
printf("首先对旅游区导游图进行初始化:\n\n");
G=(ALGraph*)malloc(sizeof(ALGraph));//申请动态结点空间
Init_Graph(G);
printf("\n请输入旅游区导游图的各个旅游景点代码(以字符的形式出入),当输入0时作为结束标志\n");
while(1)
{
scanf("%s",stack1);/*以字符串的形式输入存储旅游区景点,一次一个的存储输入的景点存到数组中之后又在图中插入该顶点，当输入0时结束*/
vex=stack1; /*用字符串可以区别结束标识，用字符存到数组中不易设置结束标志*/
if(vex==’0’)
break;
else
AddVertex(G,vex);
}
p=(ArcType*)malloc(sizeof(ArcType));
printf("\n
从键盘输入以(Vi ,Vj
,d)的形式建立该旅游区的旅游景点图,\n 其中: Vi和Vj表示两个不同的旅游景点, d表示这两个景点之间的道路距离;\n
该旅游景点图采用邻接链表存储结构(当输入第一个顶点是0时表示结束):\n");
while(1)
{
scanf("%s",stack1);
k1=stack1;
if(k1==’0’) /* 输入第一个顶点,0结束 */
break;
else
{
scanf("%s",stack2);
scanf("%d",&weight)
; /*
输入第二个顶点和权值 */
k2=stack2;
p-》vex1=k1;
p-》vex2=k2;
p-》info=weight;
AddArc(G,p);
printf("\n请继续输入下一条道路!!\n") ;
}
}
return(G);
}void output_ALGraph(ALGraph *G) // 2:输出图的邻接链表
{
int j;
LinkNode*p;
printf("\n旅游区导游图的邻接链表景点输出表示如下:\n");
for(j=0;j《G-》vexnum;j++)
{
printf("%c",G-》AdjList.data);
p=G-》AdjList.firstarc;
while(p!=NULL) //输出一个邻接链表的景点之后，继续输出他的其他邻接景点
{
printf("-》 ");
printf("《%c,%d》",p-》adjvex,p-》info);
p=p-》nextarc;
}printf("\n\n");
}}
void
output_Find_ALGraph(ALGraph *G)
// 4:相邻景点查询并输出
{
int j;
LinkNode*p; //定义邻接边单链表结点p
printf("请输入您要查询的景点(顶点数组下标值):\n"); //从输入的景点开始找和其相邻的景点并输出权值
scanf("%d",&j);
p=G-》AdjList.firstarc; //定义邻接边头指针
while(p!=NULL)
{
printf("景点%c到景点%c的距离是%d (两景点之间有相连的道路)\n",G-》AdjList.data,p-》adjvex,p-》info);//第j个景点和他下一个相邻的景点和权值
p=p-》nextarc; //指向下一个结点的地址，使全部与G-》AdjList.data直接连通的顶点全部输出，NULL时截止
}
printf("\n\n");
}
void ListToMat(ALGraph G, MGraph&g) /*将邻接链表转换成邻接矩阵 */
{
intk,i,j;
LinkNode*p;
for
(i=0;i《G.vexnum;i++)
/*g.arcs赋初值INFINITY */
for(j=0;j《G.vexnum;j++)
g.arcs=INFINITY;
for(i=0;i《G.vexnum;i++)
{
g.vexs中*/
}
for(i=0;i《G.vexnum;i++)
{
p=G.AdjList.firstarc;
while(p!=NULL)
{
k=LocateVex(&G,p-》adjvex); /*取和p相邻的顶点下标值用于邻接矩阵的下标值 */
g.arcs=p-》info;/*把权值赋值给二维数组用于矩阵输出 */
p=p-》nextarc; /*指向下一个邻接表结点 */
}
}
g.vexnum=G.vexnum;
}
void display(ALGraph *G,MGraph g) /*3:输出邻接矩阵 */
{
inti,j;
ListToMat(*G,g); /*将邻接链表转换成邻接矩阵 */
printf(" ");
for(i=0;i《G-》vexnum;i++)
printf("%-8c",G-》AdjList.data);/*输出矩阵横向顶点值 */
printf("\n");
for(i=0;i《g.vexnum;i++)
{
printf("%c ",G-》AdjList.data ); /*输出矩阵竖向顶点值，每输出一行输出一次顶点*/
for(j=0;j《g.vexnum ;j++)
{
if(g.arcs==INFINITY)
printf("∞ ");
else
printf("%-8d",g.arcs); /*每个权值占有8个字符，负号表示左端对齐 */
}
printf("\n");
}
}
void dijkshort_One(ALGraph F, MGraph G,intv0,int distance)/* 带权图G从顶点v0到其他定点的最短距离distance和最短路径前驱结点的下标path*/
//带权图F从下标v0到其他顶点的最短距离diatance和最短路径下标path,path中存放了从输入的v0到其他各个顶点的最短路径的前一个顶点的下标
//基于狄克斯特拉函数的设计
{

int*S=(int *)malloc(sizeof(int)*G.vexnum);
intminDis,i,j,u,p;
ListToMat(F,G);
printf("你所要开始查询的景点是:%c\n",F.AdjList.data);
for(i=0;i《G.vexnum;i++)//初始化
{
distance;
S=0;
if(distance《INFINITY)
path=v0;
else
path=-1;
}
S=1; //标记顶点v0已从集合T加入到集合S中（以v0为下标值的顶点）
for(i=0;i《G.vexnum;i++)
{
minDis=INFINITY ;
for(j=0;j《G.vexnum;j++)
{
if(S《minDis)
{
minDis=distance;
u=j;
}
}
S=1; //标记顶点u已从集合T加入到集合S中（以u为下标值的顶点）
for(j=0;j《G.vexnum;j++) // /修改从v0到其他顶点的最短距离和最短路径
if(S)
{
distance;//顶点v0经顶点u到其他顶点的最短距离和最短路径
path=u;
}
} //顶点v0到其他所有的顶点的最短距离已经保存在数组distance中
printf("查询结果是:\n");
for(j=0;j《G.vexnum;j++) //输出结果
if(path!=-1)
{
printf("从景点%c到景点%c",F.AdjList);
p=path;

printf("的最短距离是: %d",distance);//输出顶点v0到其他所有的顶点的最短路径
printf("途中经过的景点有:");
while(p!=-1)
{
printf("%c",G.vexs);
p=path;
}
printf("\n");
}
elseif(j!=v0)
printf("\n%c到%c : 没有通路!",G.vexs);}