无向图遍历算法

1. 输出无向图的所有深度优先遍历序列，求代码

每个节点设置一个记录表,记录当次遍历,各个边的访问顺序.这个访问顺序决定了遍历序列的不同.每次回溯之后,重新排列这个表(其实是全排列),对这个节点进行重新遍历.除非这个节点的访问表已经尝试了所有的全排列,则继续回溯.

2. 数据结构C++无向图的邻接矩阵深度优先遍历,求解答

你能不能给贴上一个深度遍历错误的用例？你这个输入用例的结果就是1，2，3，4
现在能看出来的就是这个了，
int LocateVex (MGraph G,VertexType v){
int i;
for(i = 0;i<G.vexnum;i++)
if(G.vexs[i] == v){ //这里应该是等于v，而不是等于i
return i;
}
return -1;
}

3. 无向图的深度优先遍历怎么做

#include<stdio.h>
#define n 5
int a[10]={0};
int top=0;//定义堆栈
int main()
{
void dfs(int (*edge)[n],int *status);
int edge[n][n]={{0,0,1,1,0},{0,0,0,0,1},{1,0,0,0,0},{1,0,0,0,1},{0,1,0,1,0}};//临接矩阵表示的图
int status[n]={0};//每个点的状态，有没有被访问
int i=0,j=0;
// for(i=0;i<n;i++)
// for(j=0;j<n;j++)
// scanf("%d",&edge[i][j]);
dfs(edge,status);
return 0;
}
void dfs(int (*edge)[n],int *status)//遍历
{
int k=0,j=0;
while(top>=0)
{
// for(i=0;i<n;i++)
// {
if(status[k]==0)
{
top++;
a[top]=k;
// b[count++]=k;
printf("%d",k);
status[k]=1;
}
while(j<n)
{
// for(j=0;j<n;j++)
if(edge[k][j]==1)
{
if(status[j]==0)
{
top++;
a[top]=j;
// b[count++]=k;
printf("%5d",j);
status[j]=1;
k=j;
j=0;
}
else
j++;
}
else
j++;
}
top-=1;
k=a[top];
j=0;
}
}

这个是非递归的，
#include<stdio.h>
#define n 5
int main()
{
void dft(int (*edge)[n],int *status);
int i=0,j=0;
int edge[n][n]={0};
int status[n]={0};
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&edge[i][j]);
dft(edge,status);
return 0;
}
void dft(int (*edge)[n],int *status)
{
void dftcore(int (*edge)[n],int *status,int i);
int i=0;
for(i=0;i<n;i++)
dftcore(edge,status,i);
}
void dftcore(int (*edge)[n],int *status,int i)
{
int j=0;
if(status[i]==1)
return;
printf("%5d",i);
status[i]=1;
for(j=0;j<n;j++)
if(edge[i][j]==1)
dftcore(edge,status,j);
}
这个递归的

4. 有谁帮忙解释一下 有向图和无向图遍历的区别 谢谢各位

若图中的每条边都是有方向的，则称为有向图。有向图中的边是由两个顶点组成的有序对，有序对通常用尖括号表示，如
<vi,vj>表示一条有向边，其中vi是边的始点，vj是边的终点。<vi,vj>和<vj,vi>代表两条不同的有向边。

5. 有向图的遍历算法和无向图一样吗

看下算法导论，那里面用的顶点染色，对有向图、无向图处理是一样的。

6. 已知有N个结点的无向图，采用邻接表结构存储，要求编写算法实现广度优先搜索策略遍历图中所有顶点。

//按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited.仅适用于邻接表结构
void BFSTraverse1(ALGraph G,void(* Visit)(char *))
{
int v,u;
ArcNode * p;//p指向表结点
LinkQueue Q;//链队列类型
for (v=0; v<G.vexnum; ++v)
{
visited[v] = FALSE;//置初值为未被访问
}
InitQueue(&Q);//初始化辅助队列Q
for (v=0; v<G.vexnum; ++v)//如果是连通图，只v=0就遍历全图
{
if (! visited[v])//v尚未被访问
{
visited[v] = TRUE;//设v为已被访问
Visit(G.vertices[v].data);//访问v
EnQueue(&Q,v);//v入队
while (! QueueEmpty(Q))//队列不空
{
DeQueue(&Q,&u);//队头元素出队并置为u
for (p=G.vertices[u].firstarc; p; p=p->next)//p依次指向u的邻接顶点
{
if (! visited[p->data.adjvex])//u的邻接顶点尚未被访问
{
visited[p->data.adjvex] = TRUE;//该邻接顶点设为已被访问
Visit(G.vertices[p->data.adjvex].data);//访问该邻接顶点
EnQueue(&Q,p->data.adjvex);//入队该邻接顶点序号
}
}
}//while
}//if
}//for(v=......)
printf("\n");
}

