图的存储结构及遍历算法

最新推荐文章于 2024-09-09 14:58:59 发布
最新推荐文章于 2024-09-09 14:58:59 发布
阅读量4.2k 收藏 26
点赞数 4
分类专栏： 数据结构

一、图的存储结构

1.1 邻接矩阵

    图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。

    设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：

    

    看一个实例，下图左就是一个无向图。

    

    从上面可以看出，无向图的边数组是一个对称矩阵。

    从这个矩阵中，很容易知道图中的信息。

    （1）要判断任意两顶点是否有边无边就很容易了；

    （2）要知道某个顶点的度，其实就是这个顶点vi在邻接矩阵中第i行或（第i列）的元素之和；

    （3）求顶点vi的所有邻接点就是将矩阵中第i行元素扫描一遍，arc[i][j]为1就是邻接点；

    而有向图讲究入度和出度，顶点vi的入度为1，正好是第i列各数之和。顶点vi的出度为2，即第i行的各数之和。

    若图G是网图，有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：

    

    这里的Wij表示(vi,vj)上的权值。无穷大表示一个计算机允许的、大于所有边上权值的值，也就是一个不可能的极限值。下面左图就是一个有向网图，右图就是它的邻接矩阵。

    

那么邻接矩阵是如何实现图的创建的呢？代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <curses.h>
 
typedef char VertexType;         //顶点类型应由用户定义
typedef int EdgeType;            //边上的权值类型应由用户定义
 
#define MAXVEX  100             //最大顶点数，应由用户定义
#define INFINITY    65535       //用65535来代表无穷大
#define DEBUG
 
typedef struct
{
    VertexType vexs[MAXVEX];       //顶点表
    EdgeType   arc[MAXVEX][MAXVEX];//邻接矩阵，可看作边
    int numVertexes, numEdges;      //图中当前的顶点数和边数
}Graph;
 
//定位
int locates(Graph *g, char ch)
{
    inti = 0;
    for(i = 0; i < g->numVertexes; i++)
    {
        if(g->vexs[i] == ch)
        {
            break;
        }
    }
    if(i >= g->numVertexes)
    {
        return -1;
    }
     
    return i;
}
 
//建立一个无向网图的邻接矩阵表示
void CreateGraph(Graph *g)
{
    inti, j, k, w;
    printf("输入顶点数和边数:\n");
    scanf("%d,%d", &(g->numVertexes), &(g->numEdges));
     
    #ifdef DEBUG
    printf("%d %d\n", g->numVertexes, g->numEdges);
    #endif
 
    for(i = 0; i < g->numVertexes; i++)
    {
        g->vexs[i] = getchar();
        while(g->vexs[i] == '\n')
        {
            g->vexs[i] = getchar();
        }
    }
     
    #ifdef DEBUG
    for(i = 0; i < g->numVertexes; i++)
    {
        printf("%c ", g->vexs[i]);
    }
    printf("\n");
    #endif
 
 
    for(i = 0; i < g->numEdges; i++)
    {
        for(j = 0; j < g->numEdges; j++)
        {
            g->arc[i][j] = INFINITY; //邻接矩阵初始化
        }
    }
    for(k = 0; k < g->numEdges; k++)
    {
        char p,q;
        printf("输入边(vi,vj)上的下标i，下标j和权值:\n");
         
        p = getchar();
        while(p == '\n')
        {
            p = getchar();
        }
        q = getchar();
        while(q == '\n')
        {
            q = getchar();
        }
        scanf("%d", &w);    
         
        int m = -1;
        int n = -1;
        m = locates(g, p);
        n = locates(g, q);
        if(n == -1 || m == -1)
        {
            fprintf(stderr,"there is no this vertex.\n");
            return;
        }
        //getchar();
        g->arc[m][n] = w;
        g->arc[n][m] = g->arc[m][n];  //因为是无向图，矩阵对称
    }
}
 
