图论——邻接矩阵表示法

(1)-邻接矩阵表示法

构成:    顶点数量,边数量;   顶点的下标(一维数组),边的信息(二维数组).

#include<iostream>
using namespace std;
int maxsize=100;
int maxnum=32767;

typedef struct{
    int edgenum,vecnum;
    int *point;
    int weight[100][100];
}AMGraph;

void CreateWuXiangGraph(AMGraph &g,int v,int e){
    g.edgenum=e;        g.vecnum=v;
    g.point=new int[v];
    for(int i=0;i<v;i++)
        g.point[i]=i;
    for(int i=0;i<v;i++)
        for(int j=0;j<v;j++)
        g.weight[i][j]=(i==j)?0:maxnum; //若两点不等且无边,则将其值设为最大值,若两点相等且无边,则设为0

    int v1,v2,ee;
    for(int i=0;i<e;i++)
    {
        cin>>v1>>v2>>ee;
        g.weight[v1][v2]=ee;    //g.weight[v2][v1]=ee;
    }
}

void ShowGraph(AMGraph g){
    for(int i=0;i<g.vecnum;i++)
        for(int j=0;j<g.vecnum;j++)
        if(g.weight[i][j]<maxnum&&g.weight[i][j])
            cout<<"V"<<i<<"->"<<"V"<<j<<"("<<g.weight[i][j]<<")"<<endl;
}

(2)-图的最小生成树

1.Prim算法; 以某顶点为起点,逐步找各顶点上最小权值来构建最小生成树.

void Prim(AMGraph g){
    int MinPoint[g.vecnum];
    int MinWeight[g.vecnum];
    for(int i=0;i<g.vecnum;i++)
    {
        MinWeight[i]=g.weight[0][i];
        MinPoint[i]=0;
    }
    MinWeight[0]=0;
    for(int i=1;i<g.vecnum;i++)
    {
        int minnum=maxnum,k=0;
        for(int j=1;j<g.vecnum;j++)
            if(MinWeight[j]&&minnum>MinWeight[j]){
                minnum=MinWeight[j];
                k=j;
            }
              MinWeight[k]=0;
             cout<<"V"<<MinPoint[k]<<"->"<<"V"<<k<<endl;
             for(int j=1;j<g.vecnum;j++)
             {
                 if(MinWeight[j]&&MinWeight[j]>g.weight[k][j]){
                     MinWeight[j]=g.weight[k][j];
                     MinPoint[j]=k;
                 }
             }
    }
}

2.Kruskal算法：以边为目标,逐步根据权值的大小的构建最小生成树

typedef struct{
    int head,tail;
    int weight;
}Edge,*PEdge;

PEdge Sort(AMGraph g){
    PEdge e=new Edge[g.edgenum];
    int k=0;
    for(int i=0;i<g.vecnum;i++)
        for(int j=0;j<g.vecnum;j++)
        if(g.weight[i][j]&&g.weight[i][j]<maxnum){
            e[k].head=i;        e[k].tail=j;
            e[k].weight=g.weight[i][j];
            k++;
        }
    for(int i=0;i<g.edgenum-1;i++)
        for(int j=i+1;j<g.edgenum;j++)
            if(e[i].weight>e[j].weight){
                Edge tmp=e[j];
                e[j]=e[i];
                e[i]=tmp;
            }
        return e;
}

int Find(int *visited,int f){
    while(visited[f])
        f=visited[f];
    return f;
}

void Kruskal(AMGraph g){
    PEdge e=Sort(g);
    int visited[g.vecnum]={0};
    for(int i=0;i<g.edgenum;i++)
    {
        int n=Find(visited,e[i].head);
        int m=Find(visited,e[i].tail);
        if(n!=m){
            visited[n]=m;
            cout<<"V"<<e[i].head<<"->V"<<e[i].tail<<"("<<e[i].weight<<")"<<endl;
        }
    }
}