【数据结构】图的操作（深度优先，广度优先，Dijkstra算法）

最新推荐文章于 2023-05-28 18:25:49 发布
最新推荐文章于 2023-05-28 18:25:49 发布
阅读量1.1k 收藏 8
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 图 深度优先遍历 广度优先遍历 Dijkstra算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45972928/article/details/124334991
版权

内容：
1）采用邻接矩阵/邻接表建立图；
2）采用深度优先/广度优先搜索方式遍历图
3）编程实现Dijkstra最短路径算法

实现思路：
① 定义邻接矩阵和邻接表的数据类型
② 定义visited数组存储该点是否访问
③ 编写创建图的函数
④ 编写深度优先遍历，使用递归的方法（栈）
⑤ 编写广度优先遍历，使用队列的方法
⑥ 编写Dijkstra算法，使用D[]存储起始点到某点的距离，S[]存储点是否访问过，Path[]存储某点的前一点

程序代码：
1、定义队列头文件：sqqueue.h

#ifndef SQQUEUE
#define SQQUEUE

#define MAXQAIZE 100 //队列可能达到的最大长度
typedef char QElemType;

class SqQueue
{
public:
    QElemType *base; //存储空间的基地址
    int front;  //头指针
    int rear;   //尾指针
    void InitQueue(); //初始化
    void EnQueue(QElemType e);  //入队
    void DeQueue(QElemType &e);  //出队
    bool QueueEmpty(); //判空
};
#endif // SQQUEUE

2、头文件实现

#include "SqQueue.h"

#define MAXQAIZE 100 //队列可能达到的最大长度
typedef char QElemType;

void SqQueue::InitQueue() //初始化
{
    base=new QElemType[MAXQAIZE]; //为队列分配一个最大容量为MAXQSIZE的数组空间
    front=rear=0;  //头指针尾指针置为零，队列为空
}

void SqQueue::EnQueue(QElemType e)  //入队
{
    base[rear]=e;  //新元素插入队尾
    rear=(rear+1)%MAXQAIZE;  //尾指针后移一位
}

void SqQueue::DeQueue(QElemType &e)  //出队
{
    e=base[front];  //保存队头元素
    front=(front+1)%MAXQAIZE;  //队头指针后移一位
}

bool SqQueue::QueueEmpty()
{
    if(rear==front)
        return true;
    return false;
}

3、主要部分实现：main.cpp

#include <iostream>
#include <windows.h>
#include <algorithm>
#include "SqQueue.h"

using namespace std;

//图的邻接矩阵存储表示
#define MaxInt 32767 //表示极大值，即∞
#define MVNum 100 //最大顶点数
typedef char VerTextType; //顶点数据类型
typedef int ArcType; //边的权值的数据类型
typedef struct
{
    VerTextType vexs[MVNum]; //顶点表
    ArcType arcs[MVNum][MVNum]; //邻接矩阵表
    int vexnum,arcnum; //图的当前点数和边数
    bool visited[MVNum]; //访问标志数组，其处置为false
}AMGraph;

typedef struct ArcNode
{
    int adjvex;
    struct ArcNode *nextarc;
    ArcType info;
}ArcNode;
typedef   struct  VNode//顶点结构
{
     VerTextType   data; //顶点信息
     ArcNode   * firstarc; //指向依附该顶点的第一条弧的指针
}VNode, AdjList[MVNum];
typedef   struct //图结构
{
      AdjList vertics ; //邻接表
      int  vexnum, arcnum; //顶点数和弧数
      bool visited[MVNum];
}ALGraph;

int LocateVex_AM(AMGraph G,char v) //邻接矩阵方法定位顶点
{
    for(int i=0;i<G.vexnum;i++)
        if(v==G.vexs[i])
            return i;
    return -1;
}
int LocateVex_AL(ALGraph G,char c) //邻接表方法定位顶点
{
    for(int i=0;i<G.vexnum;i++)
    {
        if(c==G.vertics[i].data)
            return i;
    }
    return -1;
}