//打印图
void printGraph(Graph g)
{
    int i, j;
    for(i = 0; i < g.numVertexes; i++)
    {
        for(j = 0; j < g.numVertexes; j++)
        {
            printf("%d  ", g.arc[i][j]);
        }
        printf("\n");
    }
}
 
int main(intargc, char**argv)
{
    Graph g;
     
    //邻接矩阵创建图
    CreateGraph(&g);
    printGraph(g);
    return 0;
}

从代码中可以得到，n个顶点和e条边的无向网图的创建，时间复杂度为O(n + n2 + e)，其中对邻接矩阵Grc的初始化耗费了O(n2)的时间。


1.2 邻接表

    邻接矩阵是不错的一种图存储结构，但是，对于边数相对顶点较少的图，这种结构存在对存储空间的极大浪费。因此，找到一种数组与链表相结合的存储方法称为邻接表。

    邻接表的处理方法是这样的：

    （1）图中顶点用一个一维数组存储，当然，顶点也可以用单链表来存储，不过，数组可以较容易的读取顶点的信息，更加方便。

    （2）图中每个顶点vi的所有邻接点构成一个线性表，由于邻接点的个数不定，所以，用单链表存储，无向图称为顶点vi的边表，有向图则称为顶点vi作为弧尾的出边表。

    例如，下图就是一个无向图的邻接表的结构。

    

    从图中可以看出，顶点表的各个结点由data和firstedge两个域表示，data是数据域，存储顶点的信息，firstedge是指针域，指向边表的第一个结点，即此顶点的第一个邻接点。边表结点由adjvex和next两个域组成。adjvex是邻接点域，存储某顶点的邻接点在顶点表中的下标，next则存储指向边表中下一个结点的指针。

   对于带权值的网图，可以在边表结点定义中再增加一个weight的数据域，存储权值信息即可。如下图所示。

    

对于邻接表结构，图的建立代码如下:

/* 邻接表表示的图结构 */
#include <stdio.h>
#include<stdlib.h>
 
#define DEBUG
#define MAXVEX 1000             //最大顶点数
typedef char VertexType;        //顶点类型应由用户定义
typedef int EdgeType;           //边上的权值类型应由用户定义
 
typedef struct EdgeNode         //边表结点
{
    int adjvex;                 //邻接点域，存储该顶点对应的下标
    EdgeType weigth;            //用于存储权值，对于非网图可以不需要
    struct EdgeNode *next;      //链域，指向下一个邻接点
}EdgeNode;
 
typedef struct VertexNode       //顶点表结点
{
    VertexType data;            //顶点域，存储顶点信息
    EdgeNode *firstedge;        //边表头指针
}VertexNode, AdjList[MAXVEX];
 
typedef struct
{
    AdjList adjList;
    int numVertexes, numEdges;  //图中当前顶点数和边数
}GraphList;
 
int Locate(GraphList *g, char ch)
{
    int i;
    for(i = 0; i < MAXVEX; i++)
    {
        if(ch == g->adjList[i].data)
        {
            break;
        }
    }
    if(i >= MAXVEX)
    {
        fprintf(stderr,"there is no vertex.\n");
        return -1;
    }
    return i;
}
 
