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
}
}
