运用DFS算法解决的图的相关算法应用

/*
求无向图G的连通分量个数
dfs运用
*/
void DFS(Graph G,int v){
    ENode *p;
    visited[v]=true;
    visit(t);
    p=G->adjList[v].firstarc;
    while(p!=null){
        if(visited[p->adjvex]==false){
            DFS(G,p->adjvex);
        }
        p=p->nextarc;
    }
}
int ComnNum(Graph G){
    int num=0;
    for(int i=0;i<G->vertices;i++){
        visited[i]=false;
    }
    for(int i=0;i<G->vertices;i++){
        if(visited[i]==false){
            DFS(G,i);
            num++;
        }
    }
}

/*
图G采用邻接表存储
设计一个算法判断图G是否是连通图
*/
void DFS(Graph G,int v){
    ENode *p;
    visited[v]=true;
    visit(v);
    p=G->adjList[v].firstarc;
    while(p!=null){
        if(visited[p->adjvex]==false){
            DFS(G,p->adjvex);
        }
        p=p->nextarc;
    }
}
bool IsConnect(Graph G){
    bool flag=true;
    int visited[maxsize];
    for(int i=0;i<g.Vertices;i++){
        visited[i]=false;
    }
    DFS(G,0);
    for(int i=0;i<G->vertices;i++){
        if(visited[i]==false){
            flag=false;
            break;
        }
    }
    return flag;
}

/*
判断有向图的邻接表中是否有Vi->Vj的路径
*/
void DFS(Graph G,int v){
    ENode *p;
    visited[v]=true;
    visit(t);
    p=G->adjList[v].firstarc;
    while(p!=null){
        if(visited[p->adjvex]==false){
            DFS(G,p->adjvex);
        }
        p=p->nextarc;
    }
}
bool visited[maxsize];
bool existPath(Graph G,int v,int j){
    for(int i=0;i<G->vertices;i++){
        visited[i]=false;
    }
    DFS(G,v);
    if(visited[j]==false){
        return false;
    }else{
        return true;
    }
}

/*
设计一个函数concomx()，求用邻接表存储的无向图中
节点总数恰好为k 的连通分量个数
*/
void DFS(Graph G,int v,bool &visited[],int &Vnum){
    ENode *p;
    visited[v]=true;
    Vnum++;
    for(p=adjList[v]->firstarc;p;p=p->next){
        if(visited[p->adjvex]==flase){
            DFS(G,p->adjvex,visited,Vnum);
        }
    }
}
bool visited[maxsize];
int concomx(Graph G,int k){//结点个数
    int count=0;//记录连通分量个数
    int Vnum=0;
    for(int i=0;i<G.vertices;i++){
        visited[i]=false;
    }
    for(int i=0;i<G.vertices;i++){
        Vnum=0;
        if(visited[i]==false){
            DFS(G,i,visited,Vnum);
        }
        if(Vnum==k) count++;
    }
    return count;
}

/*
设计一个算法，判断一个无向图G是否为一棵树。
是树返回true 否则false

结论：用DFS 访问节点数为n 访问的边数为2(n-1)
如果是一棵树 访问边数为2(n-1)
*/
void DFS(Graph G,int v,int &Vnum,int &Enum){
    ENode *pl
    visited[v]=true;
    Vnum++;//
    p=adjList[v].firstarc;
    while(p!=null){
        Enum++;//
        if(visited[p->adjvex]==false){
            DFS(G,p->adjvex,Vnum,Enum);
        }
        p=p->nextarc;
    }
}
bool IsTrre(Graph G){
    int Vnum=0,Enum=0;
    for(int i=0;i<G.vertices;i++){
        visited[i]=false;
    }
    DFS(G,1,Vnum,Enum);
    if(Vnum==g.vertices && Enum==2*(Vnum-1)){
        return true;
    }else{
        return false;
    }
}

//无向图G用邻接矩阵G，给定顶点v0出发深度遍历图G，
//并将产生的深度遍历生成树存在邻接矩阵B中
void DFS(Graph G,int b[][maxsize],int v){
    visited[v]=true;
    for(int j=0;j<G.vertices;j++){
        if(G.A[v][j]&&!visited[j]){
            b[v][j]=1;
            DFS(g,j,b);
        }
    }
}
bool visited[maxsize];
void shengchengTree(Graph g,int b[][maxsize]){
    for(int i=0;i<G.vertices;i++){
        visited[i]=false;
    }
    for(int i=0;i<G.vertices;i++){
        if(!visited[i]){
            DFS(G,b,i);
        }
    }
}