//建立图的邻接表结构
voidCreateGraph(GraphList *g)
{
    inti, j, k;
    EdgeNode *e;
    EdgeNode *f;
    printf("输入顶点数和边数:\n");
    scanf("%d,%d", &g->numVertexes, &g->numEdges);
     
    #ifdef DEBUG
    printf("%d,%d\n", g->numVertexes, g->numEdges);
    #endif
     
    for(i = 0; i < g->numVertexes; i++)
    {
        printf("请输入顶点%d:\n", i);
        g->adjList[i].data = getchar();         //输入顶点信息
        g->adjList[i].firstedge = NULL;          //将边表置为空表
        while(g->adjList[i].data == '\n')
        {
            g->adjList[i].data = getchar();
        }
    }
    //建立边表
    for(k = 0; k < g->numEdges; k++)
    {
        printf("输入边(vi,vj)上的顶点序号:\n");
        char p, q;
        p = getchar();
        while(p == '\n')
        {
            p = getchar();
        }
        q = getchar();
        while(q == '\n')
        {
            q = getchar();
        }
        int m, n;
        m = Locate(g, p);
        n = Locate(g, q);
        if(m == -1 || n == -1)
        {
            return;
        }
        #ifdef DEBUG
        printf("p = %c\n", p);
        printf("q = %c\n", q);
        printf("m = %d\n", m);
        printf("n = %d\n", n);
        #endif
     
        //向内存申请空间，生成边表结点
        e = (EdgeNode *)malloc(sizeof(EdgeNode));
        if(e == NULL)
        {
            fprintf(stderr,"malloc() error.\n");
            return;
        }
        //邻接序号为j
        e->adjvex = n;
        //将e指针指向当前顶点指向的结构
        e->next = g->adjList[m].firstedge;
        //将当前顶点的指针指向e
        g->adjList[m].firstedge = e;
         
        f = (EdgeNode *)malloc(sizeof(EdgeNode));
        if(f == NULL)
        {
            fprintf(stderr,"malloc() error.\n");
            return;
        }
        f->adjvex = m;
        f->next = g->adjList[n].firstedge;
        g->adjList[n].firstedge = f;
    }
}
 
 
void printGraph(GraphList *g)
{
    inti = 0;
    #ifdef DEBUG
    printf("printGraph() start.\n");
    #endif
     
    while(g->adjList[i].firstedge != NULL && i < MAXVEX)
    {
        printf("顶点:%c  ", g->adjList[i].data);
        EdgeNode *e = NULL;
        e = g->adjList[i].firstedge;
        while(e != NULL)
        {
            printf("%d  ", e->adjvex);
            e = e->next;
        }
        i++;
        printf("\n");
    }
}
 
int main(intargc, char**argv)
{
    GraphList g;
    CreateGraph(&g);
    printGraph(&g);
    return0;
}

 对于无向图，一条边对应都是两个顶点，所以，在循环中，一次就针对i和j分布进行插入。本算法的时间复杂度，对于n个顶点e条边来说，很容易得出是O(n+e)。


1.3 十字链表

    对于有向图来说，邻接表是有缺陷的。关心了出度问题，想了解入度就必须要遍历整个图才知道，反之，逆邻接表解决了入度却不了解出度情况。下面介绍的这种有向图的存储方法：十字链表，就是把邻接表和逆邻接表结合起来的。

    重新定义顶点表结点结构，如下所示。

    

    其中firstin表示入边表头指针，指向该顶点的入边表中第一个结点，firstout表示出边表头指针，指向该顶点的出边表中的第一个结点。

    重新定义边表结构，如下所示。

    

    其中，tailvex是指弧尾在顶点表的下标，headvex是指弧头在顶点表的下标，headlink是指入边表指针域，指向弧头相同的下一条边，taillink是指边表指针域，指向弧尾相同的下一条边。如果是网，还可以增加一个weight域来存储权值。

    比如下图，顶点依然是存入一个一维数组，实线箭头指针的图示完全与邻接表相同。就以顶点v0来说，firstout指向的是出边表中的第一个结点v3。所以，v0边表结点hearvex = 3，而tailvex其实就是当前顶点v0的下标0，由于v0只有一个出边顶点，所有headlink和taillink都是空的。

    

    重点需要解释虚线箭头的含义。它其实就是此图的逆邻接表的表示。对于v0来说，它有两个顶点v1和v2的入边。因此的firstin指向顶点v1的边表结点中headvex为0的结点，如上图圆圈1。接着由入边结点的headlink指向下一个入边顶点v2，如上图圆圈2。对于顶点v1，它有一个入边顶点v2，所以它的firstin指向顶点v2的边表结点中headvex为1的结点，如上图圆圈3。

    十字链表的好处就是因为把邻接表和逆邻接表整合在一起，这样既容易找到以v为尾的弧，也容易找到以v为头的弧，因而比较容易求得顶点的出度和入度。 而且除了结构复杂一点外，其实创建图算法的时间复杂度是和邻接表相同的，因此，在有向图应用中，十字链表是非常好的数据结构模型。


