图的操作与实现——简易城市交通网

最新推荐文章于 2022-06-21 01:26:50 发布
最新推荐文章于 2022-06-21 01:26:50 发布
阅读量3.3k 收藏 51
点赞数 11
文章标签： 图论 算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Disaster_Star/article/details/121959401
版权

本次题目为数据结构课设：

(1）数据准备
按照图 1 所示城市交通网（图中边上的权值表示城市之间的距离），将数据保存在文本文件中，文件名为：“班名+序号_Graph.txt”.
用以下格式存储：
11 11
北京 天津 西安 郑州 徐州 上海 成都 武汉 株洲 南昌 广州
北京 天津 137
北京 郑州 695
天津 徐州 674
徐州 上海 651
徐州 郑州 349
郑州 西安 511
西安 成都 842
郑州 武汉 534
株洲 武汉 411
株洲 南昌 367
株洲 广州 409

（2）功能要求
用图的邻接矩阵的表示方法存储图 1 所示的城市交通信息网。在主函数中设计功能菜
单，利用菜单调用各个函数，分别完成以下各功能：
①设计在相应存储结构（邻接矩阵或邻接表）下的图的类型声明。
②根据图 1 所示交通网，创建无向带权图。读取交通信息：从指定位置文件中读取顶
点和边的信息，保存到邻接矩阵中，并输出无向带权图。
③交通信息维护。A、城市信息维护：可以添加、删除、修改城市信息；B、连通信息
维护：可以添加、删除、修改城市之间的连通信息。（注：为了操作简便，在添加和删除城市信息时，只要求在存储城市信息的一维数组的末尾进行）
④图的遍历。输入某个起点，进行深度优先遍历和广度优先遍历，输出其遍历序列。
⑤求最小生成树。使用 Prim 算法或 Kurskal 算法构造一棵最小生成树，保证所有城市
连通且路程最短。
⑥使用 Floyd 算法求任意两个城市之间的最短路径。（选做）
⑦使用 Dijkstra 算法求源点（第一个城市）到其他各城市之间的最短路径。（选做）

以下为我自己写的程序，仅展示算法部分供借鉴：

#include <stdio.h>
#include <string.h>
#include <string>
#include <iostream>
using namespace std;
#define MAX 100//最大顶点数
#define INFINITY 32767        //表示∞
#define TRUE 1
#define FALSE 0
typedef int Bool;
Bool visited[MAX];
typedef struct
{//邻接矩阵结构
    int n,e;//顶点数n,边数e
    char vexs[MAX][MAX];//顶点数组
    int edges[MAX][MAX];//边的邻接矩阵
}MGraph;
void CreateMGraph(MGraph *G){//创建图
    FILE *fp=fopen("E:\\code\\sjjg\\计科Z62103班04_Graph.txt","r");
    if(fp==NULL){
        printf("读取文件失败！");
        fclose (fp);
    }
    char ch1[MAX],ch2[MAX];
    fscanf(fp,"%d",&G->n);
    fscanf(fp,"%d",&G->e);
    for(int i=0;i<G->n;i++){
        fscanf(fp,"%s",G->vexs[i]);
    }
    for(int i=0;i<G->n;i++){//邻接矩阵元素置∞
        for(int j=0;j<G->n;j++){
            G->edges[i][j]=INFINITY;
        }
    }
    for(int i=0;i<G->e;i++){
        fscanf(fp,"%s",ch1);
        fscanf(fp,"%s",ch2);
        for(int j=0;j<G->n;j++){
            for(int k=0;k<G->n;k++){
                if(strcmp(ch1,G->vexs[j])==0&&strcmp(ch2,G->vexs[k])==0){
                    fscanf(fp,"%d",&(G->edges[j][k]));
                    G->edges[k][j]=G->edges[j][k];
                }
            }
        }
    }
    fclose (fp);
}
void DispMGraph(MGraph *G){//图的邻接矩阵输出函数
    for(int i=0;i<G->n;i++){
        for(int j=0;j<G->n;j++)
            printf("%5d",G->edges[i][j]);
        printf("\n");
    }
}
void AddCity(MGraph *G){//添加城市信息
    printf("请输入想要加入的城市:");
    scanf("%s",G->vexs[G->n]);
    G->n++;
    for(int i=0;i<G->n;i++){//邻接矩阵元素置0
        for(int j=0;j<G->n;j++){
            if(i==G->n-1||j==G->n-1){
                G->edges[i][j]=INFINITY;
            }
        }
    }
    for(int i=0;i<G->n;i++){
        printf("%s ",G->vexs[i]);
    }
}
void AlterCity(MGraph *G){//修改城市信息
    printf("请输入想要修改的城市信息:");
    char ch1[MAX];
    scanf("%s",ch1);
    for(int i=0;i<G->n;i++){
        if(strcmp(ch1,G->vexs[i])==0){
            printf("请输入修改后的城市信息:");
            scanf("%s",ch1);
            memcpy(G->vexs[i],ch1,MAX);
        }
    }
    for(int i=0;i<G->n;i++){
        printf("%s ",G->vexs[i]);
    }
}
void DeleteCity(MGraph *G){//删除城市信息
    printf("请输入想要删除的城市信息:");
    char ch1[MAX];
    scanf("%s",ch1);
    for(int i=0;i<G->n;i++){
        if(strcmp(ch1,G->vexs[i])==0){
            for(int j=i;j<G->n;j++){
                memcpy(G->vexs[j],G->vexs[j+1],MAX);
            }
            G->n--;
        }
    }
    for(int i=0;i<G->n;i++){
        printf("%s ",G->vexs[i]);
    }
}
void AddTraffic(MGraph *G){//添加交通信息
    printf("请输入想要加入的交通信息（两个城市名）:");
    char ch1[MAX],ch2[MAX];
    scanf("%s",ch1);
    scanf("%s",ch2);
    for(int j=0;j<G->n;j++){
        for(int k=0;k<G->n;k++){
            if(strcmp(ch1,G->vexs[j])==0&&strcmp(ch2,G->vexs[k])==0){
                if(G->edges[j][k]==INFINITY&&G->edges[k][j]==INFINITY){
                    printf("请输入两个城市之间的距离：");
                    scanf("%d",&(G->edges[j][k]));
                    G->edges[k][j]=G->edges[j][k];
                    G->e++;
                }
                else
                printf("两个城市之间存在交通信息!\n");
            }
        }
    }
    for(int i=0;i<G->n;i++){
        for(int j=0;j<G->n;j++)
            printf("%5d",G->edges[i][j]);
        printf("\n");
    }
}
void AlterTraffic(MGraph *G){//修改交通信息
    printf("请输入想要修改的交通信息（两个城市名）:");
    char ch1[MAX],ch2[MAX];
    scanf("%s",ch1);
    scanf("%s",ch2);
    for(int j=0;j<G->n;j++){
        for(int k=0;k<G->n;k++){
            if(strcmp(ch1,G->vexs[j])==0&&strcmp(ch2,G->vexs[k])==0){
                if(G->edges[j][k]!=0&&G->edges[k][j]!=0){
                    printf("请输入两个城市之间的距离：");
                    scanf("%d",&(G->edges[j][k]));
                    G->edges[k][j]=G->edges[j][k];
                }
                else
                    printf("两个城市之间不存在交通信息!");
            }
        }
    }
    for(int i=0;i<G->n;i++){
        for(int j=0;j<G->n;j++)
            printf("%5d",G->edges[i][j]);
        printf("\n");
    }
}
void DeleteTraffic(MGraph *G){//删除交通信息
    printf("请输入想要删除的交通信息（两个城市名）:");
    char ch1[MAX],ch2[MAX];
    scanf("%s",ch1);
    scanf("%s",ch2);
    for(int j=0;j<G->n;j++){
        for(int k=0;k<G->n;k++){
            if(strcmp(ch1,G->vexs[j])==0&&strcmp(ch2,G->vexs[k])==0){
                if(G->edges[j][k]!=0&&G->edges[k][j]!=0){    
                    G->edges[j][k]=INFINITY;
                    G->edges[k][j]=G->edges[j][k];
                }
                else
                    printf("两个城市之间不存在交通信息!");
            }
        }
    }
    for(int i=0;i<G->n;i++){
        for(int j=0;j<G->n;j++)
            printf("%5d",G->edges[i][j]);
        printf("\n");
    }
}
//图的深度优先遍历
void DFS(MGraph *G, int i){
    int j;
    visited[i]=TRUE;
    printf("%s",G->vexs[i]);
    for(j=0;j<G->n;++j){
        if (G->edges[i][j]!=INFINITY && !visited[j])
            DFS(G, j);
    }
}
void DFSTraverse(MGraph *G){
    char ch1[MAX];
    for(int i=0;i<G->n;++i)
        visited[i]=FALSE;
    printf("请输入起始城市名：");
    scanf("%s",ch1);
    for(int i=0;i<G->n;++i){
        if(strcmp(ch1,G->vexs[i])==0){
            DFS(G,i);
            for(int i=0;i<G->n;++i)
                if (!visited[i])
                    DFS(G,i);
        }
    }
}
//广度优先遍历需要的循环队列
typedef struct {
    int    data[MAX];
    int    front, rear;
}Queue;
void InitQueue(Queue *Q){//初始化
    Q->front = Q->rear = 0;
}
void EnQueue(Queue *Q, int e){//入队
    if ((Q->rear+1)%MAX == Q->front)
        return ;
    Q->data[Q->rear] = e;
    Q->rear = (Q->rear+1)%MAX;
}
Bool QueueEmpty(Queue *Q){//判空
    if (Q->front == Q->rear)
        return TRUE;
    else
        return FALSE;
}
void DeQueue(Queue *Q, int *e){//出队
    if (Q->front == Q->rear)
        return ;
    *e = Q->data[Q->front];
    Q->front = (Q->front+1)%MAX;
}
//图的广度优先遍历
void BFSTraverse(MGraph *G){
    char ch1[MAX];
    Queue Q;
    for(int i=0;i<G->n;++i)
        visited[i] = FALSE;
    InitQueue(&Q);
    printf("请输入起始城市名：");
    scanf("%s",ch1);
    for(int i=0;i<G->n;++i){
        if(strcmp(ch1,G->vexs[i])==0){
            visited[i]=TRUE;
            printf("%s",G->vexs[i]);
            EnQueue(&Q,i);
            for(int j=0;j<G->n;++j)
            if(!visited[j]){
                visited[j]=TRUE;
                printf("%s",G->vexs[j]);
                EnQueue(&Q,j);
                while(!QueueEmpty(&Q)){
                    DeQueue(&Q,&j);
                    for (int k=0;k<G->n;++k){
                        if (!visited[k]&&G->edges[j][k]!=INFINITY){
                            visited[k]=TRUE;
                            printf("%s",G->vexs[k]);
                            EnQueue(&Q,k);
                        }
                    }
                }
            }
        }
    }
}
int LocateVex(MGraph *G,char C[MAX])
{//寻找顶点的位置下标
    int i;
    for(i=0;i<G->n;i++)
    {
        if(strcmp(G->vexs[i],C)==0 )
            return i;        
    }
    return -1; //没有找到该顶点返回-1
}
void MiniTree_Prim(MGraph *G){//最小生成树Prim算法
    int i,j,k,t,min,parent[MAX]={0},lowcost[MAX];
    for(i=1;i<G->n;i++){//初始化
        lowcost[i]=G->edges[0][i];
    }
    for(i=1;i<G->n;i++){
        int min=INFINITY;
        for(j=1;j<G->n;j++){//找最小的边
            if(lowcost[j]<min&&lowcost[j]!=0){
                min=lowcost[j];
                t=j;
            }
        }
        printf("(%s---->%s) 权值为：%d\n",G->vexs[parent[t]],G->vexs[t],min);
        lowcost[t]=0;
        for(k=1;k<G->n;k++){//更新顶点下标和边
            if(lowcost[k]!=0&&G->edges[t][k]<lowcost[k]){
                lowcost[k]=G->edges[t][k];
                parent[k]=t;
            }    
        }
    }
}
void Floyd(MGraph *G){//Floyd算法求两个城市间的最短路径
    printf("请输入两个城市名(第一个为起始城市，第二个为结束城市):");
    char ch1[MAX],ch2[MAX];
    scanf("%s",ch1);
    scanf("%s",ch2);
    int dist[MAX][MAX],path[MAX][MAX];
    for(int i=0;i<G->n;i++){
        for(int j=0;j<G->n;j++){
            dist[i][j]=G->edges[i][j];
            path[i][j] = j;
        }
    }
    for(int k=0;k<G->e;k++){
        for(int i=0;i<G->e;i++){
            for(int j=0;j<G->e;j++){
                if(dist[i][k]!=INFINITY&&dist[k][j]!=INFINITY&&dist[i][k]+dist[k][j]<dist[i][j]){
                    dist[i][j]=dist[i][k]+dist[k][j];
                    path[i][j] = path[i][k];
                }
            }
        }
    }
    printf("Floyd算法求解如下:\n");
    for(int i=0;i<G->n;i++){
        for(int j=0;j<G->n;j++){
            if(strcmp(ch1,G->vexs[i])==0&&strcmp(ch2,G->vexs[j])==0){
                printf("%s->%s:最短距离为%-4d:",G->vexs[i],G->vexs[j],dist[i][j]);
                int t=path[i][j];
                printf("路径为:%s",G->vexs[i]);
                while(t!=j){
                    printf("->%s",G->vexs[t]);
                    t=path[t][j];
                }
                printf("->%s\n",G->vexs[j]);
            }
        }
    }
}
void Dijkstra(MGraph *G,int v){//Dijkstra算法求第一个城市至各个城市的最短路径
    int dist[MAX],path[MAX],s[MAX];//dist数组用于求出最短路径，s数组用于记录已经确定的最短路径,path数组用于存储路径数组
    int min,i,j,u,pre;
    for(i=0;i<G->n;i++){
        dist[i]=G->edges[v][i];
        s[i]=0;
        if(G->edges[v][i]<INFINITY)
            path[i]=v;
        else
            path[i]=-1;
    }
    s[v]=1;path[v]=0;
    for(i=0;i<G->n;i++){
        min=INFINITY;
        u=-1;
        for(j=0;j<G->n;j++){
            if(s[j]==0&&dist[j]<min){
                u=j;
                min=dist[j];
            }
        }
        if(u!=-1){
            s[u]=1;
            for(j=0;j<G->n;j++){
                if(s[j]==0)
                    if(G->edges[u][j]<INFINITY&&dist[u]+G->edges[u][j]<dist[j]){
                        dist[j]=dist[u]+G->edges[u][j];
                        path[j]=u;
                    }
            }
        }
    }
    printf("Dijkstra算法求解如下:");
    for(i=0;i<G->n;i++){
        if(i!=v){
            printf("\n%s->%s:",G->vexs[v],G->vexs[i]);
            if(s[i]==1){
                printf("路径距离为%-4d:",dist[i]);
                pre=i;
                printf("路径逆序为:");
                while(pre!=v){
                    printf("%s->",G->vexs[pre]);
                    pre=path[pre];
                }
                printf("%s",G->vexs[pre]);
            }
            else
                printf("不存在路径\n");
        }
    }
}


相信能看懂算法的不需要菜单部分，如果实在写不出就私信我吧！

 

Disaster_Star
关注
支付域——支付基本原理
庄小焱
02-04 1690
交易( Transaction）指引起债权债务关系的各类经济活动，包括商品市场、服务市场、劳务巿场和金融市场的各类交易。交易是支付的前提和基础。在前面的案例中,交易是第一步，即老王要换老李的鸡，老李要换老王的羊。没有这个前提，就不会有后续的清分和结算。 我们的生活中有很多交易的例子、比如线上购物、线下打车、转账汇款、聚餐AA制付款等。由于交易十分重要，为了让商家支持自家的交易方式，很多支付服务商或机构会为其提供补贴或建设应用。比如在线下，有支付服务商或机构为了拓展商户，不仅补贴商家手续费，还奖励商家安装费
基于云计算打造智慧交通网络
weixin_47248296的博客
03-19 555
随着社会经济和科学技术的快速发展，城市化水平的不断提升，智能交通正在成为全球各国研究的重点。人类科技发展的最终目的之一就是要解决空间距离问题，因此不断在已有的交通运输方式上进行提升。基于云计算技术逐渐打造出包含公路、铁路、地下交通等在内的智慧交通网络。 智慧公路 云计算、人工智能、大数据等新一代信息技术与交通行业深度融合，构建高速视频云、交通大数据中心体系，全面赋能高速公路监控、通信、收费业务系统重构、数字化、智慧化转型，有孚网络将提供以核心云、路段边缘云节点两级架构的高速交通云平台解决方案..
[单源最短路+路径还原]城市交通路网 HUSTOJ2813
博客
04-07 918
题目描述下图表示城市之间的交通路网，线段上的数字表示费用，单向通行由A-&gt;E。试用动态规划的最优化原理求出A-&gt;E的最省费用。如图：求v1到v10的最短路径长度及最短路径。输入第一行为城市的数量N;后面是N*N的表示两个城市间费用组成的矩阵。输出A-&gt;E的最省费用。样例输入10 0 2 5 1 0 0 0 0 0 0 0 0 0 0 12 14 0 0...
1261：【例9.5】城市交通路网 2021-01-15
lybc2019的博客
01-15 468
1261：【例9.5】城市交通路网 时间限制: 1000 ms 内存限制: 65536 KB 【题目描述】 下图表示城市之间的交通路网，线段上的数字表示费用，单向通行由A->E。试用动态规划的最优化原理求出A->E的最省费用。 如图：求v1到v10的最短路径长度及最短路径。 【输入】 第一行为城市的数量N; 后面是N*N的表示两个城市间费用组成的矩阵。 【输出】 A->E的最省费用。 【输入样例】 10 0 2 5 1 0 0 0 0 0 0 0 0...
城市交通路网 - 动规求最短路+记录路径
m0_37579232的博客
03-17 610
1261：【例9.5】城市交通路网 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 1647 通过数: 1214 【题目描述】 下图表示城市之间的交通路网，线段上的数字表示费用，单向通行由A-&gt;E。试用动态规划的最优化原理求出A-&gt;E的最省费用。 如图：求v1到v10的最短路径长度及最短路径。 【输入】 第一行为城市的数量N...
交通查询系统(C语言) 数据结构图的应用(2学时)
许诺的博客
11-24 3248
注: 此为初代版本, 代码中有注释, 代码挂在GitHub上 点此访问 Update: ver1.0 创建于2019/11/24 2019/11/24晚在GitHub继续推送3.9的代码并优化其它代码 1. 实验目的 通过本实验掌握图的存储结构与基本运算以及Dijksta算法和 Floyed算法在实际问题中的应用。 2. 实验内容 设计一个交通查询系统，能够查询： 1. 从一个城市到其它各...
信息学奥赛一本通（1261：【例9.5】城市交通路网）
07-21 1708
1261：【例9.5】城市交通路网 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 6359 通过数: 4564 【题目描述】 下图表示城市之间的交通路网，线段上的数字表示费用，单向通行由A->E。试用动态规划的最优化原理求出A->E的最省费用。 如图：求v1到v10的最短路径长度及最短路径。 【输入】 第一行为城市的数量N; 后面是N*N的表示两个城市间费用组成的矩阵。 【输出】 A->E的最省费用。 【输...
c/数据结构课设——城市公交
02-21
在这个“C/数据结构课设——城市公交”项目中，我们可以看到一个实际应用了数据结构和C语言的实例，特别关注的是解决最短路径问题。这个课题可能涉及到Dijkstra算法或Floyd-Warshall算法等经典算法。 1. 数据结构：...
基于低压电力线载波通信技术的视频监控通信模块设计探讨——以泸州市城市建设为例.pdf
09-04
这种技术在城市安防、交通监控、公共设施管理等方面有着广泛的应用前景。 【总结】：电力线载波通信技术在视频监控领域的应用，不仅提高了数据传输的速度和稳定性，还降低了系统建设和维护成本，对于泸州市这样的...
简易操作系统OS方案规划
weixin_53295593的博客
08-10 2862
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 不会一次而成，需反复多次修改，前面发布的有错难免、会经常修改，后面发布的为准。为与虚拟内存页的概念一致，修改为：1c（簇cluster）= 8kp页（page） = 64ks（扇区sector），1p页（page）= 8s（扇区sector）=4kb。 多核处理器则是指在单个芯片上包含任意多个（如2、4、8、..
zyq2652192993zyq#Advance-Algorithm#一本通-1261：【例9.5】城市交通路网（基础动态规划）
07-25
【输入样例】0 0 0 0 12 14 0 0 0 00 0 0 0 13 12 11 0 0 0【输出样例】//逆推查找最短路径用数组d[i]代表第i个城市到
全国交通咨询系统（数据结构课设 图的应用 java实现 内含课设报告）
02-10
全国交通咨询系统（数据结构课设 图的应用 java实现 内含课设报告）全国交通咨询系统（数据结构课设 图的应用 java实现 内含课设报告）全国交通咨询系统（数据结构课设 图的应用 java实现 内含课设报告）全国交通咨询系统（数据结构课设 图的应用 java实现 内含课设报告）全国交通咨询系统（数据结构课设 图的应用 java实现 内含课设报告）全国交通咨询系统（数据结构课设 图的应用 java实现 内含课设报告）全国交通咨询系统（数据结构课设 图的应用 java实现 内含课设报告）
数据结构课设—公交线路图.zip
04-01
参考《数据结构实践教程》P56，所有功能如教程所示，并附加文件存储功能，即站点消息、公交线路信息等数据不得写入程序中，要求保存在文件中。 具体说明如下： 1、用文件一，例如文本文件，文件名stations.txt，保存站点信息，格式可以自行设计，例如：编号 站名 1 黄家湖西路武科大 2 黄家湖西路岐黄南路 3 黄家湖西路中医药大学 …… 20 和平大道三角路 …… 2、用文件二，例如文本文件，文件名buses.txt，保存公交信息，格式可以自行设计，例如：编号 线路名 起点站编号 终点站编号 1 539上行 1 20 2 539下行 20 1 …… 3、用文件三，例如文本文件，文件名routes.txt，保存线路信息，格式可以自行设计，例如：线路编号 站点编号 站点编号 距离 1 1 2 650 1 2 3 400 …… 意思是： 539上行 （从）黄家湖西路武科大 （到）黄家湖西路岐黄南路 650米 539上行 （从）黄家湖西路岐黄南路 （到）黄家湖西路中医药大学 400米 …… 4、设计公交线路所需的存储结构，将文件中的数据读入内存。 5、提供用户操作的菜单和界面实现添加、删除、修改公交、站点、线路信息，注意数据间的关联性。 6、将修改后的信息保存回文件。 7、其他查询操作参见教程。
道路交通信息系统-数据结构-图实现
03-19
我的数据结构课程设计作业，用access保存铁路交通和飞机航班的详细的信息，涉及多点最短路径查询及其代价值。用图保存各个城市节点信息，因此还有图的各种相关操作。
交通咨询系统的设计(数据结构 C语言)
m0_67401761的博客
06-21 3540
1）熟悉并掌握图的存储结构；2）熟悉并掌握单个最短路径算法；3）熟悉并掌握任意两个顶点之间的最短路径算法。设计一个交通咨询系统，能让乘客咨询从一个城市顶点到另一个城市顶点之间的最短路径或者最低费用或最少时间等问题。对于不同咨询需求，可以输入城市间的路程或所需要时间或费用。设计分三个部分，一是建立交通网络图的存储结构；二是解决单源最短路径问题；最后再实现两个城市顶点之间的最短路径问题。要求：1）构建城市信息有向图，可以以城市名为节点名，城市之间采用交通工具的时间或费用为边的权值进行构建；2）可以在已构建的城市
数据结构—图及其应用（交通问题，实现最短路径、最短时间、最少费用查询）
qq_42852559的博客
05-25 9963
数据结构—图及其应用（交通问题，实现最短路径、最短时间、最少费用查询） 1、任务描述 （1）、任务： 设计一个城市交通咨询模拟系统，利用该系统实现至少两种最优决策：最短路程到达、最省时到达等线路规划。 （2）、内容： 用户驾车出行由于出行目的的不同对道路路线选择的要求也有不同。例如，有的希望在途中的路程尽可能短，有的则可能希望路程中时间最短。为了能满足广大旅客的需求，编制一个城市交通咨询模拟系统，选取城市部分位置、道路抽象为程序所需要图的顶点和边，并以城市道路长度（路程），道路的某时段的速度等信息作为
图的邻接矩阵存储 编程实现
玲玲的专栏
10-07 4669
首先看图的邻接矩阵表示 用到的数据结构 #define MaxVertexNum 100 typedef char VertexType ; //由用户定义顶点类型 typedef int EdgeType; //由用户定义边上的权值类型 typedef
数据结构课设——公交线路图
热门推荐
qq_43478319的博客
11-08 1万+
公交线路图 源程序： #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX 100 int STATION_NUM;//站点总数 char *STATION[MAX];//存储站点名称 int ROUTE_NUM;//路段总数 int ROUTES[MAX][4];//存储路段信息 int BUS_NUM;//公交线路总数 char *BUS_NAME[MAX];//存储公交线路名称
pdf城市交通网络平衡分析——理论与实践
最新发布
07-20
《PDF城市交通网络平衡分析——理论与实践》是一本介绍城市交通网络平衡分析的书籍。本书主要涵盖了理论与实践方面的内容，旨在帮助读者理解城市交通网络的运行原理以及如何利用平衡分析方法进行分析。 首先，本书...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Disaster_Star

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值