对于图的遍历的四种问题

最新推荐文章于 2024-08-09 16:35:49 发布
最新推荐文章于 2024-08-09 16:35:49 发布
阅读量4.1k 收藏 2
点赞数 1
分类专栏： Algorithm and Data Structure 文章标签： struct input null c 图形
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongweijin/article/details/203098
版权

图建立，输入示例：
input the number for vexnum and arcnum:8 9

input8char for vexs(use -enter- to change):a
b
c
d
e
f
g
h

input9arc(char -enter- char -enter- weigh):
0:a
b
11

1:a
c
11

2:b
d
11

3:b
e
11

4:d
h
23

5:e
h
11

6:c
f
11

7:c
g
11

8:f
g
11

遍历建立的矩阵：
88 11 11 88 88 88 88 88
11 88 88 11 11 88 88 88
11 88 88 88 88 11 11 88
88 11 88 88 88 88 88 23
88 11 88 88 88 88 88 11
88 88 11 88 88 88 11 88
88 88 11 88 88 11 88 88
88 88 88 23 11 88 88 88
遍历的结果：
a
b
d
h
e
c
f
g
(邻接矩阵图深度遍历结果)

实际图形示例：
                                                                
                                a

                      b                    c

              d            e          f ------g

                      h 
                  (其他是上下连起)
代码：

邻接表图的广度遍历


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

#define INFINITY INT_MAX
#define MAX_VERTEX_NUM 20

#define MAXQSIZE 10 //最大队列长度
#define FALSE  0
#define TRUE  1

typedef int VRType;
typedef char VertexType;
typedef int Status;
typedef int  QElemType; 

typedef struct
{
 QElemType *base;
 int  front;
 int  rear;
} SqQueue;

typedef struct ArcNode
{
 int adjvex;
 struct ArcNode *nextarc;
}ArcNode;

typedef struct VNode
{
 VertexType data;
 ArcNode *firstarc;
}VNode, AdjList[MAX_VERTEX_NUM];

typedef struct
{
 AdjList vertices;
 int vexnum, arcnum;
}ALGraph;

bool visited[MAX_VERTEX_NUM];
Status (*VisitFunc)(int v);
int w;

void CreateGraph(ALGraph &G);
void BFSTraverse(ALGraph G, Status (*Visit)(int v));
Status printGraph(int v);
int FirstAdjVex(ALGraph G, int v);
int NextAdjVex(ALGraph G, int v, int w);

Status InitQueue(SqQueue &);
Status EnQueue(SqQueue &, QElemType);
Status DeQueue(SqQueue &, QElemType &);
Status  QueueEmpty(SqQueue);


void main( void )
{

 int i;
 ALGraph G;
 ArcNode *p;
 
 CreateGraph(G);

 for(i= 0; i < G.vexnum; i++)
 {
  cout<<i<<"   "<<G.vertices[i].data;
  p = G.vertices[i].firstarc;
  while(p != NULL)
  {
   cout<<"--->";
   cout<<(G.vertices[p->adjvex].data);
   p = p->nextarc;   
  }
  cout<<endl;
 }
 BFSTraverse(G, printGraph);
}
void CreateGraph(ALGraph &G)
{
 int i, j = 0, k = 0;
 char hand, tide;
 ArcNode *p;
 
 cout<<"input the number for vexnum and arcnum:";
 cin>>G.vexnum>>G.arcnum;
 cout<<endl;
 cout<<"input"<<G.vexnum<<"char for vexs:";
 for(i=0; i < G.vexnum; i++)
  cin>>G.vertices[i].data;
 cout<<endl;
 for(i=0;i<G.vexnum;++i)
  G.vertices[i].firstarc=NULL;
 cout<<"input"<<G.arcnum<<"arc(char-enter-char):"<<endl;
 j = 0;
 k = 0;
 for(i=0; i < G.arcnum; i++)
 {
  cout<<i<<":";
  cin>>hand;
  cin>>tide;
  while (hand != G.vertices[j].data)
   j++;
  while (tide != G.vertices[k].data)
   k++;
  p=new ArcNode;
  p->adjvex=j;
  p->nextarc=G.vertices[j].firstarc;
  G.vertices[k].firstarc=p;
  p=new ArcNode;
  p->adjvex=k;
  p->nextarc=G.vertices[j].firstarc;
  G.vertices[j].firstarc=p;
  
  j = 0;
  k = 0;
  cout<<endl;
 }
}