1.4 邻接多重表

   邻接多重表(Adjacency Multilist)主要用于存储无向图。因为，如果用邻接表存储无向图，每条边的两个边结点分别在以该边所依附的两个顶点为头结点的链表中，这给图的某些操作带来不便。例如，对已访问过的边做标记，或者要删除图中某一条边等，都需要找到表示同一条边的两个结点。因此，在进行这一类操作的无向图的问题中采用邻接多重表作存储结构更为适宜。
邻接多重表的存储结构和十字链表类似，也是由顶点表和边表组成，每一条边用一个结点表示，其顶点表结点结构和边表结点结构如图所示。


                                                              

                                                                                                 

     其中，顶点表由两个域组成，vertex 域存储和该顶点相关的信息firstedge 域指示第一条依附于该顶点的边；边表结点由六个域组成，mark为标记域，可用以标记该条边是否被搜索过；ivex 和

jvex 为该边依附的两个顶点在图中的位置；ilink 指向下一条依附于顶点ivex的边;jlink 指向下一条依附于顶点jvex 的边，info 为指向和边相关的各种信息的指针域。


二、图的遍历

    图的遍历和树的遍历类似，希望从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次，这一过程就叫图的遍历。

    对于图的遍历来说，如何避免因回路陷入死循环，就需要科学地设计遍历方案，通过有两种遍历次序方案：深度优先遍历和广度优先遍历。

2.1 深度优先遍历

    深度优先遍历，也有称为深度优先搜索，简称DFS。其实，就像是一棵树的前序遍历。

    深度优先遍历的思想：从图中某个顶点出发，访问该顶点的邻接点(可采用右手原则)，然后以该邻接点为新的顶点，访问该顶点的邻接点。重复执行上述操作，知道当前节点没有邻接点为止。返回到上一个被访问过但还有未被访问的邻接点的顶点，按照以上步骤继续访问该顶点的其他未被访问的邻接点。以此类推，之道图中所有的顶点都被访问为止。

用邻接矩阵的方式，则代码如下所示：

#define MAXVEX  100     //最大顶点数
typedefint Boolean;            //Boolean 是布尔类型，其值是TRUE 或FALSE
Boolean visited[MAXVEX];        //访问标志数组
#define TRUE 1
#define FALSE 0
 
//邻接矩阵的深度优先递归算法
voidDFS(Graph g, inti)
{
    intj;
    visited[i] = TRUE;
    printf("%c ", g.vexs[i]);                           //打印顶点，也可以其他操作
    for(j = 0; j < g.numVertexes; j++)
    {
        if(g.arc[i][j] == 1 && !visited[j])
        {
            DFS(g, j);                  //对为访问的邻接顶点递归调用
        }
    }
}
 
//邻接矩阵的深度遍历操作
voidDFSTraverse(Graph g)
{
    inti;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;         //初始化所有顶点状态都是未访问过状态
    }
    for(i = 0; i < g.numVertexes; i++)
    {
        if(!visited[i])            //对未访问的顶点调用DFS，若是连通图，只会执行一次
        {
            DFS(g,i);
        }
    }
}


如果使用的是邻接表存储结构，其DFSTraverse函数的代码几乎是相同的，只是在递归函数中因为将数组换成了链表而有不同，代码如下： 

//邻接表的深度递归算法
voidDFS(GraphList g, inti)
{
    EdgeNode *p;
    visited[i] = TRUE;
    printf("%c ", g->adjList[i].data);   //打印顶点，也可以其他操作
    p = g->adjList[i].firstedge;
    while(p)
    {
        if(!visited[p->adjvex])
        {
            DFS(g, p->adjvex);           //对访问的邻接顶点递归调用
        }
        p = p->next;
    }
}
 
