数据结构之图的创建以及深度和广度优先遍历

最新推荐文章于 2024-04-30 21:36:36 发布
最新推荐文章于 2024-04-30 21:36:36 发布
阅读量1.9k 收藏 24
点赞数 2
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrslxw/article/details/100610467
版权

图的存储结构

图这种结构想想就复杂,图中既有顶点还有两顶点构成的边,依靠简单的顺序存储结构是无法来表达的。
因此就有了

  • 邻接矩阵存储
  • 邻接表存储

邻接矩阵

用矩阵来存储图,想想就是二维数组啦;不过只用二维数组来存储元素来说,如果这些元素是字符,那岂不是很麻烦,如果是将其转换为数字关系来存储会非常方便;于是就另需要一个一维数组来存储这些元素,用这些元素对应的数组的索引来表示图的关系.先来看下一个简单的图

在这里插入图片描述

接下来就用矩阵来建立图的各个顶点之间的关系了

在这里插入图片描述

其中的 ∞ 表示两顶点之间不构成边

这张图是有向图，而无向图的矩阵中存在对称关系

代码

typedef char  VertexType;    //顶点类型    vertex type
typedef int   EdgeType;      //边上的权值类型  weight type on edge
#define MAXVEX  100          //最大顶点数        Maximum vertex
#define INFINITY  65535      //用65535来代表 ∞   The 65535 represents ∞

typedef struct
{
    VertexType vexs[MAXVEX];    //vertex table 顶点表
    EdgeType arc[MAXVEX][MAXVEX];   //Edge table 边表 邻接矩阵
    int numVertexes;                //图中顶点数   Number of vertices in the figure
    int numEdges;                   //图中边数
}MGraph;

void CreateMGraph(MGraph *G)
{
    printf("Please enter the number of vertexes and edges : ");
    scanf("%d %d", &G->numVertexes, &G->numEdges);

    for (int i = 0; i < G->numVertexes; i++)
    {
        getchar();
        scanf("%c", &G->vexs[i]);
    }

    for (int i = 0; i < G->numVertexes; i++)
        for (int j = 0; j < G->numVertexes; j++)
            G->arc[i][j] = INFINITY;
    int i, j, w;

    for (int k = 0; k < G->numEdges; k++)
    {
        printf("输入边（vi，vj）上的两个下标以及权值：");   //赋权值为 1 ，代表两顶点能形成边
        scanf("%d %d %d", &i, &j, &w);
        G->arc[i][j] = w;
        G->arc[j][i] = G->arc[i][j];   //此处是无向图的步骤，若是有向图可省略该行
    }
}

邻接表

图的邻接表存储结构和树的孩子表示法的存储结构非常相似，相对于邻接矩阵来说某个角度上是控制了内存空间的消耗

邻接表是利用了一位数组和链表来完成的，直接看图吧

在这里插入图片描述

邻接表表示

此图是有向图，对于无向图，在存储中也存在这对称关系；上图的右边链表部分，存储顶点是用的索引来存储的。

代码

typedef char VertexType;     //顶点类型    vertex type
typedef int  EdgeType;       //边上的权值类型  weight type on edge
#define MAXVEX  100          //最大顶点数        Maximum vertex
typedef struct EdgeNode      //edge table node  边表结点
{
    int agjvex;              //邻接表域，存储下标    Adjacent table domains are used to store subscripts
    EdgeType weight;         //用于存储权值          storage weight
    struct EdgeNode *next;
}EdgeNode;

typedef struct VertexNode    //顶点表结点        vertex table node
{
    VertexType data;        //存储顶点信息       storage vertex information
    EdgeNode *firstedge;    //边表头节点         edge table header node
}VertexNode, AdjList[MAXVEX];

typedef struct
{
    AdjList adjList;
    int numVertexes;         //图中顶点数   Number of vertices in the figure
    int numEdges;           //图中边数
}GraphAdjList;
	
