【笔记】图的遍历

最新推荐文章于 2023-04-06 11:25:08 发布
最新推荐文章于 2023-04-06 11:25:08 发布
阅读量889 收藏 3
点赞数 4
分类专栏： 数据结构 数据结构 文章标签： 图的遍历 深度优先搜索 广度优先搜索 深度优先遍历 广度优先遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cbwem/article/details/78682523
版权

  从图中某一个顶点出发，访问图中的所有顶点，且使每个顶点被访问一次且仅被访问一次，称为图的遍历（搜索）。图的遍历方式主要有深度优先搜索和广度优先搜索两种。

1.图的深度优先搜索的概念

  图的深度优先搜索遍历类似于树的先根遍历，是树的先根遍历的推广。

  算法思想：假设初始状态是图中所有顶点未曾被访问，从图中某个顶点 v0 出发，访问顶点 v0 ，然后一次从 v0 的未被访问的邻接点出发深度优先遍历图，直至图中所有和 v0 有路径相通的顶点都被访问到；若此时图中还有顶点未被访问，呃另选图中一个未被访问的顶点作为起始点，重复执行上述过程，直到图中所有的顶点都被访问过。

  图的深度优先搜索遍历过程如下所示，实箭头表示访问顶点的方向，虚箭头表示回溯，数字表示访问或回溯的次序。


这里写图片描述

  在图的深度优先搜索遍历过程中，图中可能存在回路，因此在访问某个顶点之后，沿着某条路径遍历，有可能又回到该顶点。为了避免再次访问已经访问过的顶点，需要设置一个数组visited[n]，作为一个标志记录结点是否访问过，其初值为0，一旦某个顶点被访问，则其相应的分量被置为1。

2.图的深度优先搜索的实现

  如果该图是一个无向连通图或者一个强连通图，则只需要调用一次DFS(G,v)就可以遍历整个图，否则需要多次调用DFS(G,v)。在遍历图时，对图中的每个顶点至多调用一次DFS(G,v)函数，因为一旦某个顶点被标志为已被访问，就不再从它出发进行搜索。因此遍历图的过程实质上是对每个顶点查找其邻接点的过程。其时间耗费取决于所采用的存储结构。当用二维数组表示邻接矩阵作为图时的存储结构时，查找每个顶点的邻接点所需时间为 O(n2) ，其中n为图中的顶点数。当以邻接表作为图的存储结构时，查找邻接点的时间为 O(e) ，其中，e为无向图边的顶点数目或有向图弧的数目。由此当以邻接表作为存储结构时，深度优先搜索遍历图的时间复杂度为 O(n+e) 。

  • 非递归深度优先遍历算法
int DFSTraverse(AdjGraph G,int v)
/*图的非递归深度优先遍历*/
{
    int i,visited[MaxSize],top;
    ArcNode *stack[MaxSize],*p;
    for(i=0;i<G.vexnum;i++)         /*将所有顶点都添加未访问标志*/
        visited[i]=0;
    Visit(G.vertex[v].data);        /*访问顶点v并将访问标志置为1，表示已经访问*/
    visited[v]=1;
    top=-1;                         /*初始化栈*/
    p=G.vertex[v].firstarc;         /*p指向顶点v的第一个邻接点*/
    while(top>-1||p!=NULL)
    {
        while(p!=NULL)
            if(visited[p->adjvex]==1)/*如果p指向的顶点已经访问过，则p指向下一个邻接点*/
                p=p->nextarc;
            else
            {
                Visit(G.vertex[p->adjvex].data);    /*访问p指向的顶点*/
                visited[p->adjvex]=1;
                stack[++top]=p;     /*保存p指向的顶点*/
                p=G.vertex[p->adjvex].firstarc;/*p指向当前顶点的第一个邻接点*/
            }
        if(top>-1)
        {
            p=stack[top--];         /*如果当前顶点都已经被访问，则退栈*/
            p=p->nextarc;           /*p指向下一个邻接点*/
        }
    }
}
  • 递归深度优先遍历算法