//邻接表的深度遍历操作
voidDFSTraverse(GraphList g)
{
    inti;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;
    }
    for(i = 0; i < g.numVertexes; i++)
    {
        if(!visited[i])
        {
            DFS(g, i);
        }
    }
}

   对比两个不同的存储结构的深度优先遍历算法，对于n个顶点e条边的图来说，邻接矩阵由于是二维数组，要查找某个顶点的邻接点需要访问矩阵中的所有元素，因为需要O(n2)的时间。而邻接表做存储结构时，找邻接点所需的时间取决于顶点和边的数量，所以是O(n+e)。显然对于点多边少的稀疏图来说，邻接表结构使得算法在时间效率上大大提高。


2.2 广度优先遍历

    广度优先遍历，又称为广度优先搜索，简称BFS。图的广度优先遍历就类似于树的层序遍历了。

    广度优先遍历的思想：从图的某个顶点V出发，首先访问顶点V，然后按照次序访问顶点V的未被访问的每一个邻接点，接着访问这些邻接点的邻接点，并保证遵循先被访问的邻接点的邻接点先访问，后被访问的邻接点的邻接点后访问的原则，以此访问邻接点的邻接点。

邻接矩阵做存储结构时，广度优先搜索的代码如下：

//邻接矩阵的广度遍历算法
voidBFSTraverse(Graph g)
{
    inti, j;
    Queue q;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;
    }
    InitQueue(&q);
    for(i = 0; i < g.numVertexes; i++)//对每个顶点做循环
    {
        if(!visited[i])              //若是未访问过
        {
            visited[i] = TRUE;
            printf("%c ", g.vexs[i]); //打印结点，也可以其他操作
            EnQueue(&q, i);           //将此结点入队列
            while(!QueueEmpty(q))    //将队中元素出队列，赋值给
            {
                int m;
                DeQueue(&q, &m);        
                for(j = 0; j < g.numVertexes; j++)
                {
                    //判断其他顶点若与当前顶点存在边且未访问过
                    if(g.arc[m][j] == 1 && !visited[j])
                    {
                        visited[j] = TRUE;
                        printf("%c ", g.vexs[j]);
                        EnQueue(&q, j);
                    }
                }
            }
        }
    }
}

 对于邻接表的广度优先遍历，代码与邻接矩阵差异不大， 代码如下：

//邻接表的广度遍历算法
voidBFSTraverse(GraphList g)
{
    inti;
    EdgeNode *p;
    Queue q;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;
    }
    InitQueue(&q);
    for(i = 0; i < g.numVertexes; i++)
    {
        if(!visited[i])
        {
            visited[i] = TRUE;
            printf("%c ", g.adjList[i].data);   //打印顶点，也可以其他操作
            EnQueue(&q, i);
            while(!QueueEmpty(q))
            {
                intm;
                DeQueue(&q, &m);
                p = g.adjList[m].firstedge;     找到当前顶点边表链表头指针
                while(p)
                {
                    if(!visited[p->adjvex])
                    {
                        visited[p->adjvex] = TRUE;
                        printf("%c ", g.adjList[p->adjvex].data);
                        EnQueue(&q, p->adjvex);
                    }
                    p = p->next;
                }
            }
        }
    }
}

    对比图的深度优先遍历与广度优先遍历算法，会发现，它们在时间复杂度上是一样的，不同之处仅仅在于对顶点的访问顺序不同。可见两者在全图遍历上是没有优劣之分的，只是不同的情况选择不同的算法。