void CreateUDN_AM(AMGraph &G) //采用邻接矩阵创建无向网
{
    cout<<"请输入无向图的顶点数和边数："<<endl;
    cin>>G.vexnum>>G.arcnum; //输入顶点数和边数

    cout<<"请输入这"<<G.vexnum<<"个顶点："<<endl;
    for(int i=0;i<G.vexnum;i++) //初始化顶点
    {
        cin>>G.vexs[i];
        G.visited[i]=false;
    }


    for(int i=0;i<G.vexnum;i++) //初始化邻接矩阵，边的权值均设为最大值MaxInt
        for(int j=0;j<G.vexnum;j++)
            G.arcs[i][j]=MaxInt;

    cout<<"请依次输入这"<<G.arcnum<<"条边已依附的顶点及权值："<<endl;
    for(int k=0;k<G.arcnum;k++) //构造邻接矩阵
    {
        char v1,v2;
        int w;
        cin>>v1>>v2>>w;
        int i=LocateVex_AM(G,v1);
        int j=LocateVex_AM(G,v2);
        G.arcs[i][j]=w;
        G.arcs[j][i]=G.arcs[i][j];
    }
}
void CreateUDN_AL(ALGraph &G) //采用邻接表创建无向网
{
    cout<<"请输入无向图的顶点数和边数："<<endl;
    cin>>G.vexnum>>G.arcnum;      //输入总顶点数，总边数
    cout<<"请输入这"<<G.vexnum<<"个顶点："<<endl;
    for(int i = 0; i<G.vexnum; ++i)
    {	//输入各点，构造头结点表
       cin>> G.vertics[i].data; 	//输入顶点值
       G.vertics[i].firstarc=NULL; //初始化表头结点的指针域为NULL
    }
    cout<<"请依次输入这"<<G.arcnum<<"条边已依附的顶点及权值："<<endl;
    for(int k = 0; k<G.arcnum;++k)
    {
        char v1,v2;//输入各边，构造邻接表
        int w;
        cin>>v1>>v2>>w;                 			//输入一条边依附的两个顶点
        int i = LocateVex_AL(G, v1);
        int j = LocateVex_AL(G, v2);
        ArcNode *p1=new ArcNode; //生成一个新的边结点*p1
        p1->adjvex=j;
        p1->info=w;
        p1->nextarc= G.vertics[i].firstarc;
        G.vertics[i].firstarc=p1;
       //将新结点*p1插入顶点vi的边表头部
        ArcNode *p2=new ArcNode; //生成另一个对称的新的边结点*p2
        p2->adjvex=i;//邻接点序号为i
        p2->info=w;
        p2->nextarc= G.vertics[j].firstarc;
        G.vertics[j].firstarc=p2;
        //将新结点*p2插入顶点vj的边表头部
    }//for
}


void DFS_AM(AMGraph &G,int v_index) //深度优先遍历邻接矩阵
{
    cout<<G.vexs[v_index]<<" ";
    G.visited[v_index]=true;
    for(int i=0;i<G.vexnum;i++)
    {
        if((G.arcs[v_index][i]!=MaxInt) && G.visited[i]==false)
            DFS_AM(G,i);
    }
}
void DFS_AL(ALGraph &G,int v_index) //深度优先遍历邻接表
{
    cout<<G.vertics[v_index].data<<" ";
    G.visited[v_index]=true;
    ArcNode *p=G.vertics[v_index].firstarc;
    while(p!=NULL)
    {
        int w=p->adjvex;
        if(!G.visited[w])
            DFS_AL(G,w);
        p=p->nextarc;
    }
}

void BFS_AM(AMGraph G,int v_index)
{
    cout<<G.vexs[v_index]<<" ";
    G.visited[v_index]=true;
    SqQueue Q;
    Q.InitQueue();
    Q.EnQueue(G.vexs[v_index]);
    while(!Q.QueueEmpty())
    {
        char u;
        Q.DeQueue(u);
        int index=LocateVex_AM(G,u);
        for(int i=0;i<G.vexnum;i++)
        {
            if(!G.visited[i]&&G.arcs[index][i]!=MaxInt)
            {
                cout<<G.vexs[i]<<" ";
                G.visited[i]=true;
                Q.EnQueue(G.vexs[i]);
            }
        }
    }
}
int FirstAdjVex(ALGraph G,char u)
{
    int index=LocateVex_AL(G,u);
    ArcNode *p=G.vertics[index].firstarc;
    return p->adjvex;
}
int NextAdjVex(ALGraph G,char u,int w)
{
    int index=LocateVex_AL(G,u);
    ArcNode *p=G.vertics[index].firstarc;
    while(p->adjvex!=w)
    {
        p=p->nextarc;
    }
    if(p->nextarc==NULL)
        return -1;
    else
        return p->nextarc->adjvex;
}
void BFS_AL(ALGraph G,int v_index)
{
    cout<<G.vertics[v_index].data<<" ";
    G.visited[v_index]=true;
    SqQueue Q;
    Q.InitQueue();
    Q.EnQueue(G.vertics[v_index].data);
    while(!Q.QueueEmpty())
    {
        char u;
        Q.DeQueue(u);

        for(int w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))
        {
            if(!G.visited[w])
            {
                cout<<G.vertics[w].data<<" ";
                G.visited[w]=true;
                Q.EnQueue(G.vertics[w].data);
            }

        }
    }
}