void DFSTraverse2(AdjGraph G)
/*从第1个顶点起，深度优先遍历图G*/
{
    int v;
    for(v=0;v<G.vexnum;v++)
        visited[v]=0;       /*访问标志数组初始化为未被访问*/
    for(v=0;v<G.vexnum;v++)
        if(!visited[v])
            DFS2(G,v);      /*对未访问的顶点v进行深度优先遍历*/
    printf("\n");
}
void DFS2(AdjGraph G,int v)
/*从顶点v出发递归深度优先遍历图G*/
{
    ArcNode *p;
    visited[v]=1;               /*访问标志设置为已访问*/
    Visit(G.vertex[v].data);    /*访问第v个顶点 */
    p=G.vertex[v].firstarc;     /*取v的边表头指针，p指向v的邻接点 */
    while(p)
    /*依次搜索v的邻接点 */
    {
        if(!visited[p->adjvex]) /*若v未被访问 */
            DFS(G,p->adjvex);   /*以v的邻接点纵深搜索 */
        p=p->nextarc;           /*找v的下一个邻接点*/
    }
}

3.图的广度优先搜索的概念

  图的广度优先搜索遍历类似于树的层次遍历过程。

  算法思想：从图的某个顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问他们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的邻接点”被访问，直至图中所有一斤访问的顶点的邻接点都被访问到；若此时图中还有顶点未被访问，则另选图中一个未曾被访问的顶点作为起始点，重复上述过程，直至图中的所有顶点都被访问到为止。


这里写图片描述

4.图的广度优先搜索的实现

  域深度优先搜索遍历类似，在图的广度优先搜索遍历过程中也需要一个访问标致数组visited[MaxSize]，用来表示顶点是否被访问过。初始时，将图中的所有顶点的标志数组 visited[vi] 都初始化为0，表示顶点未被访问。从第一个顶点 v0 出发，访问该顶点并将标志数组置为1；然后将 v0 入队，当队列不为空时，将队头元素出队，依次访问该顶点的所有邻接点，同时将标志数组对应位置设为1，并将其邻接点依次入队。依此类推，直到图中所有顶点都已被访问过。

  设图的顶点个数为n，边的数目为e，则采用邻接表实现图的广度优先遍历的时间复杂度为 O(n+e) 。图的深度优先遍历和广度优先遍历的结果并不是唯一的，这主要与图的存储结点的位置有关。

void BFSTraverse(AdjGraph G)
/*从第1个顶点出发，按非递归广度优先遍历图G*/
{
    int v,u,w,front,rear;
    ArcNode *p;
    int queue[MaxSize];             /*定义一个队列Q*/
    front=rear=-1;                  /*初始化队列Q*/
    for(v=0;v<G.vexnum;v++)         /*初始化标志位*/
        visited[v]=0;
    v=0;
    visited[v]=1;                   /*设置访问标志为1，表示已经被访问过*/
    Visit(G.vertex[v].data);
    rear=(rear+1)%MaxSize;
    queue[rear]=v;                  /*v入队列*/
    while(front<rear)               /*如果队列不空*/
    {
        front=(front+1)%MaxSize;
        v=queue[front];             /*队头元素出队赋值给v*/
        p=G.vertex[v].firstarc;
        while(p!=NULL)              /*遍历序号为v的所有邻接点*/
        {
            if(visited[p->adjvex]==0)/*如果该顶点未被访问过*/
            {
                visited[p->adjvex]=1;
                Visit(G.vertex[p->adjvex].data);
                rear=(rear+1)%MaxSize;
                queue[rear]=p->adjvex;
            }
            p=p->nextarc;           /*p指向下一个邻接点*/
        }
    }
}

5.图的遍历算法源码

  • 类型定义
/*图的邻接表*/
typedef char VertexType[4];
typedef char InfoPtr;
typedef int VRType;
#define MaxSize 50              /*最大顶点个数*/
typedef enum{DG,DN,UG,UN}GraphKind;     /*图的类型：有向图、有向网、无向图和无向网*/
typedef struct ArcNode          /*边结点的类型定义*/
{
    int adjvex;                 /*弧指向的顶点的位置*/
    InfoPtr *info;              /*与弧相关的信息*/
    struct ArcNode *nextarc;    /*指示下一个与该顶点相邻接的顶点*/
}ArcNode;
typedef struct VNode            /*头结点的类型定义*/
{
    VertexType data;            /*用于存储顶点*/
    ArcNode *firstarc;          /*指示第一个与该顶点邻接的顶点*/
}VNode,AdjList[MaxSize];
typedef struct                  /*图的类型定义*/
{
    AdjList vertex;
    int vexnum,arcnum;          /*图的顶点数目与弧的数目*/
    GraphKind kind;             /*图的类型*/
}AdjGraph;
  • 函数文件