void BFSTraverse(ALGraph G, Status (*Visit)(int v))
{
 SqQueue  Q;
 QElemType   u;

 InitQueue(Q);

 for(int v=0; v < G.vexnum;++v)
  visited[v]=FALSE;
 for(v=0; v<G.vexnum;++v)
  if(!visited[v])
  {
   visited[v]=TRUE;
   EnQueue(Q, v);
   Visit(v);
   while(QueueEmpty(Q))
   {
    DeQueue(Q, u);
    for(w = FirstAdjVex(G, u); w; w = NextAdjVex(G, u, w))
     if(! visited[w])
     {
      visited[w]=TRUE;
      Visit(w);
      EnQueue(Q, w);
     }
   }
  }
}

int FirstAdjVex(ALGraph G, int v)
{
 ArcNode *p;
 p = G.vertices[v].firstarc;
 while(p != NULL)
 {
  if(visited[p->adjvex] != 1)
   return p->adjvex;
  p = p->nextarc;
 }
 return 0;
}

int NextAdjVex(ALGraph G, int v, int w)
{
 ArcNode *p;
 p = G.vertices[v].firstarc;
 while(p != NULL)
 {
  if(visited[p->adjvex] != 1 && p->adjvex != w)
   return p->adjvex;
  p = p->nextarc;
 }
 return 0;
}

Status printGraph(int v)
{
 printf("%c", v + 'a');
 cout<<endl;
 return 1;
}

Status InitQueue(SqQueue & queue)
{
 queue.base = (QElemType *) malloc(MAXQSIZE * sizeof(QElemType));
 
 if (!queue.base)
  return FALSE;
 queue.front = queue.rear = 0;

 return TRUE;
}

///
//
// 函数名       : EnQueue
// 功能描述     : 插入元素到队列
// 参数         : SqQueue &queue
// 参数         : QElemType element
// 返回值       : Status
//
///
Status EnQueue(SqQueue &queue, QElemType element)
{
 //先判断是不是没满的队列
 if ((queue.rear + 1)  % MAXQSIZE == queue.front)
  return FALSE;
 queue.base[queue.rear] = element;

 queue.rear = (queue.rear + 1) % MAXQSIZE;

 return TRUE;
}


///
//
// 函数名       : DeQueue
// 功能描述     : 删除队列的头结点
// 参数         : SqQueue &queue
// 参数         : QElemType &element
// 返回值       : Status
//
///
Status DeQueue(SqQueue &queue, QElemType &element)
{
 //判断队列是不是空的
 if (queue.front == queue.rear)
  return FALSE;
 element = queue.base[queue.front];
 queue.front = (queue.front + 1) % MAXQSIZE;
 
 return TRUE;
}

Status  QueueEmpty(SqQueue queue)
{
 if (queue.front == queue.rear)
  return FALSE;
 else
  return TRUE;

}

邻接表图的深度遍历

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

#define INFINITY INT_MAX
#define MAX_VERTEX_NUM 20

typedef int VRType;
typedef char VertexType;
typedef int Status;


typedef struct ArcNode
{
 int adjvex;
 struct ArcNode *nextarc;
}ArcNode;

typedef struct VNode
{
 VertexType data;
 ArcNode *firstarc;
}VNode, AdjList[MAX_VERTEX_NUM];

typedef struct
{
 AdjList vertices;
 int vexnum, arcnum;
}ALGraph;

bool visited[MAX_VERTEX_NUM];
Status (*VisitFunc)(int v);
int w;