bool S[MVNum];
ArcType D[MVNum];
int Path[MVNum];

void ShorttestPath_DIJ_AM(AMGraph G,int v0)
{
    int n=G.vexnum;
    for(int i=0;i<n;i++)
    {
        S[i]=false;
        D[i]=G.arcs[v0][i];
        if(D[i]<MaxInt)
            Path[i]=v0;
        else
            Path[i]=-1;
    }
    S[v0]=true;
    D[v0]=0;

    int v;
    for(int i=1;i<n;i++)
    {
        int min=MaxInt;
        for(int w=0;w<n;w++)
        {
            if(!S[w]&&D[w]<min)
            {
                v=w;
                min=D[w];
            }
        }
        S[v]=true;
        int z=v;
        cout<<G.vexs[v0]<<"->"<<G.vexs[z]<<":";
        string str="";
        str+=G.vexs[z];
        do
        {
            z=Path[z];
            str+=",";
            str+=G.vexs[z];

        }while(z!=v0);
        reverse(str.begin(),str.end());
        cout<<"("<<str<<")"<<D[v]<<endl;

        for(int w=0;w<n;w++)
        {
            if(!S[w]&&(D[v]+G.arcs[v][w]<D[w]))
            {
                D[w]=D[v]+G.arcs[v][w];
                Path[w]=v;
            }
        }
    }
}

void ShorttestPath_DIJ_AL(ALGraph G,int v0)
{
    int n=G.vexnum;
    for(int i=0;i<n;i++)
    {
        S[i]=false;
        Path[i]=-1;
        D[i]=MaxInt;
    }
    ArcNode *p=G.vertics[v0].firstarc;
    while(p)
    {
        D[p->adjvex]=p->info;
        Path[p->adjvex]=v0;
        p=p->nextarc;
    }

    S[v0]=true;
    D[v0]=0;

    int v;
    for(int i=1;i<n;i++)
    {
        int min=MaxInt;
        for(int w=0;w<n;w++)
        {
            if(!S[w]&&D[w]<min)
            {
                v=w;
                min=D[w];
            }
        }
        S[v]=true;
        int z=v;
        cout<<G.vertics[v0].data<<"->"<<G.vertics[z].data<<":";
        string str="";
        str+=G.vertics[z].data;
        do
        {
            z=Path[z];
            str+=",";
            str+=G.vertics[z].data;
        }while(z!=v0);
        reverse(str.begin(),str.end());
        cout<<"("<<str<<")"<<D[v]<<endl;

        ArcNode *p=G.vertics[v].firstarc;
        while(p)
        {
            if(!S[p->adjvex]&&(D[v]+p->info<D[p->adjvex]))
            {
                D[p->adjvex]=D[v]+p->info;
                Path[p->adjvex]=v;
            }
            p=p->nextarc;
        }
    }
}

