王道2025数据结构代码总结：第六章 图

6.2.1

图的邻接矩阵存储结构

#define MaxVertexNum 100
typedef char VertexType;
typedef int EdgeType;
typedef struct{
    VertexType vex[MaxVertexNum];
    EdgeType edge[MaxVertexNum][MaxVertexNum];
    int vernum,arcnum;
}MGraph;

6.2.2

图的邻接表的存储结构

#define MaxVertexNum 100
typedef struct ArcNode{
    int adjvex;
    struct ArcNode *nextarc;
    //InfoType info;
}ArcNode;
typedef struct Vnode{
    VertexType data;
    ArcNode *firstarc;
}Vnode,AdjList[MaxVertexNum];
typedef struct{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;

6.3.1

广度优先搜索（伪代码）

bool visited[MAX_VERTEX_NUM];
void BFSTraverse(Graph G){
    for(i=0;i<G.vexnum;++i)
        visited[i]=FALSE;
    InitQueue(Q);
    for(i=0;i<G.vexnum;++i)
        if(!visited[i])
            BFS(G,i);
}

邻接表实现广度优先搜索

void BFS(ALGraph G,int i){
    visit(i);
    visited[i]=TRUE;
    EnQueue(Q,i);
    while(!IsEmpty(Q)){
        DeQueue(Q,v);
        for(p=G.vertices[v].firstarc;p;p=p_>nextarc){
            w=p->adjvex;
            if(visited[w]==FALSE){
                visit(w);
                visited[w]=TRUE;
                EnQueue(Q,w);
            }
        }
    }
}

邻接矩阵实现广度优先搜索

void BFS(MGraph G,int i){
    visit(i);
    visited[i]=TRUE;
    EnQueue(Q,i);
    while(!IsEmpty(Q)){
        DeQueue(Q,v);
        for(w=0;w<G.vexnum,w++){
            if(visited[w]==FALSE&&G,edge[v][w]==1){
                visit(w);
                visited[w]=TRUE;
                EnQueue(Q,w);
            }
        }
    }
}

BFS算法求解单源最短路径

void BFS_MIN_Distance(Graph G,int u){
    //d[i]表示从u到i结点的最短路径
    for(i=0;i<G.vexnum;;++i)
        d[i]=∞;
    visited[u]=TRUE;
    d[u]=0;
    EnQueue(Q,u);
    while(!IsEmpyt(Q)){
        DeQueue(Q,u);
        for(w=FirstNeighbor(G,u);w>=0;w=NextNeighbor(G,u,w))
            if(!visited[w]){
                visited[w]=TRUE;
                d[w]=d[u]+1;
                EnQueue(Q,w);
            }
    }
}

6.3.2

深度优先搜索

bool visited[MAX_VERTEX_NUM];
void DFSTraverse(Graph G){
    for(i=0;i<G.vexnum;i++)
        visited[i]=FALSE;
    for(i=0;i<G.vexnum;i++)
        if(!visited[i])
            DFS(G,i);
}

邻接表实现深度优先搜索

void DFS(ALGraph G,int i){
    visit(i);
    visited[i]=TRUE;
    for(p=G.vertices[v].firstarc;p;p=p_>nextarc){
        j=p->adjvex;
        if(visited[j]==FALSE){
            DFS(G,j);
        }
    }
}

邻接矩阵实现深度优先搜索

void DFS(MGraph G,int i){
    visit(i);
    visited[i]=TRUE;
    for(j=0;j<G.vexnum;j++){
        if(visited[j]==FALSE&&G.edge[i][j]=1)
            DFS(G,j);
    }
}

6.4.1

最小生成树（模板）

GENERIC_MST(G){
    T=NULL;
    while T 未形成一棵树;
        do 找到一条最小代价边(u,v)并且加入T后不会产生回路;
            T=T∪（u,v);
}

Prim算法（模板）

void Prim(G,T){
    T=Ø;
    U={w};
    while((V-U)!=Ø){
        设(u,v)是使u∈U与v∈(V-U),且权值最小的边;
        T=T∪{(u,v)};
        U=U∪{v};
    }
}

Kruskal算法（模板）

void Kruskal(V,T){
    T=V;
    numS=n;
    while(numS>1){
        从E中取出权值最小的边(u,v);
        if(v和u属于T中不同的连通分量){
            T=T∪{(v,u)};
            numS--;
        }
    }
}

6.4.4

拓扑排序

bool TopologicalSort(Graph G){
    InitStack(S);
    int i;
    for(i=0;i<G.vexnum;i++)
        if(indegree[i]==0)
            Push(S,i);
    int count=0;
    while(!IsEmpty(S)){
        Pop(S,i);
        print[count++]=i;
        for(p=G.vertices[i].firstarc;p=p->nextarc){
        //将所有i指向的顶点的入度减1，并将入度为0的顶点压入栈S
            v=p->adjvex;
            if(!(--indegree[v]))
                Push(S,v);
        }
    }
    if(count<G.vexnum)
        return false;
    else
        return true;
}