void create_Graph(GraphAdjList *G)
{
    int i, j;
    EdgeNode *e;
    printf("Please enter the number of vertexes and edges : ");
    scanf("%d %d", &G->numVertexes, &G->numEdges);
    for (i = 0; i < G->numVertexes; i++)
    {
        getchar();
        //输入顶点信息
        scanf("%c", &G->adjList[i].data);
        //将边表置空  Place the edge table as an empty table
        G->adjList[i].firstedge = NULL;
    }

    for (int k = 0; k < G->numEdges; k++)    //Build edge table
    {
        printf("Please enter vertex serial number on the edge like (vi, vj)  ：");
        scanf("%d %d", &i, &j);
        e = (EdgeNode *)malloc(sizeof(EdgeNode));
        e->agjvex = j;
        e->next = G->adjList[i].firstedge;
        G->adjList[i].firstedge = e;

        //由于无向图存在对称性
        e = (EdgeNode *)malloc(sizeof(EdgeNode));
        e->agjvex = i;
        e->next = G->adjList[j].firstedge;
        G->adjList[j].firstedge = e;
    }
}

邻接矩阵和邻接表的优点和缺点

邻接矩阵

  • 优点：对于稠密图来说，邻接矩阵存起来很合理，而且邻接矩阵存储结构可以直接查找图的权值，顶点的度，顶点的邻接顶点等
  • 缺点：由于矩阵是 n×n 的所以存储稀疏图是非常浪费空间的

邻接表

  • 优点：空间利用率高，容易找到某个顶点的邻接顶点
  • 缺点：判断两顶点之间是否构成边不方便

邻接矩阵的空间复杂度为O(n^2),而邻接表的空间复杂度为O(n+e)。

图的遍历

图的遍历分为深度优先遍历和广度优先遍历

深度优先遍历

对于该遍历，是以图的一个顶点出发，再随便深入一个邻接顶点，重复此步骤，其中对每个访问过的顶点做一下标记，就这样不断的访问，直到所有的顶点都访问完。

代码

void DFS(MGraph G, int i)
{
    //先打印顶点
    printf("%c ", G.vexs[i]);
    //标记访问过
    visited[i] = true;

    //开始深度遍历
    for (int j = 0; j < G.numVertexes; j++)
    {
        //寻找未访问过的邻接顶点
        if (!visited[j] && G.arc[i][j] == 1)
        {
            DFS(G, j);
        }
    }
}

void DFSTraverse(MGraph G)
{
    //将顶点全部标记为未访问
    for (int i = 0; i < G.numVertexes; i++)
    {
        visited[i] = false;
    }

    for (int i = 0; i < G.numVertexes; i++)
    {
        if (!visited[i])       //对于连通图来说一遍就可以
        {
            DFS(G, i);
        }
    }
}

广度优先遍历

图的广度优先遍历，其中涉及到了队列；广度遍历是以图的某个顶点出发，然后将该顶点存入队列，接着将队列的一个元素拿出来，并且访问它的所有邻接顶点存入队列，如此循环，直到队列为空。

代码

void BFSTraverse(MGraph G)
{
    int i, j;
    LinkQueue Q;
    //初始化标记顶点
    for (i = 0; i < G.numVertexes; i++)
    {
        visited[i] = false;
    }

    init_Queue(&Q);

    for (i = 0; i < G.numVertexes; i++)
    {
        if (!visited[i])
        {
            visited[i] = true;
            printf("%c ", G.vexs[i]);
            EnQueue(&Q, i);
            while(!isEmpty(Q))
            {
                DeQueue(&Q, &i);  //若该顶点未访问过，取出给i
                for (j = 0; j < G.numVertexes; j++)
                {
                    //找出顶点i的所有未访问过的邻接点
                    if (!visited[j] && G.arc[i][j] == 1)
                    {
                        visited[j] = true;
                        printf("%c ", G.vexs[j]);
                        EnQueue(&Q, j);
                    }
                }
            }
        }
    }

}