void CreateGraph(ALGraph &G);
void DFSTraverse(ALGraph G, Status (*Visit)(int v));
Status printGraph(int v);
int FirstAdjVex(ALGraph G, int v);
int NextAdjVex(ALGraph G, int v, int w);
void DFS(ALGraph G, int v);


void main( void )
{

 int i;
 ALGraph G;
 ArcNode *p;
 
 CreateGraph(G);

 for(i= 0; i < G.vexnum; i++)
 {
  cout<<i<<"   "<<G.vertices[i].data;
  p = G.vertices[i].firstarc;
  while(p != NULL)
  {
   cout<<"--->";
   cout<<(G.vertices[p->adjvex].data);
   p = p->nextarc;   
  }
  cout<<endl;
 }
 DFSTraverse(G, printGraph);
}
void CreateGraph(ALGraph &G)
{
 int i, j = 0, k = 0;
 char hand, tide;
 ArcNode *p;
 
 cout<<"input the number for vexnum and arcnum:";
 cin>>G.vexnum>>G.arcnum;
 cout<<endl;
 cout<<"input"<<G.vexnum<<"char for vexs:";
 for(i=0; i < G.vexnum; i++)
  cin>>G.vertices[i].data;
 cout<<endl;
 for(i=0;i<G.vexnum;++i)
  G.vertices[i].firstarc=NULL;
 cout<<"input"<<G.arcnum<<"arc(char-enter-char):"<<endl;
 j = 0;
 k = 0;
 for(i=0; i < G.arcnum; i++)
 {
  cout<<i<<":";
  cin>>hand;
  cin>>tide;
  while (hand != G.vertices[j].data)
   j++;
  while (tide != G.vertices[k].data)
   k++;
  p=new ArcNode;
  p->adjvex=j;
  p->nextarc=G.vertices[j].firstarc;
  G.vertices[k].firstarc=p;
  p=new ArcNode;
  p->adjvex=k;
  p->nextarc=G.vertices[j].firstarc;
  G.vertices[j].firstarc=p;
  
  j = 0;
  k = 0;
  cout<<endl;
 }
}

void DFSTraverse(ALGraph G, Status (*Visit)(int v))
{
 int j;
 VisitFunc = Visit;
 for( j=0; j<G.vexnum; j++)
  visited[j] = 0;
 for(j=0; j<G.vexnum; j++)
  if(!visited[j])
   DFS(G, j);
}

void DFS(ALGraph G, int v)
{
 
 visited[v]=1;
 VisitFunc(v);
 for(w=FirstAdjVex(G, v); w; w=NextAdjVex(G, v, w))
  if(!visited[w])
   DFS(G, w);
}

int FirstAdjVex(ALGraph G, int v)
{
 ArcNode *p;
 p = G.vertices[v].firstarc;
 while(p != NULL)
 {
  if(visited[p->adjvex] != 1)
   return p->adjvex;
  p = p->nextarc;
 }
 return 0;
}

int NextAdjVex(ALGraph G, int v, int w)
{
 ArcNode *p;
 p = G.vertices[v].firstarc;
 while(p != NULL)
 {
  if(visited[p->adjvex] != 1 && p->adjvex != w)
   return p->adjvex;
  p = p->nextarc;
 }
 return 0;
}

Status printGraph(int v)
{
 printf("%c", v + 'a');
 cout<<endl;
 return 1;
}

邻接矩阵的广度遍历

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

#define INFINITY INT_MAX
#define MAX_VERTEX_NUM 20

#define MAXQSIZE 10 //最大队列长度
#define FALSE  0
#define TRUE  1

typedef int VRType;
typedef int InfoType;
typedef char VertexType;
typedef int Status;
typedef int  QElemType; 

typedef struct
{
 QElemType *base;
 int  front;
 int  rear;
} SqQueue;