图——存储及遍历
GorMing 的博客
12-27 647
图——存储及遍历图——存储及遍历图的定义图的存储及基本操作图的存储图的基本操作图的遍历广度优先搜索BFS深度优先搜索DFS图的遍历与连通性算法演练 图——存储及遍历 图的定义 定义：图G是由顶点集V和边集E组成，记为G=(V, E),其中V(G)表示图G 的顶点的非空有限集，E(G)表示图中的边的集合。顶点的个数称为图的阶。 基本概念： 有向图 无向图 简单图：如果图满如下条件则图称...
图的储存结构及遍历
tao2380665126的博客
11-13 885
来学习图的储存结构啦
图的存储与遍历（C语言实现）
01-08
包括两程序，一个是用邻接矩阵存储图实现深度优先遍历和广度优先遍历，一个是用临街链表存储实现深度优先遍历和广度优先遍历，均调试无误
数据结构——图的存储和遍历算法
CSDNadvancer的博客
02-26 1508
概述 图是数据构中数据元素间具有多对多的的一种逻辑结构，在现实生活中用处十分广阔，实用性很高。而本篇数据结构的博客将介绍图的存储结构：邻接矩阵、邻接链表、十字链表（不讲述）、邻接多重链表（不讲述）。而图的遍历主要介绍DFS、BFS分别在邻接矩阵和邻接链表上的结构展开，后续博客会出关于图的其他算法等 图的存储结构和遍历算法 邻接矩阵：存储定点的数组、表示边的二维数组，以下结构的定义按C语言组织 存放...
数算学习——图的应用
最新发布
m0_71266194的博客
09-09 998
是指从图中的某一个顶点出发，按照一定的策略将图中的所有顶点访问一一遍，使得每个顶点被遍历且都遍历一次。容易看出，是一种特殊的图，所以树的遍历实际上也是一种特殊的图的遍历，图的遍历是树的遍历的一般化形式。图的遍历比树的遍历复杂，因为图中的每一个顶点都可能与其他顶点相连。也就是说，在访问过某个顶点之后，还是可能经过其他路径之后这个顶点。为了避免重复访问一个顶点，在遍历图的过程中应当判断顶点是否被访问，若已被访问则不再访问。图的遍历有和两种基本形式，对于和都适用。
图算法--图的存储和遍历
低到尘埃，仰望星空
11-07 392
图的存储 邻接矩阵   设图G(V,E)G(V, E)G(V,E)的顶点标号为0,1,⋯ ,N−10, 1, \cdots , N-10,1,⋯,N−1， 那么可以令二维数组G[N][N]G[N][N]G[N][N]的两维分别表示图的顶点标号，即如果G[i][j]G[i][j]G[i][j]为1， 则说明顶点i和j之间有边；如果G[i][j]G[i][j]G[i][j]为0，则说明顶点i和顶点j之...
图的存储与遍历
赞美月亮的专栏
03-30 1012
图的存储方式 1）邻接矩阵：图的邻接矩阵表示是唯一的，且无向图的邻接矩阵一定是一个对称矩阵 2）邻接表：是图的链式存储结构 3）十字链表：有向图的另一种链式存储结构 4）邻接多重表：无向图的链式存储方式 图的深度遍历和广度遍历 DFS 深度遍历类似于树的先根遍历，是树的先根遍历的推广。假设初始状态是图中所有顶点未曾被访问，则深度遍历可从图中 某个顶点v出发，访问此顶点，然
任意串并拓扑结构的数据结构及遍历算法.pdf
08-07
本文探讨了在图论中，对于具有串并关系特点的图的特殊结构，设计了相应的数据结构以及遍历算法。这种图不同于一般图，其中包含了特殊的拓扑关系。文章重点在于提出一种面向节点的存储结构，使得能够更好地表示具有...
二叉树的存储结构和遍历算法
10-08
给出二叉树的介绍及存储方法和遍历方法.专业课件，非常详细
二叉树建立及遍历算法实现
06-03
建立二叉树，实现二叉树的先序、中序、后序的递归遍历算法，输出遍历结果。 实现二叉树的先序、中序、后序和层次遍历的非递归算法，输出遍历结果。
C++实现图的存储结构及遍历
01-11
本篇将深入探讨如何在C++中实现图的存储结构以及遍历算法。 首先，图的存储结构通常有两种基本方式：邻接矩阵和邻接表。邻接矩阵是一个二维数组，其中的元素表示图中节点对之间的连接状态。如果节点i和节点j之间有...
图的存储和遍历
04-19
用数组表示法存储图，并实现图的深度优先遍历和广度优先遍历。
图的存储与遍历(数据结构)
12-10
目 录 第一章 课程设计目的 2 第二章 课程设计内容和要求 2 第三章 课程设计分析 3 第四章 算法描述 4 第五章 源代码 8 第六章 运行结果分析 13 第七章 结束语 15 第八章 参考文献 15 第一章 课程设计目的 本学期我们对《数据结构》这门课程进行了学习。这门课程是一门实践性非常强的课程，为了让大家更好地理解与运用所学知识，提高动手能力，我们进行了此次课程设计实习。这次课程设计不但要求实习者掌握《数据结构》中的各方面知识，还要求实习者具备一定的C语言基础和编程能力。 具体说来，这次课程设计主要有两大方面目的。 一是让实习者通过实习掌握《数据结构》中的知识。对于《图的存储与遍历》这一课题来说，所要求掌握的数据结构知识主要有：图的邻接表存贮结构、队列的基本运算实现、邻接表的算法实现、图的广度优先搜索周游算法实现、图的深度优先搜索周游算法实现。 二是通过实习巩固并提高实习者的C语言知识，并初步了解Visual C++的知识，提高其编程能力与专业水平。 第二章 课程设计内容和要求 2.1课程设计内容 该课题要求以邻接表的方式存储图，输出邻接表，并要求实现图的深度、广度两种遍历。
数据结构之------深度优先搜索(DFS)
Discovering,Thinking and Finding——This Is My Logic
05-24 1328
深度优先搜索 在编程时经常需要用到搜索，因此掌握搜索算法是很重要的，这里介绍一下深度优先搜索并附上代码样例 1、深度优先搜索思想      深度优先搜索遍历类似于树的先序遍历。假定给定图G的初态是所有顶点均未被访问过，在G中任选一个顶点i作为遍历的初始点，则深度优先搜索递归调用包含以下操作： （1）访问搜索到的未被访问的邻接点； （2）将此顶点的visited数组元素值置
9.图的存储与遍历
nodd_le的博客
04-13 611
图是由一系列顶点和若干连结顶点集合内两个顶点的边组成的数据结构。数学意义上的图，指的是由一系列点与边构成的集合。 图的存储方式主要为邻接矩阵和邻接表。 主要的遍历方式有深度优先遍历(dfs)和广度优先遍历(bfs).
图的存储结构与遍历
Skyyy82的博客
05-05 471
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、顶点类型、图的类型以及边的结构二、邻接矩阵存储三、邻接表存储四、图的建立1.邻接矩阵建立无向图（网）2.邻接表建立有向图（网）五、遍历1.DFS遍历邻接矩阵2.DFS遍历邻接表3.BFS遍历邻接矩阵4.BFS遍历邻接表六、完整程序1.函数部分头文件2.main 一、顶点类型、图的类型以及边的结构 typedef int vertex;//顶点编号从0开始 typedef enum bool{ true = 1, false .
图的存储及遍历
weixin_55782195的博客
07-17 2097
文章目录一、图的定义及分类1.1 图的分类二、 无向图2.1 图的相关术语2.2 图的存储结构2.2.1 邻接矩阵2.2.2 邻接表三、无向图的代码实现3.1 图的创建四、图的遍历4.1 深度优先遍历4.2 广度优先遍历 一、图的定义及分类 定义∶图是由一组顶点和一组能够将两个顶点相连的边组成的 特殊的图︰ 1.自环:即一条连接一个顶点和其自身的边; 2.平行边:连接同一对顶点的两条边; 1.1 图的分类 按照连接两个顶点的边的不同，可以把图分为以下两种: 无向图:边仅仅连接两个顶点，没有其他含义;
"图的存储结构及遍历算法详解
本文主要讨论了数据结构中关于图的相关知识。首先介绍了图的存储结构，包括图的顺序存储结构和链式存储结构。...通过本文的学习，可以更加深入地理解图的存储结构和遍历方法，为后续的图相关算法和问题的解决奠定基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值