int visited[MaxSize]; /* 访问标志数组*/
int DFSTraverse(AdjGraph G,int v)
/*图的非递归深度优先遍历*/
{
    int i,visited[MaxSize],top;
    ArcNode *stack[MaxSize],*p;
    for(i=0;i<G.vexnum;i++)         /*将所有顶点都添加未访问标志*/
        visited[i]=0;
    Visit(G.vertex[v].data);        /*访问顶点v并将访问标志置为1，表示已经访问*/
    visited[v]=1;
    top=-1;                         /*初始化栈*/
    p=G.vertex[v].firstarc;         /*p指向顶点v的第一个邻接点*/
    while(top>-1||p!=NULL)
    {
        while(p!=NULL)
            if(visited[p->adjvex]==1)/*如果p指向的顶点已经访问过，则p指向下一个邻接点*/
                p=p->nextarc;
            else
            {
                Visit(G.vertex[p->adjvex].data);    /*访问p指向的顶点*/
                visited[p->adjvex]=1;
                stack[++top]=p;     /*保存p指向的顶点*/
                p=G.vertex[p->adjvex].firstarc;/*p指向当前顶点的第一个邻接点*/
            }
        if(top>-1)
        {
            p=stack[top--];         /*如果当前顶点都已经被访问，则退栈*/
            p=p->nextarc;           /*p指向下一个邻接点*/
        }
    }
}


void DFSTraverse2(AdjGraph G)
/*从第1个顶点起，深度优先遍历图G*/
{
    int v;
    for(v=0;v<G.vexnum;v++)
        visited[v]=0;       /*访问标志数组初始化为未被访问*/
    for(v=0;v<G.vexnum;v++)
        if(!visited[v])
            DFS2(G,v);       /*对未访问的顶点v进行深度优先遍历*/
    printf("\n");
}
void DFS2(AdjGraph G,int v)
/*从顶点v出发递归深度优先遍历图G*/
{
    ArcNode *p;
    visited[v]=1;               /*访问标志设置为已访问*/
    Visit(G.vertex[v].data);    /*访问第v个顶点 */
    p=G.vertex[v].firstarc;     /*取v的边表头指针，p指向v的邻接点 */
    while(p)
    /*依次搜索v的邻接点 */
    {
        if(!visited[p->adjvex]) /*若v未被访问 */
            DFS2(G,p->adjvex);   /*以v的邻接点纵深搜索 */
        p=p->nextarc;           /*找v的下一个邻接点*/
    }
}

void BFSTraverse(AdjGraph G)
/*从第1个顶点出发，按广度优先非递归遍历图G*/
{
    int v,u,w,front,rear;
    ArcNode *p;
    int queue[MaxSize];             /*定义一个队列Q*/
    front=rear=-1;                  /*初始化队列Q*/
    for(v=0;v<G.vexnum;v++)         /*初始化标志位*/
        visited[v]=0;
    v=0;
    visited[v]=1;                   /*设置访问标志为1，表示已经被访问过*/
    Visit(G.vertex[v].data);
    rear=(rear+1)%MaxSize;
    queue[rear]=v;                  /*v入队列*/
    while(front<rear)               /*如果队列不空*/
    {
        front=(front+1)%MaxSize;
        v=queue[front];             /*队头元素出队赋值给v*/
        p=G.vertex[v].firstarc;
        while(p!=NULL)              /*遍历序号为v的所有邻接点*/
        {
            if(visited[p->adjvex]==0)/*如果该顶点未被访问过*/
            {
                visited[p->adjvex]=1;
                Visit(G.vertex[p->adjvex].data);
                rear=(rear+1)%MaxSize;
                queue[rear]=p->adjvex;
            }
            p=p->nextarc;           /*p指向下一个邻接点*/
        }
    }
}

int FirstAdjVertex(AdjGraph G,VertexType v)
/*返回顶点v的第一个邻接顶点的序号*/
{
    ArcNode *p;
    int v1;
    v1=LocateVertex(G,v);       /*v1为顶点v在图G中的序号*/
    p=G.vertex[v1].firstarc;
    if(p)                       /*如果顶点v的第一个邻接点存在，返回邻接点的序号，否则返回-1 */
        return p->adjvex;
    else
        return -1;
}
int NextAdjVertex(AdjGraph G,VertexType v,VertexType w)
/*返回v的相对于w的下一个邻接顶点的序号*/
{
    ArcNode *p,*next;
    int v1,w1;
    v1=LocateVertex(G,v);       /*v1为顶点v在图G中的序号*/
    w1=LocateVertex(G,w);       /*w1为顶点w在图G中的序号*/
    for(next=G.vertex[v1].firstarc;next;)
        if(next->adjvex!=w1)
            next=next->nextarc;
    p=next;                     /*p指向顶点v的邻接顶点w的结点*/
    if(!p||!p->nextarc)         /*如果w不存在或w是最后一个邻接点，则返回-1*/
        return -1;
    else
        return p->nextarc->adjvex;  /*返回v的相对于w的下一个邻接点的序号*/
}

