求图的深度优先遍历程序 c语言版

求大神帮写一个c语言图的深度优先遍历，和广度优先遍历??~

/*深度优先*/
#include
#include
struct node/*图的顶点结构*/
{
int vertex;
int flag;
struct node *nextnode;
};
typedef struct node *graph;
struct node vertex_node[10];
void creat_graph(int *node,int n)
{
graph newnode,p;/*定义一个新结点及指针*/
int start,end,i;
for(i=0;i<n;i++)
{
start=node[i*2];/*边的起点*/
end=node[i*2+1];/*边的终点*/
newnode=(graph)malloc(sizeof(struct node));
newnode->vertex=end;/*新结点的内容为边终点处顶点的内容*/
newnode->nextnode=NULL;
p=&(vertex_node[start]);/*设置指针位置*/
while(p->nextnode!=NULL)
p=p->nextnode;/*寻找链尾*/
p->nextnode=newnode;/*在链尾处插入新结点*/
}
}
void dfs(int k)
{
graph p;
vertex_node[k].flag=1;/*将标志位置1，证明该结点已访问过*/
printf("vertex[%d]",k);
p=vertex_node[k].nextnode;/*指针指向下个结点*/
while(p!=NULL)
{
if(vertex_node[p->vertex].flag==0)/*判断该结点的标志位是否为0*/
dfs(p->vertex);/*继续遍历下个结点*/
p=p->nextnode;/*若已遍历过p指向下一个结点*/
}
}
main()
{
graph p;
int node[100],i,sn,vn;
printf("please input the number of sides:
");
scanf("%d",&sn);/*输入无向图的边数*/
printf("please input the number of vertexes
");
scanf("%d",&vn);
printf("please input the vertexes which connected by the sides:
");
for(i=0;i<4*sn;i++)
scanf("%d",&node[i]);/*输入每个边所连接的两个顶点，起始及结束位置不同，每边输两次*/
for(i=1;i<=vn;i++)
{
vertex_node[i].vertex=i;/*将每个顶点的信息存入数组中*/
vertex_node[i].nextnode=NULL;
}
creat_graph(node,2*sn);/*调用函数创建邻接表*/
printf("the result is:
");
for(i=1;i<=vn;i++)/*将邻接表内容输出*/
{
printf("vertex%d:",vertex_node[i].vertex);/*输出顶点内容*/
p=vertex_node[i].nextnode;
while(p!=NULL)
{
printf("->%3d",p->vertex);/*输出邻接顶点的内容*/
p=p->nextnode;/*指针指向下个邻接顶点*/
}
printf("
");
}
printf("the result of depth-first search is:
");
dfs(1);/*调用函数进行深度优先遍历*/
printf("
");
}
/***************************广度优先*******************************/
#include
#include
struct node
{
int vertex;
struct node *nextnode;
};
typedef struct node *graph;
struct node vertex_node[10];
#define MAXQUEUE 100
int queue[MAXQUEUE];
int front = - 1;
int rear = - 1;
int visited[10];
void creat_graph(int *node, int n)
{
graph newnode, p; /*定义一个新结点及指针*/
int start, end, i;
for (i = 0; i < n; i++)
{
start = node[i *2]; /*边的起点*/
end = node[i *2+1]; /*边的终点*/
newnode = (graph)malloc(sizeof(struct node));
newnode->vertex = end; /*新结点的内容为边终点处顶点的内容*/
newnode->nextnode = NULL;
p = &(vertex_node[start]); /*设置指针位置*/
while (p->nextnode != NULL)
p = p->nextnode;
/*寻找链尾*/
p->nextnode = newnode; /*在链尾处插入新结点*/
}
}

int enqueue(int value) /*元素入队列*/
{
if (rear >= MAXQUEUE)
return - 1;
rear++; /*移动队尾指针*/
queue[rear] = value;
}

int dequeue() /*元素出队列*/
{
if (front == rear)
return - 1;
front++; /*移动队头指针*/
return queue[front];
}

void bfs(int k) /*广度优先搜索*/
{
graph p;
enqueue(k); /*元素入队*/
visited[k] = 1;
printf("vertex[%d]", k);
while (front != rear)
/*判断是否对空*/
{
k = dequeue(); /*元素出队*/
p = vertex_node[k].nextnode;
while (p != NULL)
{
if (visited[p->vertex] == 0)
/*判断其是否被访问过*/
{
enqueue(p->vertex);
visited[p->vertex] = 1; /*访问过的元素置1*/
printf("vertex[%d]", p->vertex);
}
p = p->nextnode; /*访问下一个元素*/
}
}
}

main()
{
graph p;
int node[100], i, sn, vn;
printf("please input the number of sides:
");
scanf("%d", &sn); /*输入无向图的边数*/
printf("please input the number of vertexes
");
scanf("%d", &vn);
printf("please input the vertexes which connected by the sides:
");
for (i = 0; i < 4 *sn; i++)
scanf("%d", &node[i]);
/*输入每个边所连接的两个顶点，起始及结束位置不同，每边输两次*/
for (i = 1; i <= vn; i++)
{
vertex_node[i].vertex = i; /*将每个顶点的信息存入数组中*/
vertex_node[i].nextnode = NULL;
}
creat_graph(node, 2 *sn); /*调用函数创建邻接表*/
printf("the result is:
");
for (i = 1; i <= vn; i++)
/*将邻接表内容输出*/
{
printf("vertex%d:", vertex_node[i].vertex); /*输出顶点内容*/
p = vertex_node[i].nextnode;
while (p != NULL)
{
printf("->%3d", p->vertex); /*输出邻接顶点的内容*/
p = p->nextnode; /*指针指向下个邻接顶点*/
}
printf("
");
}
printf("the result of breadth-first search is:
");
bfs(1); /*调用函数进行深度优先遍历*/
printf("
");
}

#include #include #include using namespace std;int FirstAdjVex(int v);int NextAdjVex(int v, int w);void DFS(int v); //从顶点v开始对图做深度优先遍历, v是顶点数组的下标void BFS(int v); //从顶点v开始对图做广度优先遍历，v是顶点数组的下标int find(string a,int n);int visited[10]={0};int traver[10][10]={0};string name[10];int main(){int n,m,i,j,k;string a,b;//freopen("Traver.txt","r",stdin);cin>>n;cin>>m;for(i=0; i>a;name[i] = a;}for(i=0; i>a;cin>>b;j = find(a,n);k = find(b,n);traver[j][k] = 1;traver[k][j] = 1;}for(i=0; i= 0; i--){if (traver[v][i] == 1)return i;}return -1;}int NextAdjVex(int v, int w){int i;for (i = w - 1; i >= 0; i--){if (traver[v][i] == 1)return i;}return -1;}void DFS(int v){int w;//访问顶点v(输出顶点v的名字)cout= 0; w = NextAdjVex(v, w)){//如果w没有访问过，对顶点w做深度优先搜索if (visited[w] == 0)DFS(w);}}void BFS(int v) //从顶点v开始对图做广度优先遍历，v是顶点数组的下标{int w, u;queue myqueue; //定义一个队列，元素是顶点的下标//把顶点v入队myqueue.push(v);cout= 0){if (visited[w] == 0){//访问wcout<<name[w]<<" ";visited[w] = 1;//w入队myqueue.push(w);}w = NextAdjVex(u, w);}}}

邻接表表示的图：#include"stdio.h"
#include"stdlib.h"#define MaxVertexNum 50 //定义最大顶点数typedef struct node{ //边表结点
int adjvex; //邻接点域
struct node *next; //链域
}EdgeNode;
typedef struct vnode{ //顶点表结点
char vertex; //顶点域
EdgeNode *firstedge; //边表头指针
}VertexNode;
typedef VertexNode AdjList[MaxVertexNum]; //AdjList是邻接表类型
typedef struct {
AdjList adjlist; //邻接表
int n,e; //图中当前顶点数和边数
} ALGraph; //图类型//=========建立图的邻接表=======
void CreatALGraph(ALGraph *G)
{
int i,j,k;
char a;
EdgeNode *s; //定义边表结点
printf("Input VertexNum(n) and EdgesNum(e): ");
scanf("%d,%d",&G->n,&G->e); //读入顶点数和边数
fflush(stdin); //清空内存缓冲
printf("Input Vertex string:");
for(i=0;i<G->n;i++) //建立边表
{
scanf("%c",&a);
G->adjlist[i].vertex=a; //读入顶点信息
G->adjlist[i].firstedge=NULL; //边表置为空表
}
printf("Input edges,Creat Adjacency List\n");
for(k=0;k<G->e;k++) { //建立边表
scanf("%d%d",&i,&j); //读入边（Vi，Vj）的顶点对序号
s=(EdgeNode *)malloc(sizeof(EdgeNode)); //生成边表结点
s->adjvex=j; //邻接点序号为j
s->next=G->adjlist[i].firstedge;
G->adjlist[i].firstedge=s; //将新结点*S插入顶点Vi的边表头部
s=(EdgeNode *)malloc(sizeof(EdgeNode));
s->adjvex=i; //邻接点序号为i
s->next=G->adjlist[j].firstedge;
G->adjlist[j].firstedge=s; //将新结点*S插入顶点Vj的边表头部
}
}
//=========定义标志向量，为全局变量=======
typedef enum{FALSE,TRUE} Boolean;
Boolean visited[MaxVertexNum];
//========DFS：深度优先遍历的递归算法======
void DFSM(ALGraph *G,int i)
{//以Vi为出发点对邻接链表表示的图G进行DFS搜索
EdgeNode *p;
printf("%c",G->adjlist[i].vertex); //访问顶点Vi
visited[i]=TRUE; //标记Vi已访问
p=G->adjlist[i].firstedge; //取Vi边表的头指针
while(p) { //依次搜索Vi的邻接点Vj，这里j=p->adjvex
if(! visited[p->adjvex]) //若Vj尚未被访问
DFSM(G,p->adjvex); //则以Vj为出发点向纵深搜索
p=p->next; //找Vi的下一个邻接点
}
}
void DFS(ALGraph *G)
{
int i;
for(i=0;i<G->n;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<G->n;i++)
if(!visited[i]) //Vi未访问过
DFSM(G,i); //以Vi为源点开始DFS搜索
} //==========BFS：广度优先遍历=========
void BFS(ALGraph *G,int k)
{ //以Vk为源点对用邻接链表表示的图G进行广度优先搜索
int i,f=0,r=0; EdgeNode *p;
int cq[MaxVertexNum]; //定义FIFO队列
for(i=0;i<G->n;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<=G->n;i++)
cq[i]=-1; //初始化标志向量
printf("%c",G->adjlist[k].vertex); //访问源点Vk
visited[k]=TRUE;
cq[r]=k; //Vk已访问，将其入队。注意，实际上是将其序号入队
while(cq[f]!=-1) { // 队列非空则执行
i=cq[f]; f=f+1; //Vi出队
p=G->adjlist[i].firstedge; //取Vi的边表头指针
while(p) { //依次搜索Vi的邻接点Vj（令p->adjvex=j）
if(!visited[p->adjvex]) { //若Vj未访问过
printf("%c",G->adjlist[p->adjvex].vertex); //访问Vj
visited[p->adjvex]=TRUE;
r=r+1; cq[r]=p->adjvex; //访问过的Vj入队
}
p=p->next; //找Vi的下一个邻接点
}
}//endwhile
}
//==========主函数===========
void main()
{
//int i;
ALGraph *G;
G=(ALGraph *)malloc(sizeof(ALGraph));
CreatALGraph(G);
printf("Print Graph DFS: ");
DFS(G);
printf("\n");
printf("Print Graph BFS: ");
BFS(G,3);
printf("\n");
}邻接矩阵表示的图：
#include"stdio.h"
#include"stdlib.h"
#define MaxVertexNum 100 //定义最大顶点数
typedef struct{
char vexs[MaxVertexNum]; //顶点表
int edges[MaxVertexNum][MaxVertexNum]; //邻接矩阵，可看作边表
int n,e; //图中的顶点数n和边数e
}MGraph; //用邻接矩阵表示的图的类型
//=========建立邻接矩阵=======
void CreatMGraph(MGraph *G)
{
int i,j,k;
char a;
printf("Input VertexNum(n) and EdgesNum(e): ");
scanf("%d,%d",&G->n,&G->e); //输入顶点数和边数
scanf("%c",&a);
printf("Input Vertex string:");
for(i=0;i<G->n;i++)
{
scanf("%c",&a);
G->vexs[i]=a; //读入顶点信息，建立顶点表
}
for(i=0;i<G->n;i++)
for(j=0;j<G->n;j++)
G->edges[i][j]=0; //初始化邻接矩阵
printf("Input edges,Creat Adjacency Matrix\n");
for(k=0;k<G->e;k++) { //读入e条边，建立邻接矩阵
scanf("%d%d",&i,&j); //输入边（Vi，Vj）的顶点序号
G->edges[i][j]=1;
G->edges[j][i]=1; //若为无向图，矩阵为对称矩阵；若建立有向图，去掉该条语句
}
}
//=========定义标志向量，为全局变量=======
typedef enum{FALSE,TRUE} Boolean;
Boolean visited[MaxVertexNum];
//========DFS：深度优先遍历的递归算法======
void DFSM(MGraph *G,int i)
{ //以Vi为出发点对邻接矩阵表示的图G进行DFS搜索，邻接矩阵是0，1矩阵
int j;
printf("%c",G->vexs[i]); //访问顶点Vi
visited[i]=TRUE; //置已访问标志
for(j=0;j<G->n;j++) //依次搜索Vi的邻接点
if(G->edges[i][j]==1 && ! visited[j])
DFSM(G,j); //（Vi，Vj）∈E，且Vj未访问过，故Vj为新出发点
}
void DFS(MGraph *G)
{
int i;
for(i=0;i<G->n;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<G->n;i++)
if(!visited[i]) //Vi未访问过
DFSM(G,i); //以Vi为源点开始DFS搜索
}
//===========BFS：广度优先遍历=======
void BFS(MGraph *G,int k)
{ //以Vk为源点对用邻接矩阵表示的图G进行广度优先搜索
int i,j,f=0,r=0;
int cq[MaxVertexNum]; //定义队列
for(i=0;i<G->n;i++)
visited[i]=FALSE; //标志向量初始化
for(i=0;i<G->n;i++)
cq[i]=-1; //队列初始化
printf("%c",G->vexs[k]); //访问源点Vk
visited[k]=TRUE;
cq[r]=k; //Vk已访问，将其入队。注意，实际上是将其序号入队
while(cq[f]!=-1) { //队非空则执行
i=cq[f]; f=f+1; //Vf出队
for(j=0;j<G->n;j++) //依次Vi的邻接点Vj
if(!visited[j] && G->edges[i][j]==1) { //Vj未访问
printf("%c",G->vexs[j]); //访问Vj
visited[j]=TRUE;
r=r+1; cq[r]=j; //访问过Vj入队
}
}
}
//==========main=====
void main()
{
//int i;
MGraph *G;
G=(MGraph *)malloc(sizeof(MGraph)); //为图G申请内存空间
CreatMGraph(G); //建立邻接矩阵
printf("Print Graph DFS: ");
DFS(G); //深度优先遍历
printf("\n");
printf("Print Graph BFS: ");
BFS(G,3); //以序号为3的顶点开始广度优先遍历
printf("\n");
}

BFS的基本思想是：首先访问初始点v并将其标志为已经访问。接着通过邻接关系将邻接点入队。然后每访问过一个顶点则出队。按照顺序，访问每一个顶点的所有未被访问过的顶点直到所有的顶点均被访问过。广度优先遍历类似与层次遍历。其特点是尽可能先对横向进行搜索，从指定的出发点，按照该点的路径长度由短到长的顺序访问图中各顶点。下面给出bfs函数代码：void bfs(Graph *g,int vi)
{
int i,v;
int Q[max],front=0,rear=0;//循环队列
Edgenode *p;
for(i=0;i<g->n;i++)
visited[i]=0; //队列赋初值
visited[vi]=1; //访问初始顶点
printf("--%c--",g->v[vi].c);
rear=(rear+1)% max;
Q[rear]=vi;//初始顶点入队列
while(front!=rear) //队列不为空的时候循环
{
front=(front+1)%max;
v=Q[front]; //出队列
p=g->v[v].first;//查找v的第一个邻接点
while(p!=NULL)//查找v的所有邻接点
{
if(visited[p->b]==0)//未访问过则访问之
{
visited[p->b]=1;
printf("--%c--",g->v[p->b].c);//访问该点并入队
rear=(rear+1)%max;
Q[rear]=p->b;
}
p=p->next; //查找v的下一邻接点
}
}
}请仔细理解其中队列的使用。 完整程序：#include<stdio.h>
#define max 6
typedef struct node{
int b;
struct node* next;
}adjnode; //定义边表节点
typedef struct vertex{
int c;
adjnode *first;
}vertexnode; //定义顶点
typedef struct graph{
vertexnode v[max];
int vertex,edge;
}adjgraph; //定义图的结构
int visited[max];
void creatg(adjgraph *g) //初始化创建图
{
int i,j,e,f;
adjnode *p,*q;
for(i=0;i<5;i++) //这里的4就是vertex的值可以用g->vertex换过来
{ g->v[i].c=getchar(); g->v[i].first=NULL;} //图的顶点赋值这里就是赋的0123
for(j=0;j<5;j++) //这里的5就是edge的值也可换
{
printf("Please input 邻接边:\n");
scanf("\n%d,%d",&e,&f); //输入邻接边

p=(adjnode *)malloc(sizeof(adjnode));
p->b=f;
p->next=g->v[e].first; //插入领接边的表是从中间插着接的。注意了！
g->v[e].first=p; //注意这两个指针的使用。比较巧妙

q=(adjnode *)malloc(sizeof(adjnode)); //一个图只要输入相应的边即可
q->b=e; //这两个接点将两个顶点的邻接表
q->next=g->v[f].first; //的节点都接上了。注意体会
g->v[f].first=q;
}
}
void dispg(adjgraph *g) //输出图，打印出邻接表
{
int i,j;
adjnode *p;
for(i=0;i<4;i++) //打印4个节点的情况
{
printf("%c",g->v[i].c);
p=g->v[i].first;
while(p!=NULL)
{printf("->%d",p->b);<br> p=p->next;}
printf("\n");
}
}
void bfs(adjgraph *g,int vi)
{
int i,v;
int Q[max],front=0,rear=0;//循环队列
adjnode *p;
for(i=0;i<g->vertex;i++)
visited[i]=0; //队列赋初值
visited[vi]=1; //访问初始顶点
printf("--%c--",g->v[vi].c);
rear=(rear+1)% max;
Q[rear]=vi;//初始顶点入队列
while(front!=rear) //队列不为空的时候循环
{
front=(front+1)%max;
v=Q[front]; //出队列
p=g->v[v].first;//查找v的第一个邻接点
while(p!=NULL)//查找v的所有邻接点
{
if(visited[p->b]==0)//未访问过则访问之
{
visited[p->b]=1;
printf("--%c--",g->v[p->b].c);//访问该点并入队
rear=(rear+1)%max;
Q[rear]=p->b;
}
p=p->next; //查找v的下一邻接点
}
}
}int main()
{
adjgraph *g;
g=(adjgraph *)malloc(sizeof(adjgraph));
creatg(g);
dispg(g);
bfs(g,0);
system("pause");
}

#include "stdio.h"
#include "malloc.h"
#define MAX 20int visited[MAX];typedef struct ArcNode{
int adjvex;
struct ArcNode *nextarc;
}ArcNode;typedef int Vertex;typedef struct VNode{
Vertex data;
struct ArcNode *firstarc;
}VNode;typedef VNode AdjList[MAX];typedef struct {
AdjList adjlist;
int vexnum,arcnum;
}ALGraph; CreateDG(ALGraph *G){ /*创建邻接表*/
int i,k,j,v1,v2;
ArcNode *p;
printf("shu ru tu de ding dian shu ,hu du:" );
scanf("%d,%d",&G->vexnum,&G->arcnum);
printf("\n");
for(i=0;i<G->vexnum;++i)
G->adjlist[i].firstarc=NULL;
for(k=0;k<G->arcnum;++k){
printf("shu ru di%dtiao de hu wei he hu tou:",k);
scanf("%d,%d",&v1,&v2);
i=v1;j=v2;
p=(ArcNode *)malloc(sizeof(ArcNode));
p->adjvex=j;
p->nextarc=G->adjlist[i].firstarc;
G->adjlist[i].firstarc=p;
}
} DispAdj(ALGraph *G){ /*输出邻接表*/
int i;
ArcNode *q;
for(i=0;i<G->vexnum;++i){
q=G->adjlist[i].firstarc;
printf("%d",i);
while(q!=NULL){
printf("->%d",q->adjvex);
q=q->nextarc;
}
printf("\n");
}
}
DFS(ALGraph *G,int v){ /*深度优先搜索周游*/
ArcNode *p;
visited[v]=1;
printf("%d ",v);
for(p=G->adjlist[v].firstarc;p!=NULL;){
if(!visited[p->adjvex])
DFS(G,p->adjvex);
p=p->nextarc;
}
}
BFS(ALGraph *G,int v){ /*广度优先搜索周游*/
int queue[MAX],front=0,rear=0;
int w,i;
ArcNode *u;
for(i=0;i<G->vexnum;++i) visited[i]=0;
visited[v]=1;
printf("%d ",v);
rear=(rear+1)%MAX;
queue[rear]=v;
while(front!=rear){
front=(front+1)%MAX;
w=queue[front];
for(u=G->adjlist[w].firstarc;u!=NULL;){
if(!visited[u->adjvex]){
visited[u->adjvex]=1;
printf("%d ",u->adjvex);
rear=(rear+1)%MAX;
queue[rear]=u->adjvex;
}
u=u->nextarc;
}
}
printf("\n");
} main(){ /*主函数*/
int i,j,k;
ALGraph *G;
printf("\n");
G=(ALGraph *)malloc(sizeof(ALGraph));
CreateDG(G);
printf("tu de ling jie biao wei:\n");
DispAdj(G);
printf("\n");
printf("cong ding dian 0 kai shi de shen du sou suo:\n");
DFS(G,0);
printf("\n");
printf("cong ding dian 0 kai shi de guangdu du sou suo:\n");
BFS(G,0);
printf("\n");
getch();
}

---

仲巴县13766958893： 求c语言图的深度优先遍历算法 - ？
陟菊牛黄： //两个算法使用的全局变量 --- bool visited[MAX_VERTEX_NUM]; // 访问标志数62616964757a686964616fe59b9ee7ad9431333264663039组 Status (* VisitFunc)(int v); // 函数变量 void DFSTraverse(Graph G, Status (*Visit)(int v)) {// 对图G作...

仲巴县13766958893： 图的深度优先遍历c语言算法 - ？
陟菊牛黄： #include <stdio.h> int m,n; bool w[100][100],visited[100]; void dfs(int i){ visited[i] = true; printf(＂%d ＂,i); for(int j = 0;j<n;j++) if(w[i][j] && !visited[j]) dfs(j); } int main(){ scanf(＂%d%d＂,&m,&n); int a,b; for(int i = 0;i<m;i++){ scanf(＂%d%d,&a,&b); w[a][b...

仲巴县13766958893： c语言图的遍历,邻接表存储,深度,广度优先遍历 - ？
陟菊牛黄： (1) 图的建立,按采用邻接表作为存储结构.(2) 从指定顶点出发进行深度优先搜索遍历.(3) 从指定顶点出发进行广度优先搜索遍历.#include＂stdio.h＂#include＂string.h＂#include＂stdlib.h＂#include＂math.h＂#define MAX_INT 1000#define ...

仲巴县13766958893： 用c语言对给定的图和起点,产生其所有的深度优先遍历序列. - ？
陟菊牛黄： #include ＂stdio.h＂#include ＂malloc.h＂#define MAX 20int visited[MAX];typedef struct ArcNode{ int adjvex; struct ArcNode *nextarc; }ArcNode;typedef int Vertex;typedef struct VNode{ Vertex data; struct ArcNode *firstarc; }VNode;typedef VNode ...

仲巴县13766958893： 求一个C语言编程,图的遍历,深度优先和广度优先搜索的程序.要浅显易懂的~~~~？
陟菊牛黄： 给你一个作为参考吧 #include <iostream> #define INFINITY 32767 #define MAX_VEX 20 //最大顶点个数 #define QUEUE_SIZE (MAX_VEX+1) //队列长度 using namespace std; bool *visited; //访问标志数组 //图的邻接矩阵存储结构 typedef struct...

仲巴县13766958893： 跪求 C语言 ACM题目 图的深度优先遍历序列？
陟菊牛黄： #include&lt;stdio.h&gt; #include&lt;string.h&gt; int p[22][22]={0}; int vis[22]; void DFS(int r,int n) { int i; vis[r]=1; printf(＂%d ＂,r); for(i=0;i&lt;n;i++) { if(vis[i]==1)continue; DFS(i,n); } } int main() { int n,m; int i,j; while(scanf(＂%d%d＂,&amp;n,&amp;m)!...

仲巴县13766958893： C语言图的创建和遍历算法,紧急 - ？
陟菊牛黄： 图的遍历是指按某条搜索路径访问图中每个结点,使得每个结点均被访问一次,而且仅被访问一次.图的遍历有深度遍历算法和广度遍历算法,最近阿杰做了关于图的遍历的算法,下面是图的遍历深度优先的算法(C语言程序): #include#...

仲巴县13766958893： C语音算法图的广度优先算法实现代码?要C语言版的 - ？
陟菊牛黄： 深度优先遍历算法(Depth-first-search),重点关注的是图的连通性(connectivity),即从图中给定的一点都能访问到哪些点.不仅如此,在遍历这些点的过程中,通过记录访问次序,可以实现其他功能,比如测试该图是否有闭环等. 广度优先...

仲巴县13766958893： C语言编程 图的创建与遍历 - ？
陟菊牛黄： 在C语言编程中,图的创建和遍历: #include<stdio.h> #define N 20 #define TRUE 1 #define FALSE 0 int visited[N]; typedef struct /*队列的定义*/ { int data[N]; int front,rear; }queue; typedef struct /*图的邻接矩e799bee5baa6e4b893e5b19e...

仲巴县13766958893： 诚求用C语言编一个实现图的创建及两种遍历的代码. - ？
陟菊牛黄： /* 首先访问出发点v,并将其标记为已访问过; 然后依次从v出发搜索v的每个邻接点w. 若w未曾访问过,则以w为新的出发点继续进行深度优先遍历,直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止. 若此...