7. 图的图的遍历

常见的图遍历方式有两种：深度优先遍历和广度优先遍历，这两种遍历方式对有向图和无向图均适用。 深度优先遍历的思想类似于树的先序遍历。其遍历过程可以描述为：从图中某个顶点v出发，访问该顶点，然后依次从v的未被访问的邻接点出发继续深度优先遍历图中的其余顶点，直至图中所有与v有路径相通的顶点都被访问完为止。
深度优先遍历算法实现：
为了便于在算法中区分顶点是否已被访问过，需要创建一个一维数组visited[0..n-1]（n是图中顶点的数目），用来设置访问标志，其初始值visited（0≤i≤n-1）为"0"，表示邻接表中下标值为i的顶点没有被访问过，一旦该顶点被访问，将visited置成"1"。
int visited[0..n-1]={0,0,...0};
void DFS(AdjList adj,int v)
{//v是遍历起始点的在邻接表中的下标值，其下标从0开始
visited[v]=1; visited(adj[v].elem);
for (w=adj[v].firstedge;w;w=w->next)
if (!visited[w->adjvex]) DFS(adj,w->adjvex);
}
对于无向图，这个算法可以遍历到v顶点所在的连通分量中的所有顶点，而与v顶点不在一个连通分量中的所有顶点遍历不到；而对于有向图可以遍历到起始顶点v能够到达的所有顶点。若希望遍历到图中的所有顶点，就需要在上述深度优先遍历算法的基础上，增加对每个顶点访问状态的检测： intvisited[0..n-1]={0,0,...0};voidDFSTraverse(AdjListadj){for(v=0;v<n;v++)if(!visited[v])DFS(adj,v);} 对图的广度优先遍历方法描述为：从图中某个顶点v出发，在访问该顶点v之后，依次访问v的所有未被访问过的邻接点，然后再访问每个邻接点的邻接点，且访问顺序应保持先被访问的顶点其邻接点也优先被访问，直到图中的所有顶点都被访问为止。下面是对一个无向图进行广度优先遍历的过程。
下面我们讨论一下实现广度优先遍历算法需要考虑的几个问题：
（1）在广度优先遍历中，要求先被访问的顶点其邻接点也被优先访问，因此，必须对每个顶点的访问顺序进行记录，以便后面按此顺序访问各顶点的邻接点。应利用一个队列结构记录顶点访问顺序，就可以利用队列结构的操作特点，将访问的每个顶点入队，然后，再依次出队，并访问它们的邻接点；
（2）在广度优先遍历过程中同深度优先遍历一样，为了避免重复访问某个顶点，也需要创建一个一维数组visited[0..n-1]（n是图中顶点的数目），用来记录每个顶点是否已经被访问过。
int visited[0..n-1]={0,0,...0};
void BFS(AdjList adj,int v)
{//v是遍历起始点在邻接表中的下标，邻接表中下标从0开始
InitQueue(Q); //Q是队列
visited[v]=1; visite(adj[v].elem); EnQueue(Q,v);
while (!QueueEmpty(Q)) {
DeQueue(Q,v);
for (w=adj[v].firstedge;w;w=w->next)
if (!visited[w->adjvex]) {
visited[w->adjvex]=1;
visite(adj[w->adjvex].elem);
EnQueue(Q,w->adjvex); }
}
}

8. 无向图中查找环的算法有哪些

比较直观的办法是，从初始结点 S 开始，用深度优先的方法遍历图的结点，如果在这个过程中，你遇到了一个先前就已经发现过的结点（假定它叫 V），说明存在一个环。
如果你想输出这个环，那么就从 V 沿路返回，直到又遇到 V，途中经过的所有结点就组成了这个环。

9. 我想问一下 图的遍历两种方法DFS和BFS作用域有向图和无向图有什么区别，例如如果是同一个结构的图就是上面

结果肯定不一样的
可以通过链表实现，一个点作为起点的话，箭头指向的点就作为链表连接的下一个节点，依次直到最后一个点没有指向的点了
也可以通过数组实现，把图的所有点之间的联系做成一个矩阵，假如是10个点，就做一个10*10的矩阵数组a[10][10]，a[m][n]表示由m点指向n点，如果没有连接设置a[m][n]=0，如果是n指向m就把a[m][n]设置为一个比较大的数，如果是m指向n就设置为m到n的距离。而a[n][m]也要设置一下，这就是有向图的a[m][n]和a[n][m]是不同的
思路大概是这样的，都写了好久了，你要需要的话，我可以发个源码给你参考，你可以留邮箱