int LocateVertex(AdjGraph G,VertexType v)
/*返回图中顶点对应的位置*/
{
    int i;
    for(i=0;i<G.vexnum;i++)
        if(strcmp(G.vertex[i].data,v)==0)
            return i;
        return -1;
}
void CreateGraph(AdjGraph *G)
/*采用邻接表存储结构，创建无向图G*/
{
    int i,j,k;
    VertexType v1,v2;               /*定义两个顶点v1和v2*/
    ArcNode *p;
    printf("请输入图的顶点数,边数(逗号分隔): ");
    scanf("%d,%d",&(*G).vexnum,&(*G).arcnum);
    printf("请输入%d个顶点的值:\n",G->vexnum);
    for(i=0;i<G->vexnum;i++)            /*将顶点存储在头结点中*/
    {
        scanf("%s",G->vertex[i].data);
        G->vertex[i].firstarc=NULL; /*将相关联的顶点置为空*/
    }
    printf("请输入弧尾和弧头(以空格作为间隔):\n");
    for(k=0;k<G->arcnum;k++)            /*建立边链表*/
    {
        scanf("%s%s",v1,v2);
        i=LocateVertex(*G,v1);
        j=LocateVertex(*G,v2);
        /*j为弧头i为弧尾创建邻接表*/
        p=(ArcNode*)malloc(sizeof(ArcNode));
        p->adjvex=j;
        p->info=NULL;
        p->nextarc=G->vertex[i].firstarc;
        G->vertex[i].firstarc=p;
        /*i为弧头j为弧尾创建邻接表*/
        p=(ArcNode*)malloc(sizeof(ArcNode));
        p->adjvex=i;
        p->info=NULL;
        p->nextarc=G->vertex[j].firstarc;
        G->vertex[j].firstarc=p;
    }
    (*G).kind=UG;
}
void DestroyGraph(AdjGraph *G)
/*销毁无向图G*/
{
    int i;
    ArcNode *p,*q;
    for(i=0;i<(*G).vexnum;++i)      /*释放图中的边表结点*/
    {
        p=G->vertex[i].firstarc;        /*p指向边表的第一个结点*/
        if(p!=NULL)                 /*如果边表不为空，则释放边表的结点*/
        {
            q=p->nextarc;
            free(p);
            p=q;
        }
    }
    (*G).vexnum=0;                  /*将顶点数置为0*/
    (*G).arcnum=0;                  /*将边的数目置为0*/
}
void Visit(VertexType v)
{
    printf("%s ",v);
}
  • 主程序
#include<stdlib.h>
#include<stdio.h>
#include<malloc.h>
#include<string.h>
void main()
{
    AdjGraph G;
    printf("采用邻接矩阵创建无向图G：\n");
    CreateGraph(&G);
    printf("图G的非递归深度优先遍历：");
    DFSTraverse(G,0);
    printf("\n");
    printf("图G的非递归广度优先遍历：");
    BFSTraverse(G);
    printf("\n");
    printf("图G的递归深度优先遍历：");
    DFSTraverse2(G);
    printf("\n");
    DestroyGraph(&G);
}
  • 测试结果


这里写图片描述