图的邻接矩阵的两种遍历

#include <stdio.h>
#include <stdlib.h>

typedef char  VertexType;    //顶点类型    vertex type
typedef int   EdgeType;      //边上的权值类型  weight type on edge
#define MAXVEX  100          //最大顶点数        Maximum vertex
#define INFINITY  65535      //用65535来代表 ∞   The 65535 represents ∞

typedef struct
{
    VertexType vexs[MAXVEX];    //vertex table 顶点表
    EdgeType arc[MAXVEX][MAXVEX];   //Edge table 边表 邻接矩阵
    int numVertexes;                //图中顶点数   Number of vertices in the figure
    int numEdges;                   //图中边数
}MGraph;

typedef int QElemType;

typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}QNode, *Queue;
typedef struct
{
    Queue Front;
    Queue Rear;
}LinkQueue;

bool visited[MAXVEX];

void init_Queue(LinkQueue *Q)
{
    Q->Front = (Queue)malloc(sizeof(QNode));
    if (!Q->Front)
    {
        printf("The memory allocation failed ! Queue initialization falied! \n");
        exit(0);
    }
    Q->Rear = Q->Front;
    Q->Front->next = NULL;
}

void EnQueue(LinkQueue *Q, int value)
{
    Queue qNew = (Queue)malloc(sizeof(QNode));
    if (!qNew)
    {
        printf("The memory allocation failed!Element can not enter queue!\n");
        exit(0);
    }
    qNew->data = value;
    qNew->next = NULL;
    Q->Rear->next = qNew;
    Q->Rear = qNew;
}

void DeQueue(LinkQueue *Q, int *value)
{
    Queue q;
    if (Q->Front == Q->Rear)
    {
        printf("The queue is empty!\n");
        exit(0);
    }

    q = Q->Front->next;
    *value = q->data;
    Q->Front->next = q->next;

    if (Q->Rear == q)
    {
        Q->Rear = Q->Front;
    }
    free(q);
    q = NULL;
}

