void BFSTraverse(AMLGraph G,Status(*Visit)(VertexType)) { /* 初始条件: 图G存在,Visit是顶点的应用函数。*/ /* 操作结果: 从第1个顶点起,按广度优先非递归遍历图G,并对每个顶点调用函数 */ /* Visit一次且仅一次。一旦Visit()失败,则操作失败。 */ /* 使用辅助队列Q和访问标志数组visite */ int v,u,w; VertexType w1,u1; LinkQueue Q; for(v=0;v<G.vexnum;v++) visite[v]=FALSE; /* 置初值 */ InitQueue(&Q); /* 置空的辅助队列Q */ for(v=0;v<G.vexnum;v++) if(!visite[v]) /* v尚未访问 */ { visite[v]=TRUE; /* 设置访问标志为TRUE(已访问) */ Visit(G.adjmulist[v].data); EnQueue(&Q,v); /* v入队列 */ while(!QueueEmpty(Q)) /* 队列不空 */ { DeQueue(&Q,&u); /* 队头元素出队并置为u */ strcpy(u1,*GetVex(G,u)); for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w)))) if(!visite[w]) /* w为u的尚未访问的邻接顶点的序号 */ { visite[w]=TRUE; Visit(G.adjmulist[w].data); EnQueue(&Q,w); } } } printf("\n"); }
void DFSTree(ALGraph G,int v,CSTree *T) { /* 从第v个顶点出发深度优先遍历图G,建立以T为根的生成树。算法7.8 */ Boolean first=TRUE; int w; CSTree p,q; VertexType v1,w1; visited[v]=TRUE; strcpy(v1,*GetVex(G,v)); for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w)))) /* w依次为v的邻接顶点 */ if(!visited[w]) /* w顶点不曾被访问 */ { p=(CSTree)malloc(sizeof(CSNode)); /* 分配孩子结点 */ strcpy(p->data,*GetVex(G,w)); p->firstchild=NULL; p->nextsibling=NULL; if(first) { /* w是v的第一个未被访问的邻接顶点 */ (*T)->firstchild=p; first=FALSE; /* 是根的第一个孩子结点 */ } else /* w是v的其它未被访问的邻接顶点 */ q->nextsibling=p; /* 是上一邻接顶点的兄弟姐妹结点 */ q=p; DFSTree(G,w,&q); /* 从第w个顶点出发深度优先遍历图G,建立子生成树q */ } }
//----------------------------Breadth First Search --------------------------------// Status BFSTraverse( AMLGraph G , Status ( *v )( VertexType v ) ) { int u , w , q; LinkQueue Q ; for( u = 0 ; u < G.vexnum ; ++ u ) //如果利用数据结构本身的访问标志域会very good! { visite[ u ] = FALSE ; } InitQueue( &Q ) ; for( u = 0 ; u < G.vexnum ; ++ u ) { if( !visite[ u ] ) //u尚未被访问 { visite[ u ] = TRUE ; v( G.adjmulist[ u ].data ) ; EnQueue( &Q , u ) ; //u号入队列 while( !QueueEmpty( Q ) ) { DeQueue( &Q , &q ) ; for( w = FirstAdjVex( G , G.adjmulist[ q ].data ) ; w >= 0 ; w = NextAdjVex( G , G.adjmulist[ q ].data , G.adjmulist[ w ].data ) ) if( !visite[ w ] ) //w为q的尚未访问的邻接顶点 { visite[ w ] = TRUE ; v( G.adjmulist[ w ].data ) ; EnQueue( &Q , w ) ; } }//while }//if }//for return OK ; }
Status DFSArticul(MGraph graph, int vex_index, int *count, int articulated[MAXVEX + 1], int visited_sequ[MAXVEX], int vex_can_arrived[MAXVEX]) { int nextvex; visited_sequ[vex_index] = *count; ++*count; vex_can_arrived[vex_index] = visited_sequ[vex_index]; //min(自己的序号,儿子能到达的最早序号,自己的祖先边中祖先的序号) for (nextvex = FirstAdjVex(graph, vex_index); nextvex != -1; nextvex = NextAdjVex(graph, vex_index, nextvex)) { if (visited_sequ[nextvex] == -1) { DFSArticul(graph, nextvex, count, articulated, visited_sequ, vex_can_arrived); if (vex_can_arrived[nextvex] < vex_can_arrived[vex_index]) { vex_can_arrived[vex_index] = vex_can_arrived[nextvex]; } if (vex_can_arrived[nextvex] >= visited_sequ[vex_index]) { int i; for (i = 1; i <= articulated[0]; ++i) //如果该点已经添加过了,则不必再添加 if (articulated[i] == graph.vexs[vex_index]) break; if (i == articulated[0] + 1) { ++articulated[0]; articulated[articulated[0]] = graph.vexs[vex_index]; } } } else if (visited_sequ[nextvex] < vex_can_arrived[vex_index]) { vex_can_arrived[vex_index] = visited_sequ[nextvex]; } } return OK; }
void BFSTraverse(ALGraph G,void(*Visit)(char*)) {/*按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组visited。*/ int v,u,w; VertexType u1,w1; 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; Visit(G.vertices[v].data); EnQueue(&Q,v); /* v入队列 */ while(!QueueEmpty(Q)) /* 队列不空 */ { DeQueue(&Q,&u); /* 队头元素出队并置为u */ strcpy(u1,*GetVex(G,u)); for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w)))) if(!visited[w]) /* w为u的尚未访问的邻接顶点 */ { visited[w]=TRUE; Visit(G.vertices[w].data); EnQueue(&Q,w); /* w入队 */ } } } printf("\n"); }
void BFSTraverse(MGraph G, Status(*Visit)(VertexType)) {/* 初始条件: 图G存在,Visit是顶点的应用函数。算法7.6 */ /* 操作结果: 从第1个顶点起,按广度优先非递归遍历图G,并对每个顶点调用函数 */ /* Visit一次且仅一次。一旦Visit()失败,则操作失败。 */ /* 使用辅助队列Q和访问标志数组visited */ int u, v, w; VertexType w1, u1; SqQueue Q; for (v = 0; v < G.vexnum; v++) visited[v] = FALSE; //访问标志数组初始化(未被访问) InitQueue(Q); for (v = 0; v < G.vexnum; v++) { if (!visited[v]) { visited[v] = TRUE; Visit(G.vexs[v]); EnQueue(Q, v); while (!QueueEmpty(Q)) { DeQueue(Q, u); //队头元素出队并置为u strcpy(u1, GetVex(G, u)); for (w = FirstAdjVex(G, u1); w != -1; w = NextAdjVex(G, u1, strcpy(w1, GetVex(G, w)))) if (!visited[w]) { // w为u的尚未访问的邻接顶点的序号 visited[w] = TRUE; Visit(G.vexs[w]); EnQueue(Q, w); } } } } }
/** * 算法7.6,按广度优先非递归遍历图G,使用辅助队列Q和访问标志数组visited */ void BFSTraverse(ALGraph G, Boolean visited[], Status (*Visit)(ALGraph G, int v)) { int u, v, w; LinkQueue Q; InitQueue(Q); for (v = 0; v < G.vexnum; v++) { visited[v] = false; } for (v = 0; v < G.vexnum; v++) { if (!visited[v]) { visited[v] = true; Visit(G, v); EnQueue(Q, v); while (!QueueEmpty(Q)) { DeQueue(Q, u); //附着元素出列并置为u for (w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)) { if (!visited[w]) { visited[w] = true; Visit(G, w); EnQueue(Q, w); } } } } } }
/** * 算法7.8,从第v个顶点出发深度优先遍历图G,建立以T为根的生成树 */ Status DFSTree(ALGraph G, int v, CSTree T, bool visited[]) { bool first; CSTree p, q; int w; visited[v] = true; first = true; for (w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w)) { if (!visited[w]) { p = (CSTree) malloc (sizeof(CSNode)); //分配孩子结点 if (!p) { return ERROR; } p->data = GetVex(G, w); p->lchild = NULL; p->nextsibling = NULL; if (first) { T->lchild = p; first = false; } else { q->nextsibling = p; } q = p; DFSTree(G, w, q, visited); } } return OK; }
void DFSTree(ALGraph G,int v,CSTree &T) { // 从第v个顶点出发深度优先遍历图G,建立以T为根的生成树。算法7.8 Boolean first=TRUE; int w; CSTree p,q; VertexType v1,w1; visited[v]=TRUE; strcpy(v1,GetVex(G,v)); for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,GetVex(G,w)))) // w依次为v的邻接顶点 if(!visited[w]) // w顶点不曾被访问 { p=(CSTree)malloc(sizeof(CSNode)); // 分配孩子结点 strcpy(p->data,GetVex(G,w)); p->firstchild=NULL; p->nextsibling=NULL; if(first) { // w是v的第一个未被访问的邻接顶点 T->firstchild=p; first=FALSE; // 是根的第一个孩子结点 } else // w是v的其它未被访问的邻接顶点 q->nextsibling=p; // 是上一邻接顶点的兄弟姐妹结点 q=p; DFSTree(G,w,q); // 从第w个顶点出发深度优先遍历图G,建立子生成树q } }
int BFSTraverse(MGraph G,int(*Visit)(char v)) { LinkQueue Q; int v,w,u; for(v=0;v<G.vexnum;v++) visited[v]=0; InitQueue(Q); for(v=0;v<G.vexnum;v++) { if(!visited[v]) { visited[v]=1; Visit(G.dingdian[v]); EnQueue(Q,v); while(!EmptyQueue(Q)) { DeQueue(Q,u); w=FirstAdjVex(G,G.dingdian[u]); for(;w>=0;w=NextAdjVex(G,G.dingdian[u],G.dingdian[w])) if(!visited[w]) { visited[w]=1; Visit(G.dingdian[w]); EnQueue(Q,w); } } } } return OK; }
Status BFSTraverse(ALGrapth G, Status(visit)(VertexType), int num = 0){ int i; visitfunc = visit; for(i = 0; i < G.vexnum; i++){ visited[i] = FALSE; } LinkQueue Q; InitQueue(&Q); int j; for(i = num, j = 0; j < G.vexnum; i++, j++){ if(i == G.vexnum) i = 0; if(!visited[i]){ visited[i] = TRUE; visitfunc(G.vertices[i].data); EnQueue(&Q, i); int u; while(!isEmpty(Q)){ DeQueue(&Q, &u); int w; for(w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)){ // printf("w: %d\n", w); visited[w] = TRUE; visitfunc(G.vertices[w].data); EnQueue(&Q, w); // printf("step\n"); } // printf("stop\n"); } } // printf("end\n"); } }
void BFSTraverse(OLGraph G,Status(*Visit)(VertexType)) { /* 初始条件: 有向图G存在,Visit是顶点的应用函数。算法7.6 */ /* 操作结果: 从第1个顶点起,按广度优先非递归遍历有向图G,并对每个顶点调用 */ /* 函数Visit一次且仅一次。一旦Visit()失败,则操作失败。 */ /* 使用辅助队列Q和访问标志数组visited */ int v,u,w; VertexType u1,w1; SqQueue Q; for(v=0;v<G.vexnum;v++) visited[v]=FALSE; InitQueue(&Q); for(v=0;v<G.vexnum;v++) if(!visited[v]) { visited[v]=TRUE; Visit(G.xlist[v].data); EnQueue(&Q,v); while(!QueueEmpty(Q)) { DeQueue(&Q,&u); strcpy(u1,*GetVex(G,u)); for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w)))) if(!visited[w]) /* w为u的尚未访问的邻接顶点的序号 */ { visited[w]=TRUE; Visit(G.xlist[w].data); EnQueue(&Q,w); } } } printf("\n"); }
/*深度遍历*/ int visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量),未访问标记0,访问标记1 */ void(*VisitFunc)(char* v); /* 函数变量(全局量) */ void DFS(ALGraph G,int v) { /* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */ int w; visited[v]=TRUE;/* 设置访问标志为TRUE(已访问) */ VisitFunc(v);/* 访问第v个顶点 */ for(int w=FirstAdjVex(G,G.vertices[v].data);w>0;w=NextAdjVex(G,G.vertices[v].data,G.vertices[w].data)) if(!visited[w]) DFS(G,w);/* 对v的尚未访问的邻接点w递归调用DFS */ }
void DFS(Graph G, int v) { // 算法7.5 // 从第v个顶点出发递归地深度优先遍历图G。 int w; visited[v] = true; VisitFunc(v); // 访问第v个顶点 for (w=FirstAdjVex(G, v); w!=-1; w=NextAdjVex(G, v, w)) if (!visited[w]) // 对v的尚未访问的邻接顶点w递归调用DFS DFS(G, w); }
// exist and edge ~ (vex[v],vex[u]) or not bool isEdge(ALGraph G,int v, int u) { int w; w = FirstAdjVex(G,v); for(; w >= 0; w = NextAdjVex(G,v,w)) if(w == u) return true; return false; }
void DFS(MGraph G,int v) { int w; visited[v]=1; Visit(G.dingdian[v]); for(w=FirstAdjVex(G,G.dingdian[v]);w>=0;w=NextAdjVex(G,G.dingdian[v],G.dingdian[w])) if(!visited[w]) DFS(G,w); }
// depth-first search void DFS(ALGraph &G,int v) { int w; //set visited G.vertices[v].visited = 1; visit(G,v); for(w = FirstAdjVex(G,v); w >= 0; w = NextAdjVex(G,v,w)) if(G.vertices[w].visited == 0) DFS(G,w); }
/** * 算法7.5,从第v个顶点出发递归地深度优先遍历图G, visited为结点访问标志数组,Visit为访问函数 */ void DFS(ALGraph G, int v, Boolean visited[], Status (*Visit)(ALGraph G, int v)) { int w; visited[v] = true; Visit(G, v); //访问第v个结点 for (w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w)) { if (!visited[w]) DFS(G, w, visited, Visit); } }
/* 若w是v的最后一个邻接点,则返回-1 */ ArcNode *p; int v1,w1; v1=LocateVex(G,v); /* v1为顶点v在图G中的序号 */ w1=LocateVex(G,w); /* w1为顶点w在图G中的序号 */ p=G.vertices[v1].firstarc; while(p&&p->adjvex!=w1) /* 指针p不空且所指表结点不是w */ p=p->nextarc; if(!p||!p->nextarc) /* 没找到w或w是最后一个邻接点 */ return -1; else /* p->adjvex==w */ return p->nextarc->adjvex; /* 返回v的(相对于w的)下一个邻接顶点的序号 */ } Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */ void(*VisitFunc)(char* v); /* 函数变量(全局量) */ void DFS(ALGraph G,int v) { /* 从第v个顶点出发递归地深度优先遍历图G。*/ int w; VertexType v1,w1; strcpy(v1,*GetVex(G,v)); visited[v]=TRUE; /* 设置访问标志为TRUE(已访问) */ VisitFunc(G.vertices[v].data); /* 访问第v个顶点 */ for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w)))) if(!visited[w]) DFS(G,w); /* 对v的尚未访问的邻接点w递归调用DFS */ }
void DFS(MGraph G, int v) {/* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */ VertexType w1, v1; int w; visited[v] = TRUE; /* 设置访问标志为TRUE(已访问) */ VisitFunc(G.vexs[v]); //访问第v个顶点 strcpy(v1, GetVex(G, v)); for (w = FirstAdjVex(G, v1); w != -1; w = NextAdjVex(G, v1, strcpy(w1, GetVex(G, w)))) if (!visited[w]) DFS(G, w); //对v的尚未访问的序号为w的邻接顶点递归调用DFS }
/* * @description:深度优先递归遍历 */ void DFS(MGraph G,int i,Status (*Visit) (VertexType)) { int w; //标记 visited[i] = TRUE; Visit(G.vexs[i]); for(w = FirstAdjVex(G,i); w >= 0; w = NextAdjVex(G,i,w)) if(!visited[w]) DFS(G,w,Visit); }
Status FindArticul(MGraph graph, int articulated[MAXVEX + 1]) { int visited_sequ[MAXVEX]; //被访问的序列号 int vex_can_arrived[MAXVEX]; //能到达的最早被访问的序列号 int index, i; int count; if (graph.vexnum < 2) return ERROR; if (!articulated) return ERROR; articulated[0] = 0; count = 0; for (i = 0; i < graph.vexnum; ++i) //访问序列初始化 visited_sequ[i] = -1; for (i = 0; i < graph.vexnum; ++i) { if (visited_sequ[i] == -1) { visited_sequ[i] = count; ++count; if ((index = FirstAdjVex(graph, i)) == -1) //不能存在度为0的点(独立构成一个连通分量) return ERROR; // 对根的一棵子树进行遍历,找出关节点 DFSArticul(graph, index, &count, articulated, visited_sequ, vex_can_arrived); // 判断根是否是关节点 for (index = FirstAdjVex(graph, i); index != -1; index = NextAdjVex(graph, i, index)) { if (visited_sequ[index] == -1) { ++articulated[0]; articulated[articulated[0]] = graph.vexs[i]; break; } } } } return OK; }
void DFS(MGraph G,VertexType v) { VertexType w; int i=LocateVex(G,v); if(!Visited[i]) { Visited[i]=TRUE; Visit(v); } for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w)) if(!Visited[LocateVex(G,w)]) DFS(G,w); }
Status DFS( AMLGraph G , int v ) //从第v个顶点出发递归地深度优先遍历图G { int w ; visite[ v ] = TRUE ; VisitFunc( G.adjmulist[ v ].data ) ; //访问第v个顶点 for( w = FirstAdjVex( G , G.adjmulist[ v ].data ) ; w >= 0 ; w = NextAdjVex( G , G.adjmulist[ v ].data , G.adjmulist[ w ].data ) ) { if( visite[ w ] != TRUE ) DFS( G , w ) ; } return OK ; }
Status DFS(ALGrapth G, int v){ // printf("%d\n", v); // printf("visited%d: %d\n", v, visited[v]); visited[v] = TRUE; // printf("visited%d: %d\n", v, visited[v]); visitfunc(G.vertices[v].data); int w; for(w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w)){ // printf("w:%d\n", w); if(!visited[w]) DFS(G, w); // printf("step\n"); } // printf("stop\n"); return OK; }
//Function use: 从第nSeqV个顶点出发深度遍历图 void DFS(MGraph G, int nSeqV) { VertexType v; VertexType w; int nSeqW; visited[nSeqV] = TRUE; VisitFunc(G.vexs[nSeqV]); strcpy(v, *GetVex(G, nSeqV)); for (nSeqW = FirstAdjVex(G, v);\ nSeqW >= 0; nSeqW = NextAdjVex(G, v, w)) { if (!visited[nSeqW]) { DFS(G, nSeqW); } } }
void PathDFS(Graph &G,vexindex v){ //深度优先进行路径遍历 if(!OnCurrentPath[v]){ OnCurrentPath[v]=TRUE; EnCurrentPath(v,CurrentPath); if(P(v)&&Q(CurrentPath)) print(CurrentPath); else{ w=FirstAdjVex(G,v); while(w){ PathDFS(G,w); w=NextAdjVex(G,v,w); } } OnCurrentPath[v]=FALSE; DeCurrentPath(v,Current); } }
// breadth-first search based on queue Status BFSTraverse(ALGraph G) { LinkQueue Q; Init_LinkQueue(Q); int w,i,u; for(i = 0; i < G.vexnum; i++) //vertex nodes if(G.vertices[i].visited == 0){ // unvisited G.vertices[i].visited = 1; // set visited visit(G,i); // visit it En_LinkQueue(Q,i); // vex[i] enqueue while(!IsEmpty_LinkQueue(Q)) { De_LinkQueue(Q,u); for(w = FirstAdjVex(G,u); w >= 0; w = NextAdjVex(G,u,w)) if(G.vertices[w].visited == 0){ // visit adjacent nodes G.vertices[w].visited = 1; visit(G,w); En_LinkQueue(Q,w); }//if }//while }//if Destroy_LinkQueue(Q); // free memory space return OK; }
//Function use: 从第1个顶点起广度非递归遍历图,并对每个顶点 //调用函数,一旦Visit()失败,则失败 void BFSTraverse(MGraph G, Status (*Visit)(VertexType)) { int nSeqV; int nSeqW; int nSeqU; VertexType u; VertexType w; LinkQueue Q; for (nSeqV = 0; nSeqV < G.vexnum; nSeqV++) { visited[nSeqV] = FALSE; } InitQueue(&Q); for (nSeqV = 0; nSeqV < G.vexnum; nSeqV++) { if (!visited[nSeqV]) { visited[nSeqV] = TRUE; Visit(G.vexs[nSeqV]); EnQueue(&Q, nSeqV); while (!QUEUEEMPTY(Q)) { DeQueue(&Q, &nSeqU); strcpy(u, *GetVex(G, nSeqU)); for (nSeqW = FirstAdjVex(G, u);\ nSeqW >= 0;\ nSeqW = NextAdjVex(G, u, strcpy(w, *GetVex(G, nSeqW)))) { visited[nSeqW] = TRUE; Visit(G.vexs[nSeqW]); EnQueue(&Q, nSeqW); } } } } printf("\n"); }
void DFSTree(ALGraph G,int v,CSTree &T) { // 从第v个顶点出发深度优先遍历图G,建立以T为根的生成树。算法7.8 Boolean first=TRUE; int w; CSTree p,q; visited[v]=TRUE; for(w=FirstAdjVex(G,G.vertices[v].data);w>=0;w=NextAdjVex(G,G.vertices[v].data,G.vertices[w].data)) // w依次为v的邻接顶点 if(!visited[w]) // w顶点不曾被访问 { p=(CSTree)malloc(sizeof(CSNode)); // 分配孩子结点 strcpy(p->data,G.vertices[w].data); p->firstchild=NULL; p->nextsibling=NULL; if(first) { // w是v的第一个未被访问的邻接顶点 T->firstchild=p; first=FALSE; // 是根的第一个孩子结点 } else // w是v的其它未被访问的邻接顶点 q->nextsibling=p; // 是上一邻接顶点的兄弟姐妹结点(第1次不通过此处,以后q已赋值) q=p; DFSTree(G,w,q); // 从第w个顶点出发深度优先遍历图G,建立子生成树q } }