Time-space
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php学习笔记 数组遍历实现代码
01-20
复制代码 代码如下: <?php /* 数组的遍历 * * 1.使用for语句循环遍历数组 * 1.其他语言(只有这一种方式) * 2.PHP中这种方式不是首选的方式 * 3.数组必须是索引数组，而且下标必须是连续的。 * (索引数组下标可以不连续,数组还有关联数组,这两种不能遍历) * * 2.使用foreach语句循环遍历数组 * foreacho(数组变量 as 变量值){ * //循环体 * } * 1.循环次数由数组的元素个数决定 * 2.每一次循环都会将数组中的元素分别赋值给后面变量 * * foreach(数组变量 as 下标变量=> 值变量){ * } * * * 3.whil
Python的常见函数和用法
低吟浅笑
07-06 695
常见的python、numpy的用法，持续更新和记录。
图的遍历之广度优先搜索
yang20141109的专栏
10-13 1089
广度优先搜索遍历类似于树的按层次遍历的过程。假设从图中某个顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使用”先被访问的顶点的邻接点“先于”后被访问的顶点的邻接点“被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则选图中一个未被访问的节点作为起始点，重复上述过程，直至图中所有顶点都被访问到为止。若用邻
广度优先搜索（BFS）
09-24 1739
广度优先搜索（Breadth First Search , BFS）遍历类似于树的按层次遍历的过程，则是以广度为第一关键词，当碰到岔道口时，总是先依次访问从该岔道口能直接到达的所有结点，然后再按这些结点被访问的顺序去依次访问它们能直接到达的所有结点，以此类推，直到所有结点都被访问为止。 广度优先搜索的整个算法过程很像一个队列，因此，广度优先搜索（Breadth First Search , BF...
深度遍历和广度遍历（函数）
，，，，，，，，，的博客
05-14 1167
图的深度遍历-邻接矩阵实现 MGraph是邻接矩阵存储的图，定义如下： #define MaxVertexNum 10 /*定义最大顶点数*/ typedef int Vertex;/* 用顶点下标表示顶点,为整型 */ typedef struct{ int arcs[MaxVertexNum][MaxVertexNum]; /*邻接矩阵*/ int vexnum,arcnum; /...
图的遍历笔记1
guicaifjz的博客
02-02 93
图图的概念有向图和无向图形式化定义图度度的性质判断序列是否可图 图的概念 什么是图？ 图是由一系列顶点和若干连结顶点集合内两个顶点的边组成的数据结构。 有向图和无向图 如果用边来表示好友关系，对于微信这种双向关注的社交网络没有问题，但是对于微博这种单向的关注如何表示？ 于是引出了两个新的概念：有向边和无向边 简而言之，一条有向边必然是从一个点指向另一个点，而相反方向的边在有向图中则不一定存在，而有的时候我们并不在意构成一条边的两个顶点具体谁先谁后，这样得到的一条边就是无向边。就像在微信中，A是B的好友，那B
数据结构 笔记：图的遍历（BFS）
Qiuery的博客
11-29 221
时间复杂度的对比分析   MatrixGraph ListGraph addVertex - O(n) removeVertex - O(n^2) getVertex O(1) O(n) setVertex O(1) O(n) getAdjacent O(n) O(n) getEdge O(1)...
[算法笔记]图的遍历
RegulusF的博客
09-03 142
一：深度优先遍历（DFS） 每次沿着路径到不能再前进的时候才退回到最近的岔道口 每一次DFS过程可以遍历一个连通分量，遍历所有联通分量即遍历图 //邻接矩阵存储 const int maxv=10000; const int INF=1000000000; bool vis[maxv]={false}; int n,G[maxv][maxv]; void DFS(int u,int depth){...
学习笔记（四）图的遍历
这里是两只喜欢代码的电路狗。
04-24 596
图的遍历有两种遍历方式：深度优先遍历(depth-first search)和广度优先遍历(breadth-first search)。 DFS通常使用递归实现，BFS通常使用队列实现。图的遍历是树的遍历的推广，是按照某种规则(或次序)访问图中各顶点依次且仅一次的操作，亦是将网络结构按某种规则线性化的过程。 1.DFS 基本思想： 首先从图中某个顶点v0出发，访问此顶点，然后依次从v0相邻
数据结构 6.28知识点 图的遍历、存储结构
wuwndj的博客
06-29 383
图的基本概念 路径长度是指路径相同，则这上边或弧的数目。 若第一个顶点和最后一个顶点条路径是一条回路，也叫做 环。 若路径中顶点没有重复出现，则称这条路径为 简单路径。 在无向图中，如果从顶点vi到顶点vj有路径，则称vi和vj连通。如果图中任意两个顶点之间都连通，则称该图为连通图，否则，将其中的极大连通子图称为连通分量。 生成树、生成森林概念： 结论：完全树一定是生成树，反之不成立。 图的存储结构 1、邻接矩阵存储 2、邻接表 每个单链表上添加一个表头结点（表示顶点信息）。并将所有表头结点构成一个
Javascript学习笔记之数组的遍历和 length 属性
01-21
尽管数组在 Javascript 中是对象，但是不建议使用 for in 循环来遍历数组，实际上，有很多理由来阻止我们对数组使用 for in 循环。 因为 for in 循环将会枚举原型链上的所有属性，并且唯一阻止的方法是使用 ...
chap 7 图（判断+单选）
寒舟不渡的博客
12-08 4955
判断题 1-1 无向连通图至少有一个顶点的度为1。 (1分)F 1-2 用邻接表法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。 (1分)F 1-3 用邻接矩阵法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。 (1分)T 1-4 在一个有向图中，所有顶点的入度与出度之和等于所有边之和的2倍。 (1分)T 1-5 在任一有向图中，所有顶点的入度之和等于...
249. Group Shifted Strings
dihuangxiu8828的博客
06-29 93
问题描述： Given a string, we can "shift" each of its letter to its successive letter, for example:"abc" -> "bcd". We can keep "shifting" which forms the sequence: "abc" -> "bcd" -> ... -&...
a的visited不起作用问题
nicexibeidage的博客
11-02 9356
visited问题 a:link{color:red} a:visited{color:blue} a:hover{color:yellow} a:active{color:pink} visited问题 在浏览器中访问这个代码时，会发现visited是不起作用的，这是因为链接无效会使a的visited设置无效, 这是因为链接点击后没有产生网页访问的历史记录, 所
279. 完全平方数（C语言）BFS总结
maryfei的博客
02-11 386
BFS 1.头结点入队，visited设置为1 2. 判断队列是否为空 3.根据队列大小，得出该层有多少元素，依次出队，访问 4.本题为求完全平方数的和，因此将层中的每个节点都与父节点相加，并且入队，且visited设为1。用step记录层数，next==n则返回。 int numSquares(int n) { int i, j, next, curr, size, step...
图及其遍历
weixin_40984271的博客
09-09 181
一些概念 · 图由顶点（Vertex）和边（Edge）组成，每条边的两端都必须是图的两个顶点 · 图可分为有向图和无向图，无向图的边都是双向的，可以当作正负向两条边组成 · 顶点的度是指和该顶点相连的边的条数。对于有向图来说，顶点的出边条数称为该定点的出度，入边条数则为入度 · 顶点和边的量化属性称为权值，点权和边权 图的存储 1.邻接矩阵 另二维数组G[N][N]的两维分别...
【数据结构9】-图的概念、遍历以及应用
渐渐的忘记，赶不上明天（读研ing，2024年毕业）
07-19 1377
文章目录1. 图的基本概念1.1 定义1.2 无向图与有向图1.3 度1.4 点到点的关系1.5 图的局部1.5.1 子图 1. 图的基本概念 1.1 定义 1.2 无向图与有向图 1.3 度 1.4 点到点的关系 1.5 图的局部 1.5.1 子图 有向图的子图和无向图的子图定义一样。 ...
图的定义、存储及遍历（算法笔记）
Arabot_的博客
04-06 569
图，直观来理解就是地图，是一种逻辑结构为非线性的数据结构，是一种多对多的数据结构，每一个顶点都可以作为起点和终点，将图拆分开就是由若干棵树构成的森林。1.图的定义：图由顶点和边构成，每条边的两个端点必须是图的两个顶点，采用G（V，E）表示图G的顶点集为V、边集为E。一般来说，图可分为有向图和无向图。有向图的所有边都有方向，即确定了顶点到顶点的一个指向：而无向图的所有边都是双向的，即无向边所连接的两个顶点可以互相到达。
qstringlist遍历
最新发布
07-27
QStringList的遍历可以使用多种方式。一种常见的方式是使用迭代器进行遍历。可以使用QList的迭代器来遍历QStringList，例如使用for循环遍历迭代器，将每个元素添加到另一个列表中。\[1\]另一种方式是使用foreach循环，直接遍历QStringList中的每个元素并进行操作。\[2\]还可以使用STL风格的迭代器来遍历QStringList。\[2\]在遍历过程中，可以使用Qt::CaseSensitivity来指定是否区分大小写。例如，可以使用contains函数来检查字符串是否包含指定的字符，并使用Qt::CaseInsensitive来表示不区分大小写。\[3\] #### 引用[.reference_title] - *1* *3* [QT笔记10--匹配大小写、QStringList遍历](https://blog.csdn.net/GENGXINGGUANG/article/details/107344835)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [QStringList](https://blog.csdn.net/lfnlook/article/details/129160135)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值