bool isEmpty(LinkQueue Q)
{
    if (Q.Front == Q.Rear)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void CreateMGraph(MGraph *G)
{
    printf("Please enter the number of vertexes and edges : ");
    scanf("%d %d", &G->numVertexes, &G->numEdges);

    for (int i = 0; i < G->numVertexes; i++)
    {
        getchar();
        scanf("%c", &G->vexs[i]);
    }

    for (int i = 0; i < G->numVertexes; i++)
        for (int j = 0; j < G->numVertexes; j++)
            G->arc[i][j] = INFINITY;
    int i, j, w;

    for (int k = 0; k < G->numEdges; k++)
    {
        printf("输入边（vi，vj）上的两个下标以及权值：");   //赋权值为 1 ，代表两顶点能形成边
        scanf("%d %d %d", &i, &j, &w);
        G->arc[i][j] = w;
        G->arc[j][i] = G->arc[i][j];   //此处是无向图的步骤，若是有向图可省略该行
    }
}

void DFS(MGraph G, int i)
{
    //先打印顶点
    printf("%c ", G.vexs[i]);
    //标记访问过
    visited[i] = true;

    //开始深度遍历
    for (int j = 0; j < G.numVertexes; j++)
    {
        //寻找未访问过的邻接顶点
        if (!visited[j] && G.arc[i][j] == 1)
        {
            DFS(G, j);
        }
    }
}

void DFSTraverse(MGraph G)
{
    //将顶点全部标记为未访问
    for (int i = 0; i < G.numVertexes; i++)
    {
        visited[i] = false;
    }

    for (int i = 0; i < G.numVertexes; i++)
    {
        if (!visited[i])       //对于连通图来说一遍就可以
        {
            DFS(G, i);
        }
    }
}

void BFSTraverse(MGraph G)
{
    int i, j;
    LinkQueue Q;
    //初始化标记顶点
    for (i = 0; i < G.numVertexes; i++)
    {
        visited[i] = false;
    }

    init_Queue(&Q);

    for (i = 0; i < G.numVertexes; i++)
    {
        if (!visited[i])
        {
            visited[i] = true;
            printf("%c ", G.vexs[i]);
            EnQueue(&Q, i);
            while(!isEmpty(Q))
            {
                DeQueue(&Q, &i);  //若该顶点未访问过，取出给i
                for (j = 0; j < G.numVertexes; j++)
                {
                    //找出顶点i的所有未访问过的邻接点
                    if (!visited[j] && G.arc[i][j] == 1)
                    {
                        visited[j] = true;
                        printf("%c ", G.vexs[j]);
                        EnQueue(&Q, j);
                    }
                }
            }
        }
    }

}

int main()
{
    MGraph G;
    CreateMGraph(&G);

    //深度遍历
    DFSTraverse(G);

    //广度遍历
    BFSTraverse(G);

    return 0;
}

图的邻接表的两种遍历

#include <stdio.h>
#include <stdlib.h>

typedef char VertexType;     //顶点类型    vertex type
typedef int  EdgeType;       //边上的权值类型  weight type on edge
#define MAXVEX  100          //最大顶点数        Maximum vertex
typedef struct EdgeNode      //edge table node  边表结点
{
    int agjvex;              //邻接表域，存储下标    Adjacent table domains are used to store subscripts
    EdgeType weight;         //用于存储权值          storage weight
    struct EdgeNode *next;
}EdgeNode;

typedef struct VertexNode    //顶点表结点        vertex table node
{
    VertexType data;        //存储顶点信息       storage vertex information
    EdgeNode *firstedge;    //边表头节点         edge table header node
}VertexNode, AdjList[MAXVEX];

typedef struct
{
    AdjList adjList;
    int numVertexes;         //图中顶点数   Number of vertices in the figure
    int numEdges;           //图中边数
}GraphAdjList;

typedef int QElemType;

typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}QNode, *Queue;
typedef struct
{
    Queue Front;
    Queue Rear;
}LinkQueue;

bool visited[MAXVEX];

void init_Queue(LinkQueue *Q)
{
    Q->Front = (Queue)malloc(sizeof(QNode));
    if (!Q->Front)
    {
        printf("The memory allocation failed ! Queue initialization falied! \n");
        exit(0);
    }
    Q->Rear = Q->Front;
    Q->Front->next = NULL;
}

void EnQueue(LinkQueue *Q, int value)
{
    Queue qNew = (Queue)malloc(sizeof(QNode));
    if (!qNew)
    {
        printf("The memory allocation failed!Element can not enter queue!\n");
        exit(0);
    }
    qNew->data = value;
    qNew->next = NULL;
    Q->Rear->next = qNew;
    Q->Rear = qNew;
}

void DeQueue(LinkQueue *Q, int *value)
{
    Queue q;
    if (Q->Front == Q->Rear)
    {
        printf("The queue is empty!\n");
        exit(0);
    }

    q = Q->Front->next;
    *value = q->data;
    Q->Front->next = q->next;

    if (Q->Rear == q)
    {
        Q->Rear = Q->Front;
    }
    free(q);
    q = NULL;
}

