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");
}
/**
* 算法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;
}
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;
}
/*深度遍历*/
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;
}
// 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);
}
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);
}
/**
* 算法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);
}
}
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
}
/* 若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 */
}
/*
* @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);
}
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);
}
}
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;
}
// 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
}
}
void DFSTree(ALGraph G, int v, CSTree &T)
{
// 从第v个顶点出发深度优先遍历图G,建立以T为根的生成树。算法7.8
Boolean first = TRUE;
int w;
CSTree p, q; //孩子兄弟树p、q
VertexType v1, w1;
visited[v] = TRUE;
v1=GetVex(G, v); //顶点v1序号为v
// w依次为v的邻接顶点
//w初始化为v1第一个邻接点序号
//只要w大于等于0，就执行循环体
//循环体完毕，w取v1的(相对于w1（序号w）的)下一个邻接顶点的序号，准备下轮循环
for (w=FirstAdjVex(G,v1); w>=0; w=NextAdjVex(G,v1,w1=GetVex(G,w)))
if (!visited[w]) // w顶点不曾被访问
{
p = (CSTree) malloc(sizeof (CSNode)); // 分配新孩子结点
p->data=GetVex(G, w); //v的当前邻接顶点复制到新结点
p->firstchild = NULL;
p->nextsibling = NULL;
if (first) // w是v的第一个未被访问的邻接顶点
{
T->firstchild = p; //树T的长子取新结点
first = FALSE; // 长子标志置假
}
else // w是v的其它未被访问的邻接顶点，是上一邻接顶点的兄弟结点
q->nextsibling = p; // 上一邻接顶点的兄弟结点取新结点
q = p; //q取新结点
DFSTree(G, w, q); // 从第w个顶点出发深度优先遍历图G,递归建立以q为根的子生成树
}
}
void DFSTree(Graph G, int v, CSTree &T)
{
Boolean first = TRUE;
int w;
CSTree p, q;
visited[v] = TRUE;
for (w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w))
if (!visited[w]) {
p = (CSTree)malloc(sizeof(CSNode));
p->data = GetVex(G, w);
p->firstchild = NULL;
p->nextsibling = NULL;
if (first) {
T->firstchild = p;
first = FALSE;
} else {
q->nextsibling = p;
}
q = p;
DFSTree(G, w, q);
}
}