void fun_AM_test()
{
    system("cls");
    AMGraph G;
    CreateUDN_AM(G);
    cout<<"该无向图的邻接矩阵为："<<endl;
    for(int i=0;i<G.vexnum;i++)
    {
        cout<<"\t"<<G.vexs[i];
    }cout<<endl<<endl;
    for(int i=0;i<G.vexnum;i++)
    {
        cout<<G.vexs[i]<<"\t";
        for(int j=0;j<G.vexnum;j++)
        {
            cout<<G.arcs[i][j]<<"\t";
        }
        cout<<endl<<endl;
    }
    system("pause");
    system("cls");
    int flag=1;
    while(flag)
    {
        cout<<"***********************************************************"<<endl;
        cout<<"**************  1、深度优先遍历无向图        **************"<<endl;
        cout<<"**************  2、广度优先遍历无向图        **************"<<endl;
        cout<<"**************  3、Dijkstra最短路径算法      **************"<<endl;
        cout<<"**************  4、程序退出                  **************"<<endl;
        cout<<"***********************************************************"<<endl;
        int ip;
        cout<<"请输入指令：";
        cin>>ip;
        switch(ip)
        {
        case 1:
            {
                cout<<"请输入起始顶点的下标（下标从1开始）：";
                int num;
                cin>>num;
                DFS_AM(G,num-1);cout<<endl;
                for(int i=0;i<G.vexnum;i++)
                {
                    G.visited[i]=false;
                }
                system("pause");
                break;
            }
        case 2:
            {
                cout<<"请输入起始顶点的下标（下标从1开始）：";
                int num;
                cin>>num;
                BFS_AM(G,num-1);cout<<endl;
                system("pause");
                break;
            }
        case 3:
            {
                cout<<"请输入起始顶点的下标（下标从1开始）：";
                int num;
                cin>>num;
                ShorttestPath_DIJ_AM(G,num-1);
                system("pause");
                break;
            }
        case 4:
            {
                flag=0;
                cout<<"程序退出！";
                Sleep(1000);
            }
        }
        system("cls");
    }
}

void fun_AL_test()
{
    system("cls");
    ALGraph G;
    CreateUDN_AL(G);
    cout<<"该无向图的邻接表为："<<endl;
    for(int i=0;i<G.vexnum;i++)
    {
        cout<<G.vertics[i].data<<" ";
        ArcNode *p=G.vertics[i].firstarc;
        while(p)
        {
            cout<<G.vertics[p->adjvex].data<<" ";
            p=p->nextarc;

        }
        cout<<endl;
    }
    system("pause");
    system("cls");
    int flag=1;
    while(flag)
    {
        cout<<"***********************************************************"<<endl;
        cout<<"**************  1、深度优先遍历无向图        **************"<<endl;
        cout<<"**************  2、广度优先遍历无向图        **************"<<endl;
        cout<<"**************  3、Dijkstra最短路径算法      **************"<<endl;
        cout<<"**************  4、程序退出                  **************"<<endl;
        cout<<"***********************************************************"<<endl;
        int ip;
        cout<<"请输入指令：";
        cin>>ip;
        switch(ip)
        {
        case 1:
            {
                cout<<"请输入起始顶点的下标（下标从1开始）：";
                int num;
                cin>>num;
                DFS_AL(G,num-1);cout<<endl;
                for(int i=0;i<G.vexnum;i++)
                {
                    G.visited[i]=false;
                }
                system("pause");
                break;
            }
        case 2:
            {
                cout<<"请输入起始顶点的下标（下标从1开始）：";
                int num;
                cin>>num;
                BFS_AL(G,num-1);cout<<endl;
                system("pause");
                break;
            }
        case 3:
            {
                cout<<"请输入起始顶点的下标（下标从1开始）：";
                int num;
                cin>>num;
                ShorttestPath_DIJ_AL(G,num-1);
                system("pause");
                break;
            }
        case 4:
            {
                flag=0;
                cout<<"程序退出！";
                Sleep(1000);
            }
        }
        system("cls");
    }
}

int main()
{
    cout<<"***********************************************************"<<endl;
    cout<<"**************  1、以邻接矩阵方法创建无向图  **************"<<endl;
    cout<<"**************  2、以邻接表方法创建无向图    **************"<<endl;
    cout<<"**************  3、退出                      **************"<<endl;
    cout<<"***********************************************************"<<endl;

    cout<<"选择以哪种方式创建无向图：";
    while(1)
    {
        int ip;

        cin>>ip;
        if(ip==1)
        {
            fun_AM_test();
            break;
        }
        else if(ip==2)
        {
            fun_AL_test();
            break;
        }
        else if(ip==3)
        {
            cout<<"程序退出！"<<endl;
            break;
        }
        else
        {
            cout<<"指令错误，请重新输入：";
        }
    }

    return 0;
}

