图的算法

1. 图的存储结构：

　　　　（1）     邻接矩阵

typedef struct{
    int no;//顶点编号
    char data[MAXL];//顶点其他信息 
}VertexType;//顶点类型 

typedef struct{
    int edges[MAXV][MAXV];//边数组 
    int n,e;//顶点数、边数
    VertexType vexs[MAXV];//存放顶点信息 
}MGraph;//完整的图邻接矩阵类型 

 

　　　　（2）     邻接表

typedef struct ANode{
    int adjvex;//终点编号 
    int weight;//权重 
    struct ANode *nextarc;//指向下一条边 
}ArcNode;//边节点类型 

typedef struct Vnode{
    char data[MAXL];//顶点的其他信息 
    ArcNode *firstarc;//指向第一条边 
}VNode;//表头结点类型 

typedef struct{
    VNode adjlist[MAXV];//邻接表 
    int n,e;//顶点数、边数 
}ALGraph; //完整的图邻接表类型

 

1. 遍历：访问图中所有点仅一次，设置visited[MAXV]数组

　　　　（1）     深度优先遍历DFS，递归回溯遍历所有顶点，常用于图的路径查找

//基于递归的邻接矩阵的深搜 
void DFS(MGraph g,int v){
    cout<<v<<" ";
    visited[v]=1;
    for(int i=0;i<g.n;i++){
        if(g.edges[v][i]!=0&&g.edges[v][i]!=INF&&visited[i]==0){
            DFS(g,i);
        }
    }
} 

//基于递归的邻接表的深搜 
void DFS(ALGraph *g,int v){
    cout<<v<<" ";
    visited[v]=1;
    ArcNode *p=g->adjlist[v].firstarc;
    while(p!=NULL){
        if(visited[p->adjvex]==0) DFS(g,p->adjvex);
        p=p->nextarc;
    }
}

 

　　　　（2）     广度优先遍历BFS，需要使用先进先出的队列

//使用队列的邻接矩阵的广搜
void BFS(MGraph g,int v){
    queue<int> qu;
    cout<<v<<" ";
    visited[v]=1;
    qu.push(v);
    while(!qu.empty()){
        int w=qu.front();
        qu.pop();
        for(int i=0;i<g.n;i++){
            if(g.edges[w][i]!=0&&g.edges[w][i]!=INF&&visited[i]==0){
                cout<<i<<" ";
                visited[i]=1;
                qu.push(i);
            }
        }
    }
} 

 

1. 最小生成树

　　　　（1）     Pirm算法：在两个顶点集之间选择权最小的边

void Prim(MGraph g,int v){
    int lowcost[MAXV];//各点到U的最短距离
    int mincost;
    int closet[MAXV],i,j,k;//lowcost最短距离的上一个节点是 
    for(j=0;j<g.n;j++){
        lowcost[j]=g.edges[v][j];
        closet[j]=v;
    } 
    for(i=1;i<g.n;i++){
        mincost=INF;
        for(j=0;j<g.n;j++){
            if(lowcost[j]!=0&&mincost<lowcost[j]){
                mincost=lowcost[j];
                k=j;
            }
        }
        cout<<closet[k]<<"到"<<k<<"权为"<<mincost<<endl;
        lowcost[k]=0;
        for(j=0;j<g.n;j++){
            if(lowcost[j]>g.edges[k][j]&&g.edges[k][j]!=0){
                lowcost[j]=g.edges[k][j];
                closet[j]=k;
            }
        }
    } 
} 

 

　　　　（2）     Kruskal算法：按边权值从小到大，如果未使生成树形成回路则加入，关键是判断是否是回路　　　　（并查集）

　　　　*并查集以及并查集的优化

1. 最短路径

　　　　（1）     Dijkstra算法（单源最短路径）：

void Dijkstra(MGraph g,int v){
    int dist[MAXV],path[MAXV];
    int S[MAXV];
    int min,i,j,u;
    //初始化
    for(i=0;i<g.n;i++){
        dist[i]=g.edges[v][i];
        S[i]=0;
        if(g.edges[v][i]<INF) path[i]=v;
        else path[i]=-1;
    } 
    S[v]=1;path[v]=0;
    //求最短路径 
    for(i=0;i<g.n;i++){
        min=INF;
        //找到目前最小 
        for(j=0;j<g.n;j++){
            if(min>dist[j]&&S[j]==0){
                min=dist[j];
                u=j;
            }
        }
        S[u]=1;
        //看看新的点能否使更小 
        for(j=0;j<g.n;j++){
            if(g.edges[u][j]+dist[u]<dist[j]&&g.edges[u][j]<INF){
                dist[j]=g.edges[u][j]+dist[u];
                path[j]=u;
            }
        }
    }
} 

 

　　　　（2）     Bellman-Ford算法（单源最短路径、允许存在负边）：n-1次松弛，可以用来判断是否存在负回路

void BellmanFord(MGraph g,int v){
    int i,k,u;
    int dist[MAXV],path[MAXV];
    for(i=0;i<g.n;i++){
        dist[i]=g.edges[v][i];
        if(i!=v&&dist[i]<INF)path[i]=v;
        else path[i]=-1;
    }
    for(k=1;k<g.n;k++){//dist\path数组的变化次 
        for(u=0;u<g.n;u++){
            if(u!=v){
                for(i=0;i<g.n;i++){
                    if(g.edges[i][u]<INF&&dist[u]>dist[i]+g.edges[i][u]){
                        dist[u]=dist[i]+g.edges[i][u];
                        path[u]=i;
                    }
                }
            }
        }
    }
} 

 

　　　　（3）     SPFA算法（单源最短路径、允许存在负边但不负权回路）：需要用到图的邻接表

void SPFA(ALGraph *g,int s){
    int dist[MAXV],path[MAXV],visited[MAXV];
    int v,w;
    ArcNode *p;
    queue<int> qu;
    for(int i=0;i<g->n;i++){
        dist[i]=INF;
        visited[i]=0;
        path[i]=-1;
    }
    dist[s]=0;
    visited[s]=1;
    qu.push(s);
    while(!qu.empty()){
        v=qu.front();
        qu.pop();
        visited[v]=0;
        p=g->adjlist[v].firstarc;
        while(p!=NULL){
            w=p->adjvex;
            if(dist[w]>dist[v]+p->weight){
                dist[w]=dist[v]+p->weight;
                path[w]=v;
                if(visited[w]==0){
                    qu.push(w);
                    visited[w]=1;
                }
            }
            p=p->nextarc;
        }
    }
} 

 

　　　　（4）     Floyd算法（多源最短路径）：dp

void floyd(MGraph g){
    int a[MAXV][MAXV],path[MAXV][MAXV];
    int i,j,k;
    for(i=0;i<g.n;i++){
        for(j=0;j<g.n;j++){
            a[i][j]=g.edges[i][j];
            if(i!=j && g.edges[i][j]<INF) path[i][j]=i;
            else path[i][j]=-1;
        }
    }
    for(k=0;k<g.n;k++){
        for(i=0;i<g.n;i++){
            for(j=0;j<g.n;j++){
                if(a[i][j]>a[i][k]+a[k][j]){
                    a[i][j]=a[i][k]+a[k][j];
                    path[i][j]=path[k][j];
                }
            }
        }
    }
}