bool isEmpty(LinkQueue Q)
{
    if (Q.Front == Q.Rear)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void create_Graph(GraphAdjList *G)
{
    int i, j;
    EdgeNode *e;
    printf("Please enter the number of vertexes and edges : ");
    scanf("%d %d", &G->numVertexes, &G->numEdges);
    for (i = 0; i < G->numVertexes; i++)
    {
        getchar();
        //输入顶点信息
        scanf("%c", &G->adjList[i].data);
        //将边表置空  Place the edge table as an empty table
        G->adjList[i].firstedge = NULL;
    }

    for (int k = 0; k < G->numEdges; k++)    //Build edge table
    {
        printf("Please enter vertex serial number on the edge like (vi, vj)  ：");
        scanf("%d %d", &i, &j);
        e = (EdgeNode *)malloc(sizeof(EdgeNode));
        e->agjvex = j;
        e->next = G->adjList[i].firstedge;
        G->adjList[i].firstedge = e;

        //由于无向图存在对称性
        e = (EdgeNode *)malloc(sizeof(EdgeNode));
        e->agjvex = i;
        e->next = G->adjList[j].firstedge;
        G->adjList[j].firstedge = e;
    }
}

void DFS(GraphAdjList G, int i)
{
    visited[i] = true;
    printf("%c ", G.adjList[i].data);
    EdgeNode *p;

    p = G.adjList[i].firstedge;
    //此时访问邻接顶点   Accessing adjacent vertices
    while(p)
    {

        if (!visited[p->agjvex])
        {
            //进行深度遍历
            DFS(G, p->agjvex);
        }
        p = p->next;
    }
}

void DFSTraverse(GraphAdjList G)
{
    for (int i = 0; i < G.numVertexes; i++)
    {
        //false 表示顶点未访问过    False indicates that the vertex has not been accessed
        visited[i] = false;
    }

    for (int i = 0; i < G.numVertexes; i++)
    {
        //For connectivity diagram, DFS be used only one. Non-connected diagrams are used more than one.
        //连通图只调用一次。非连通图不止一次
        if (!visited[i])
        {
            DFS(G, i);
        }
    }
}

void BFSTraverse(GraphAdjList G)
{
    int i;
    EdgeNode *p;
    LinkQueue Q;

    for (i = 0; i < G.numVertexes; i++)
    {
        visited[i] = false;
    }

    init_Queue(&Q);

    for (i = 0; i < G.numVertexes; i++)
    {
        if (!visited[i])
        {
            visited[i] = true;
            printf("%c ", G.adjList[i].data);
            EnQueue(&Q, i);
            while(!isEmpty(Q))
            {
                DeQueue(&Q, &i);
                p = G.adjList[i].firstedge;
                while(p)
                {
                    if (!visited[p->agjvex])
                    {
                        visited[p->agjvex] = true;
                        printf("%c ", G.adjList[p->agjvex].data);
                        EnQueue(&Q, p->agjvex);
                    }
                    p = p->next;
                }
            }
        }
    }
}

int main()
{
    GraphAdjList G;
    create_Graph(&G);

    //深度遍历
    DFSTraverse(G);

    //广度遍历
    BFSTraverse(G);

    return 0;
}
mrHeis
关注
  • 2
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的邻接矩阵存储及遍历操作
qq_45917176的博客
07-05 1万+
数据结构--图的邻接矩阵存储及遍历操作
数据结构实验7---- 图的两种遍历方法及对应的生成树
qq_60737285的博客
07-16 1052
其中，深度优先遍历通过递归或栈实现，它会遍历图中所有的节点，并将它们标记为已经访问过，但并没有记录节点间的关系；广度优先遍历则通过队列实现，它同样会遍历图中所有的节点，但会先访问距离起始节点近的节点，并记录节点间的关系。本次实验通过深度优先生成树和广度优先生成树的实现，可以建立起基于图的树结构，便于对图的结构进行理解和处理。在实现本算法之前，我们需要图的基本运算算法和图的存储算法：本次用到的是邻接表类型存储的图并且添加了创建图的邻接表、输出图的邻接表、销毁图的邻接表等算法。图的两种遍历方法及对应的生成树。
数据结构图的创建和遍历（dfs,bfs，附代码）
whcwhc111111的博客
04-30 496
图的邻接矩阵，邻接表存储，dfs递归非递归，bfs
【数据结构实验四】- 图的存储和遍历 - （无向图、有向图，深度优先、广度优先遍历）
m0_46233342的博客
03-04 8892
文章目录一、实验题目：二、实验目的：三、实验内容：1.建立无向图的邻接矩阵存储结构，进行深度优先遍历和广度优先遍历。程序代码：2.建立有向图的邻接表存储结构，进行深度优先遍历和广度优先遍历。程序代码：四、实验心得体会 实验四 一、实验题目： 图的存储和遍历 二、实验目的： ⑴ 掌握图的逻辑结构； ⑵ 掌握图的邻接矩阵存储结构和图的邻接表存储结构； ⑶ 验证图的邻接矩阵存储和邻接表的存储以及深度优先遍历和广度优先遍历操作的实现。 三、实验内容： （1）建立无向图的邻接矩阵存储； （2）对建立的无向图，进行深
【数据结构】图的深度遍历与广度遍历
流星雨的博客
03-23 6973
图是一种常见的数据格式，它的遍历主要分为两种： 深度优先遍历(DFS):类似于二叉树的前序前序遍历 广度优先遍历(BFS):类似于二叉树的层次遍历 一、出度与入度 在讲图的遍历之前，我们需要先了解图的数据结构。 对于图，我们一般定义横向是出度，纵向是入度。比如对于左图我们转成领接矩阵如右图 这里我们构建一个图的数据结构Graph，顺序遍历二维数组matrix的index[0]、index[1]、index[2]···获取出度。同理顺序遍历[0]index···获取入度。用java实现如下： p.
图的深度遍历与广度遍历（JAVA实现）
weixin_43589025的博客
05-30 328
为什么要有图？ （1）线性表局限于一个直接前驱和一个直接后继的关系 （2）树也只有一个直接前驱也就是父节点 （3）当我们需要表示多对多关系时，就需要用到了图 概念： 表示方式: （1）二维数组（邻接矩阵） （2）链表表示（邻接表） 邻接表： （1）邻接矩阵需要为每个顶点都分配n个边的空间，其实很多边都是不存在，会造成空间的一定的损失 （2）邻接表的实现只关心存在的边，不关心不存在的边，因此没有空间浪费，由链表+数组组成。 深度优先遍历 深度优先遍历（Depth First Search）： （1）
数据结构之图的表示、深度优先和广度优先遍历.zip
06-21
在这个"数据结构之图的表示、深度优先和广度优先遍历.zip"压缩包中，我们重点探讨的是图这一重要的数据结构，以及如何通过邻接矩阵和邻接表来表示它，以及如何进行深度优先遍历（DFS）和广度优先遍历（BFS）。...
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
两种常见的遍历方法是深度优先遍历（Depth-First Search, DFS）和广度优先遍历（Breadth-First Search, BFS）。在JavaScript中，我们可以使用递归或非递归的方法来实现这两种遍历。 1. **深度优先遍历**： 深度...
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
无向图建立、深度优先遍历和广度优先遍历实现算法 本文将详细介绍无向图的建立、深度优先遍历和广度优先遍历的实现算法。这些算法是数据结构中非常重要的内容，掌握它们对后续学习和应用非常重要。 一、无向图的...
数据结构 图的深度优先遍历和广度优先遍历 .zip
最新发布
06-19
图的遍历是理解和操作图的关键技术，主要分为深度优先遍历（DFS, Depth-First Search）和广度优先遍历（BFS, Breadth-First Search）两种策略。 深度优先遍历是一种递归的遍历方法，它的基本思想是从起点开始，尽...
java 实现图 的深度遍历和广度遍历
taizhen/blog
12-10 742
package demo5; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Queue; import java.util.Set; public class test1
图
weixin_42393293的博客
10-20 109
图
数据结构——图的两种遍历方法
Joshua Lee的博客
12-24 1万+
遍历定义：从已给的图中某一顶点出发，沿着一些边，访遍图中所有的顶点，且使每个顶点仅被访问一次，就叫做图的遍历。 遍历实质：找每个顶点的邻接点的过程。 图的特点：图中可能存在回路，且图的任一顶点都可能与其它顶点相通，在访问完某个顶点之后可能会沿着某些边又回到了曾经         访问过的顶点。 解决思路：可设置一个辅助数组 visited [n ]，用来标记每个被访问过的顶点。它的初始状态为...
数据结构学习笔记——图的遍历算法（深度优先搜索和广度优先搜索）
热门推荐
小宇y的博客
08-18 3万+
若通过邻接表表示图，则每个顶点都入队一次，即所需时间为O(|V|)，搜索顶点的邻接顶点所需时间为O(|E|)，其时间复杂度为O(|V|+|E|)。若通过邻接表表示图，则查找所有顶点的邻接顶点所需时间为O(|E|)，访问顶点所需时间为O(|V|)，即总时间复杂度为O(|V|+|E|)。4、查看V7单链表，其邻接顶点为2，即V3，它已经被访问过，于是回到V3单链表，搜索下一个未被访问的邻接顶点；11、查看V8单链表，其邻接顶点为4，即V5，已经被访问过，于是回到V5单链表，搜索下一个未被访问的邻接顶点；....
图的深度优先遍历（DFS）和 广度优先遍历（BFS）
zyx_bx的博客
04-27 2358
图的深度优先遍历（DFS） 1、深度优先搜索遍历过程 图的深度优先搜索(Depth First Search)，和树的先序遍历比较类似。 它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。 显然，深度优先搜索是一个递归的过程 深度优先遍历特点是，选定一个出发点后进
大话数据结构---（六）图的深度优先遍历和广度优先遍历
松落
03-30 1万+
我们已经掌握了如何存储图中的信息，即邻接矩阵，邻接表，十字链表等。那么我们该如何利用这些存储结构中的数据呢，或者说我该如何找到我想要的数据呢，这里我们就得学会如何遍历图结构，而接下来会和大家介绍两种常用的遍历方法，深度优先遍历和广度优先遍历。
图的基本概念表示方法以及两种搜索方式——深度优先遍历和广度优先遍历
不要总是等明天再开始
06-10 1万+
原先的知识没好好学，导致现在很多都忘了，或者说以前就没弄懂过。现在重新看一遍，收获良多，不管怎样先写这篇基础的，当做笔记。 图的定义：是由顶点的有穷非空集合和顶点之间的边的集合组成的，通常表示为 G（V,E）。其中G表示一个图，V是图的顶点的集合，E是图的边的集合。 有跟多条边的图我们称为稠密图，很少条边的我们称为稀疏图。 有向图和无向图： 无向图：顶点之间的边是没有方向的，也就是两个
图的深度优先遍历(DFS)和广度优先遍历(BFS)算法分析
weixin_30480075的博客
01-19 275
1. 深度优先遍历 　　深度优先遍历(Depth First Search)的主要思想是： 　　　　1、首先以一个未被访问过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点； 　　　　2、当没有未访问过的顶点时，则回到上一个顶点，继续试探别的顶点，直至所有的顶点都被访问过。 　　　在此我想用一句话来形容 “不到南墙不回头”。 　　1.1　无向图的深度优先遍历图解 以下"无向图...
图：图的邻接矩阵创建、深度优先遍历和广度优先遍历详解
重庆李四
02-20 9794
邻接矩阵介绍直接说，邻接矩阵是图的一种存储结构。那么图是什么呢？图是一种逻辑结构，和线性结构、树形结构、集合结构一样 是一种逻辑结构用来描述数据对象中的数据元素之间的关系。来看下图的定义：图（Graph）是有顶点的有穷非空集和顶点之间边的集合组成，通常表示为G（V，E）其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。考虑到图是有顶点和边或弧2部分组成。合在一起比较困难，那就自然的考虑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值