/*0 2 10 0 4 30 0 5 100
1 2 5
2 3 50
3 5 10
4 3 20 4 5 60*/
酥酥～
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
武汉大学 遥感院 数据结构实习 Dijkstra算法的运用 图的运用
12-08
在这个实习项目中，我们将重点关注如何在实际场景中应用数据结构，特别是Dijkstra算法和图的处理。这个项目来自武汉大学遥感院，它涉及到CSV数据的读写、图的构建、遍历以及最短路径的计算和可视化，这些都是IT专业...
图的深度优先和广度优先遍历源码
10-11
在计算机科学中，图是一种数据结构，用于表示对象之间的关系或连接。图的遍历是图算法中的基础操作，主要用于访问图中所有的顶点。本资料包含的是Java实现的图的深度优先遍历（DFS, Depth First Search）和广度优先...
基于邻接矩阵的无向图构造，以及宽度优先、深度优先搜索(Java)
lhf2112的博客
04-19 516
图的数据结构组成成分，包括了顶点，边，以及它们之间的连接关系。邻接矩阵是一种采用大小为V*V的矩阵Adj来表示点和边的关系的。其中矩阵的值为布尔值，如果两个点i，j之间存在一条边，则Adj[i][j] = 1。   深度优先搜索，类似于树的前序遍历，本质上也是用堆栈来实现。应用包括了：拓扑排序，查找连通分量，解决类似迷宫的问题等。   宽度优先搜索，类似于树的层次遍历，本质上是用队列来实现。应
图（无向网）的邻接矩阵存储以及深度、广度优先遍历操作-java
daBai_Zzz的博客
01-17 1316
/** * 图的邻接矩阵表示法（无向网） */ public class AdjacencyMatrixGraph { // 图的顶点数组 char[] vexs; // 邻接矩阵 int arcs[][]; // 图中顶点和边的数量 int vexNums,arcNums; // 构造方法 public AdjacencyMatrixGraph(int n){ this.vexs=new char[n];
C++实现无向图的邻接矩阵存储 及 深度优先遍历
鸽子的博客
11-29 8518
方一：依次输入所有顶点的关系 方二：手动两两输入相连的顶点 #include <iostream> using namespace std; #define MAX_VERTEX 20 //最多允许创建20个顶点的图 typedef char DataType; typedef struct { int vertexNum,edgeNum; DataT...
图 无向网 采用邻接矩阵存储结构 按深度优先搜索和广度优先搜索遍历图 （DFS,BFS）实验报告 数据结构
绿色水杯
05-15 2575
基本内容： 输入图的类型、顶点数、弧（边）数、顶点信息、弧（边）信息，建立相应的图(具体类型可以是无向图、有向图、无向网、有向网，采用邻接矩阵存储结构)；分别按深度优先搜索和广度优先搜索遍历图；按某种形式输出图及遍历结果。 代码： #include<stdio.h> #include<stdlib.h> #define MAXQSIZE 100//循环队列最大值 #define OVERFLOW -2 #define FALSE 0 #define OK 1 #define MAX
浅谈算法和数据结构: 十二 无向图相关算法基础
weixin_34204722的博客
05-08 190
从这篇文章开始介绍图相关的算法，这也是Algorithms在线课程第二部分的第一次课程笔记。 图的应用很广泛，也有很多非常有用的算法，当然也有很多待解决的问题，根据性质，图可以分为无向图和有向图。本文先介绍无向图，后文再介绍有向图。 之所以要研究图，是因为图在生活中应用比较广泛： 无向图 图是若干个顶点(Vertices)和边(Edges)相互连接组成的。边仅由两个顶点连接，并且没有方...
aa.rar_优先搜索算法_广度搜索算法_深度广度
09-22
了解DFS和BFS的原理和实现至关重要，因为它们是许多高级算法和数据结构的基础，例如拓扑排序、最短路径计算（Dijkstra算法和Bellman-Ford算法）、强连通分量检测等。熟练掌握这两种搜索算法，对于提升编程能力和解决...
基于C++实现的航班最短路径计算系统源代码，可计算最短时间路径和最便宜路径，用深度优先遍历，广度优先遍历，DIjkstra等算法
最新发布
04-13
5. **图数据结构**：在实现这些算法时，会使用图数据结构来表示机场和航班之间的关系。每个机场可以看作是一个节点，航班则作为连接节点的边，边可能附带有时间和费用信息。 6. **优先队列（通常用堆实现）**：在...
shendu.rar_广度优先_深度优先搜索
09-20
**深度优先搜索(DFS, Depth First Search)与广度优先搜索(BFS, Breadth First Search)**是图论和树形结构中两种基本的遍历算法，广泛应用于计算机科学的各个领域，如图形渲染、游戏AI、网络路由、数据结构的遍历等。...
【图】概念、存储结构、广度优先遍历遍历、深度优先遍历 - 详解
CYK_byte的博客
05-28 1198
本章主要讲的是图的基本概念以及应用，面试的时候基本不考图~
图的操作（c++实现）
路漫漫小菜狗的博客
12-05 1989
（1）采用邻接矩阵/邻接表建立图； （2）采用深度优先/广度优先搜索方式遍历图； （3）编程实现Dijkstra最短路径算法。 #include <iostream> using namespace std; #define MaxInt 32767 #define MVNum 100 typedef struct{ char vexs[MVNum]; int arcs[MVNum][MVNum]; int vexnum,arcnum; }AMGraph; typedef
【图的邻接矩阵、邻接表存储结构，深度优先和广度优先搜索遍历以及普里姆算法实现最小生成树可执行程序】
lflcodeplus的博客
12-12 7980
​要求1. 编程实现如下功能： （1）输入有向图的顶点数、边数及各条边的顶点对， 建立用邻接表存储的有向图。 （2）输出有向图的邻接表 （3）对有向图进行深度优先搜索和广度优先搜索遍历，并分别输出其遍历序列。 有向图如下所示： #include<iostream> #include<string.h> #include<iomanip> using namespace std; ​ #define ERROR 0 #define OK 1 #define MVNum 1
C语言实现邻接矩阵创建无向图&图的深度优先遍历
weixin_30273763的博客
12-12 3771
Code /* '邻接矩阵' 实现无向图的创建、深度优先遍历*/ #include <stdio.h> #include <stdlib.h> #define MaxVex 100 //最多顶点个数 #define INFINITY 32768 //表示极大值，即 ∞ #define TRUE ...
图：邻接矩阵表示法创建无向图并深度优先搜索遍历
双鱼座boyy的博客
05-16 6093
无向图表示： 代码： #include<iostream> using namespace std; #define pointMax 100 #define MaxInt 32767 struct AMgroup { char VTchart[pointMax]; //顶点表 int AMchart[pointMax][pointMax]; //邻接矩阵 int point, vert; ...
无向图--邻接矩阵、连接矩阵、深度遍历、广度遍历、生成树
ChainingBlocks
09-15 2285
1、开始生成的无向图 2、由图深度优先遍历生成的树  package graph;import java.util.ArrayList;import java.util.Iterator;import java.util.LinkedList;import java.util.List;import java.util.Queue;import java.util.Stack;public cla
实验6.2 无向图的深度和广度遍历
weixin_47500703的博客
12-11 1122
文章目录头文件定义结构体定义变量创建无向图输出无向图初始化队列判断队列是否为空入队出队深度优先遍历广度优先遍历主函数运行结果 头文件 #include<stdio.h> #include<stdlib.h> #define MAX 20 定义结构体 typedef int Vextype; typedef struct Vnode { Vextype data; struct Vnode* next; }Vnode; typedef Vnode Lgraph[MAX]; typ
用邻接矩阵存储无向图的深度优先遍历
weixin_47511190的博客
08-26 2018
实现代码： #include<iostream> #include<queue> using namespace std; //邻接矩阵存储无向图的深度优先遍历 #define MaxSize 10 #define inf 0x3f3f3f bool book[MaxSize]; int n,m; //顶点数 边数 struct MGraph{ //定义图 int edge[MaxSize][MaxSize]; //存储边 int vexnum,arcnum;
练习6.1 邻接矩阵存储图的深度优先遍历 (20 分)
coderxsj
09-02 4806
试实现邻接矩阵存储图的深度优先遍历。 函数接口定义： void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) ); 其中MGraph是邻接矩阵存储的图，定义如下： typedef struct GNode *PtrToGNode; struct GNode{ int Nv; /* 顶点数 */ int Ne; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值