typedef struct ArcCell
{
 VRType adj;
 InfoType *info;
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct
{
 VertexType vexs[MAX_VERTEX_NUM];
 AdjMatrix arcs;
 int vexnum, arcnum;
}MGraph;

bool visited[MAX_VERTEX_NUM];
Status (*VisitFunc)(int v);
int w;

void CreateGraph(MGraph &G);
void BFSTraverse(MGraph G, Status (*Visit)(int v));
Status printGraph(int v);
int FirstAdjVex(MGraph G, int v);
int NextAdjVex(MGraph G, int v, int w);

Status InitQueue(SqQueue &);
Status EnQueue(SqQueue &, QElemType);
Status DeQueue(SqQueue &, QElemType &);
Status  QueueEmpty(SqQueue);

void main( void )
{
 int i, j;
 MGraph G;
 
 CreateGraph(G);
 for(i = 0; i < G.vexnum; i++)
 {
  for(j = 0; j < G.vexnum; j++)
  {
   cout<<G.arcs[i][j].adj;
   cout<<" ";
  }
  cout<<endl;
 }
 BFSTraverse(G, printGraph);
}
void CreateGraph(MGraph &G)
{
 int weigh;
 int i, j = 0, k = 0;
 char hand, tide;
 
 cout<<"input the number for vexnum and arcnum:";
 cin>>G.vexnum>>G.arcnum;

 for(i = 0; i < G.vexnum; i++)
 {
  for(j = 0; j < G.vexnum; j++)
   G.arcs[i][j].adj = 88;
 }

 cout<<endl;
 cout<<"input"<<G.vexnum<<"char for vexs(use -enter- to change):";
 for(i=0; i < G.vexnum; i++)
  cin>>G.vexs[i];
 cout<<endl;
 cout<<"input"<<G.arcnum<<"arc(char -enter- char -enter- weigh):"<<endl;
 j = 0;
 k = 0;
 for(i=0; i < G.arcnum; i++)
 {
  cout<<i<<":";
  cin>>hand;
  cin>>tide;
  cin>>weigh;
  while (hand != G.vexs[j])
   j++;
  while (tide != G.vexs[k])
   k++;
  G.arcs[j][k].adj = weigh;
  G.arcs[k][j].adj = weigh;
  j = 0;
  k = 0;
  cout<<endl;
 }
}

void BFSTraverse(MGraph G, Status (*Visit)(int v))
{

 SqQueue  Q;
 QElemType   u;

 InitQueue(Q);

 for(int v=0; v < G.vexnum;++v)
  visited[v]=FALSE;
 for(v=0; v<G.vexnum;++v)
  if(!visited[v])
  {
   visited[v]=TRUE;
   Visit(v);
   EnQueue(Q, v);
   while(QueueEmpty(Q))
   {
    DeQueue(Q, u);
    for(w = FirstAdjVex(G, u); w; w = NextAdjVex(G, u, w))
     if(! visited[w])
     {
      visited[w]=TRUE;
      Visit(w);
      EnQueue(Q, w);
     }
   }
  }
}

int FirstAdjVex(MGraph G, int v)
{
 int j;
 for(j = 0; j < G.vexnum; j++)
 {
  if(G.arcs[v][j].adj != 88 && visited[j] != 1)
   return j;
 }
 return 0;
}

int NextAdjVex(MGraph G, int v, int w)
{
 int j;
 for(j = 0; j < G.vexnum; j++)
 {
  if(G.arcs[v][j].adj != 88 && j != w && visited[j] != 1)
   return j;
 }
 return 0;
}

Status printGraph(int v)
{
 printf("%c", v + 'a');
 cout<<endl;
 return 1;
}

Status InitQueue(SqQueue & queue)
{
 queue.base = (QElemType *) malloc(MAXQSIZE * sizeof(QElemType));
 
 if (!queue.base)
  return FALSE;
 queue.front = queue.rear = 0;

 return TRUE;
}

///
//
// 函数名       : EnQueue
// 功能描述     : 插入元素到队列
// 参数         : SqQueue &queue
// 参数         : QElemType element
// 返回值       : Status
//
///
Status EnQueue(SqQueue &queue, QElemType element)
{
 //先判断是不是没满的队列
 if ((queue.rear + 1)  % MAXQSIZE == queue.front)
  return FALSE;
 queue.base[queue.rear] = element;

 queue.rear = (queue.rear + 1) % MAXQSIZE;

 return TRUE;
}


///
//
// 函数名       : DeQueue
// 功能描述     : 删除队列的头结点
// 参数         : SqQueue &queue
// 参数         : QElemType &element
// 返回值       : Status
//
///
Status DeQueue(SqQueue &queue, QElemType &element)
{
 //判断队列是不是空的
 if (queue.front == queue.rear)
  return FALSE;
 element = queue.base[queue.front];
 queue.front = (queue.front + 1) % MAXQSIZE;
 
 return TRUE;
}

Status  QueueEmpty(SqQueue queue)
{
 if (queue.front == queue.rear)
  return FALSE;
 else
  return TRUE;

}

邻接矩阵的深度遍历

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

#define INFINITY INT_MAX
#define MAX_VERTEX_NUM 20

typedef int VRType;
typedef int InfoType;
typedef char VertexType;
typedef int Status;

typedef struct ArcCell
{
 VRType adj;
 InfoType *info;
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct
{
 VertexType vexs[MAX_VERTEX_NUM];
 AdjMatrix arcs;
 int vexnum, arcnum;
}MGraph;

bool visited[MAX_VERTEX_NUM];
Status (*VisitFunc)(int v);
int w;

void CreateGraph(MGraph &G);
void DFSTraverse(MGraph G, Status (*Visit)(int v));
Status printGraph(int v);
int FirstAdjVex(MGraph G, int v);
int NextAdjVex(MGraph G, int v, int w);
void DFS(MGraph G, int v);

void main( void )
{
 int i, j;
 MGraph G;
 
 CreateGraph(G);
 for(i = 0; i < G.vexnum; i++)
 {
  for(j = 0; j < G.vexnum; j++)
  {
   cout<<G.arcs[i][j].adj;
   cout<<" ";
  }
  cout<<endl;
 }
 DFSTraverse(G, printGraph);
}
void CreateGraph(MGraph &G)
{
 int weigh;
 int i, j = 0, k = 0;
 char hand, tide;
 
 cout<<"input the number for vexnum and arcnum:";
 cin>>G.vexnum>>G.arcnum;

 for(i = 0; i < G.vexnum; i++)
 {
  for(j = 0; j < G.vexnum; j++)
   G.arcs[i][j].adj = 88;
 }

 cout<<endl;
 cout<<"input"<<G.vexnum<<"char for vexs(use -enter- to change):";
 for(i=0; i < G.vexnum; i++)
  cin>>G.vexs[i];
 cout<<endl;
 cout<<"input"<<G.arcnum<<"arc(char -enter- char -enter- weigh):"<<endl;
 j = 0;
 k = 0;
 for(i=0; i < G.arcnum; i++)
 {
  cout<<i<<":";
  cin>>hand;
  cin>>tide;
  cin>>weigh;
  while (hand != G.vexs[j])
   j++;
  while (tide != G.vexs[k])
   k++;
  G.arcs[j][k].adj = weigh;
  G.arcs[k][j].adj = weigh;
  j = 0;
  k = 0;
  cout<<endl;
 }
}

void DFSTraverse(MGraph G, Status (*Visit)(int v))
{
 int j;
 VisitFunc = Visit;
 for( j=0; j<G.vexnum; j++)
  visited[j] = 0;
 for(j=0; j<G.vexnum; j++)
  if(!visited[j])
   DFS(G, j);
}

void DFS(MGraph G, int v)
{

 visited[v]=1;
 VisitFunc(v);
 for(w=FirstAdjVex(G, v); w; w=NextAdjVex(G, v, w))
  if(!visited[w])
   DFS(G, w);
}

int FirstAdjVex(MGraph G, int v)
{
 int j;
 for(j = 0; j < G.vexnum; j++)
 {
  if(G.arcs[v][j].adj != 88 && visited[j] != 1)
   return j;
 }
 return 0;
}

int NextAdjVex(MGraph G, int v, int w)
{
 int j;
 for(j = 0; j < G.vexnum; j++)
 {
  if(G.arcs[v][j].adj != 88 && j != w && visited[j] != 1)
   return j;
 }
 return 0;
}

Status printGraph(int v)
{
 printf("%c", v + 'a');
 cout<<endl;
 return 1;
}

hongweijin
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的遍历
kamendula的专栏
03-30 989
图的遍历主要分为两种形式：广度优先遍历（BFS） 和深度优先遍历（DFS）。 对于图的遍历来说，不管是采用的邻接矩阵的方式，还是采用的邻接表的形式，其实现都是类似的，甚至可以说是一样的。 广度遍历 广度遍历利用了队列的特点，结点顺序的放入队列中，然后再出来。 对于采用邻接表还是邻接矩阵，两者实际上是非常类似的： void BFSTraverse(MGraph G,Status(*Visi
图遍历问题
weixin_34380296的博客
03-20 507
图遍历问题分为四类 遍历完所有的边而不能有重复，即所謂“一笔画问题”或“欧拉路径”； 遍历完所有的顶点而没有重复，即所谓“哈密尔顿问题”。 遍历完所有的边而可以有重复，即所谓“中国邮递员问题”； 遍历完所有的顶点而可以重复，即所谓“旅行推销员问题”。 对于第一和第三类问题已经得到了完满的解决，而第二和第四类问题则只得到了部分解决。 第一类问题就是研究所谓的欧拉图的性质，而第二类问题则是...
【数据结构】六、图：4.图的遍历（深度优先算法DFS、广度优先算法BFS）
最新发布
来csdn只办三件事：开源！开源！还是***开源！
08-09 1410
图的遍历是和树的遍历类似，我们希望从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次， 这一过程就叫做图的遍历(Traversing Graph)。 对于图的遍历来，通常有两种遍历次序方案： 深度优先遍历 广度优先遍历 1.1 深度优先遍历DFS 深度优先遍历(Depth First Search)，也有称为深度优先搜索，简称为DFS。 1.1.1 DFS算法 深度优先搜索类似于树的先序遍历。如其名称中所暗含的意思一样，这种搜索算法所遵循的搜索策略是尽可能“深”地搜索一个图，每次都尝试向更
关于图的遍历算法
u013518289的专栏
11-28 5835
前些天做算法设计实验,涉及到图的遍历的一些算法,由于数据结构是在去年学的,很多算法也有些记不清了,今天在网上看到了一篇好的博文,留作看吧. 转载自海子的: http://www.cnblogs.com/dolphin0520/图的遍历有两种遍历方式：深度优先遍历(depth-first search)和广度优先遍历(breadth-first search)。 1.深度优先遍历基本思想：首先从图
图的遍历... 错误一堆...
young00001的专栏
06-19 760
二叉树遍历问题二叉树遍历问题
10-20
二叉树遍历是计算机科学中处理树结构数据时的一项基本操作，主要应用于数据的检索、存储和操作。在二叉树中，每个节点最多有两个子节点，分别称为左子节点...熟练掌握这四种遍历方法有助于理解和解决涉及树结构的问题。
Java中遍历ConcurrentHashMap的四种方式详解
08-25
Java中遍历ConcurrentHashMap的四种方式详解 Java中遍历ConcurrentHashMap的四种方式详解是Java开发中一个非常重要的知识点。ConcurrentHashMap是Java中一种高效且线程安全的HashMap实现，它提供了高效的读写操作...
c# 遍历 Dictionary的四种方式
12-16
昨天在 StackOverflow 上看到一个很有趣的问题，说: 你会几种遍历字典的方式，然后跟帖就是各种奇葩的回答，挺有意思，马上就要国庆了，娱乐娱乐吧，说说这种挺无聊的问题:grinning_face_with_smiling_eyes::...
Java四种遍历Map的方法
08-26
Java四种遍历Map的方法 Java语言中，Map是一种常用的数据结构，用于存储键值对形式的数据。遍历Map是指从Map中提取键值对的过程。本文将介绍四种遍历Map的方法，分别是通过键值遍历、通过值遍历、通过EntrySet遍历...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
【图论】图的遍历
weixin_44745441的博客
05-23 165
https://ac.nowcoder.com/acm/problem/52275 题目描述 小sun最近为了应付考试，正在复习图论，他现在学到了图的遍历，觉得太简单了，于是他想到了一个更加复杂的问题： 无向图有n个点，从点1开始遍历，但是规定：按照每次“走两步”的方式来遍历整个图。可以发现按照每次走两步的方法，不一定能够遍历整个图，所以现在小sun想问你，最少加几条边，可以完整的遍历整个图。 输入: 第一行两个整数n，m代表图的点数和边数。 接下来m行，每行两个整数u，v代表u，v有边相连（无向边） 输出
数据结构-图的遍历问题
Peisenli的博客
09-29 1909
图的遍历：从图中某个顶点出发游历图，访遍图中其余顶点，并且使图中的每个顶点仅被访问一次的过程。我们可以设置一个全局型标志数组visited来标志某个顶点是否被访问过，未访问的值为0，访问过的值为1。 深度优先搜索遍历 深度优先搜索遍历类似于树的先序遍历。假定给定图G的初态是所有顶点均未被访问过，在G中任选一个顶点i作为遍历的初始点，则深度优先搜索遍历可定义如下： (1)首先访问顶点i，并将其访问...
邻接多重表如何实现广度优先遍历_动画解析：图的遍历方式有哪些？
weixin_30799553的博客
01-18 1038
点击关注上方“五分钟学算法”，设为“置顶或星标”，第一时间送达干货。转自景禹小禹禹，你们好呀，景禹今天给你们说一说图的遍历方法！小禹禹： 好呀好呀，图的遍历方法都包含哪些呢？景禹： 图的遍历方法包括 深度优先遍历(搜索) 和 广度优先遍历(搜索) 两种方式。小禹禹能给我说一下树的四种遍历方式吗？聪明的小禹禹： 树的四种遍历方式分别为：前序遍历、中序遍历和后序遍历、层序遍历。这四种遍历方式...
图的遍历方法
贾欣晓的博客
05-15 7960
从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次，这一过程就叫做图的遍历（Traversing Graph） 访问过的顶点打上标记，避免访问多次而不自知；可以通过设置一个访问数组visited[n]，n是图中顶点个数，初值为0，访问之后设置为1 图遍历要避免因回路陷入死循环，通常有两种遍历次序方案： 深度优先遍历 广度优先遍历 深度优先遍历 深度优先遍历（Depth_First_Search），也有称为深度优先搜索，简称DFS 如上图，如何从顶点A开始走遍所有的图顶点并作上标记？ 从顶点
图和树（上）图的遍历问题
greatcoder的博客
04-27 300
树的直径问题 题目描述 给定一棵树，求树的直径，树的直径被定义为树中任意两点之间的距离的最大值，树的边权都为1 做法 首先明确树的直径一定是某两个叶子之间的距离 从树中任选一个点开始遍历这棵树，找到距离这个点最远的叶子，然后在从这个叶子开始遍历，找到里这个叶子最远的另一个叶子，他俩之间的距离就是树的直径。 两次遍历就可以求得树的直径 遍历可以使用DFS、BFS，找到距离起点最远的叶子节点就好。 题目描述 给定一棵树，输出n个数，第i个数表示第i个点到其他任意一点的最长距离。树的边权是1 这个例子中答案：3
图的深度优先遍历BFS (含错误代码即分析)
Zhonexixi的博客
11-26 349
C++
Java Map遍历的四种方法详解
"本文将详细阐述Java中Map接口的遍历方法，主要涵盖四种不同的遍历策略：通过keySet、entrySet、values以及迭代器。这些方法在处理Map数据结构时各有优劣，适用于不同的场景需求。" 在Java中，Map接口是用于存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值