图论源代码——数据结构课堂作业

n(*≧▽≦*)n

/*
编写程序输出以邻接表为存储结构的无向图的各顶点的度。
*/
/**********************************/
/*文件名称：lab8_01.c                 */
/**********************************/
#include "ljb.h"
/* 输出以邻接表为存储结构的无向图g的各顶点的度 */
void degree(LinkedGraph g)
{
    EdgeNode *p;
    int i;
    for (i=0; i<g.n; i++)
    {
        printf("%c's degree is ",g.adjlist[i].vertex);
        p=g.adjlist[i].FirstEdge;
        int cnt = 0;
        while (p)
        {
            cnt++;
            //printf("-->%d",p->adjvex);
            p=p->next;
        }
        printf("%d
",cnt);
    }

}


int main()
{
    LinkedGraph g;
    creat(&g,"g11.txt",0);      /*已知g11.txt中存储了图的信息*/
    printf("
 The graph is:
");
    print(g);
    degree(g);
    return 0;
}

/*
图采用邻接表存储结构，编程对图进行广度优先遍历。
*/
/**********************************/
/*文件名称：lab8_02.c                 */
/**********************************/
#include "ljb.h"
#include <queue>

using namespace std;


int visited[M];                  /*全局标志向量*/
/*请将本函数补充完整，并进行测试*/
void bfs(LinkedGraph g, int i)
{
    visited[i] = true;
    printf("%d ",i);
    EdgeNode *p;
    p=g.adjlist[i].FirstEdge;
    /*从顶点i出发广度优先变量图g的连通分量*/
    queue<int> Q;
    while (p)
    {
        if(!visited[i])
        {
            printf("%d",i);
            Q.push(i);
        }
        p=p->next;
    }
    while(!Q.empty()) {
        int u = Q.front();
        Q.pop();
        bfs(g,u);
    }

}


/*函数功能：广度优先遍历图g
  函数参数：邻接表g
*/
int BfsTraverse(LinkedGraph g)
{
    int i,count=0;
    for (i=0; i<g.n; i++)
        visited[i]=0;     /*初始化标志数组*/

    for (i=0; i<g.n; i++)
        if (!visited[i])  /*vi未访问过*/
        {
            printf("
");
            count++;            /*连通分量个数加1*/
            bfs(g,i);
        }
    return count;
}

int main()
{
    LinkedGraph g;
    int count;
    creat(&g,"g11.txt",0);          /*创建图的邻接表*/
    printf("
 The graph is:
");
    print(g);
    printf("广度优先遍历序列为：
");
    count=BfsTraverse(g);         /*从顶点0出发广度优先遍历图g*/
    //printf("
该图共有%d个连通分量。
",count);
    return 0;
}

/*
    图采用邻接表存储结构，编程对图进行深度优先遍历。
*/

#include "ljb.h"
int visited[M];
/*请将本函数补充完整，并进行测试*/

void dfs(LinkedGraph g,int i)
{
    /*从顶点i开始深度优先遍历图的连通分量*/
    EdgeNode *p;
    printf("visit vertex: %c 
",g.adjlist[i].vertex);/*访问顶点i*/
    visited[i]=1;
    p=g.adjlist[i].FirstEdge;
    while (p)                 /*从p的邻接点出发进行深度优先搜索*/
    {
        if(!visited[p->adjvex]) {
           // printf("%d
",p->adjvex);
            dfs(g,p->adjvex);
        }
        else p = p->next;
    }
}
/*函数功能：深度优先遍历图
  函数参数：图的邻接表g
*/
void DfsTraverse(LinkedGraph g)
{
    int i;
    for (i=0; i<g.n; i++)
        visited[i]=0;     /*初始化标志数组*/
    for (i=0; i<g.n; i++)
        if (!visited[i])  /*vi未访问过*/
            dfs(g,i);
}

int main()
{
    LinkedGraph g;
    creat(&g,"g11.txt",0);              /*创建图的邻接表*/
    printf("
 The graph is:
");
    print(g);
    printf("深度优先遍历序列为：
");
    DfsTraverse(g);                    /*从顶点0开始深度优先遍历图无向图g*/
}

/*********************************************/
/*           Prim求解最小生成树算法          */
/*********************************************/
#include "ljjz.h"

typedef struct edgedata  /*用于保存最小生成树的边类型定义*/
{
    int beg,en;     /*beg,en是边顶点序号*/
    int length;     /*边长*/
} edge;

/*函数功能：prim算法构造最小生成树
函数参数：图的邻接矩阵g;边向量edge
*/
void prim(Mgraph g, edge tree[M-1])
{
    edge x;
    int d,min,j,k,s,v;

    /* 建立初始入选点，并初始化生成树边集tree*/
    int i;
    int dis[M];
    int vis[M];
    int pre[M];
    for(i=0; i<g.n; i++)
    {
        pre[i] = 0;
        vis[i] = 0;
        dis[i] = FINITY;
        tree[i].length = FINITY;
        tree[i].beg = tree[i].en = -1;
    }

    int ans = 0;
    dis[0] = 0;

    for(i=0; i<g.n; i++)
    {
        /*依次求当前(第k条）最小两栖边，并加入TE*/
        int tmp = FINITY,k=-1;
        for(j=0; j<g.n; j++)
        {
            if(!vis[j]&&dis[j]<tmp)
            {
                tmp = dis[j];
                k = j;
            }
        }
        if(tmp!=0) {
            tree[i-1].length = tmp;
            tree[i-1].beg = pre[k];
            tree[i-1].en = k;
        }

        vis[k] = 1;
        ans +=tmp;
        /*由于新顶点v的加入，修改两栖边的基本信息*/
        for(s=0; s<g.n; s++) {
            if(!vis[s]&&dis[s]>g.edges[k][s]) {
                dis[s] = g.edges[k][s];
                pre[s] = k;
            }
        }
    }

    /*输出最小生成树*/
    printf("
最小生成树是:
");/*输出最小生成树*/
    for (j=0; j<=g.n-2; j++)
        printf("
%c---%c  %d
",g.vexs[tree[j].beg],g.vexs[tree[j].en],tree[j].length);    //顶点信息
    printf("
最小生成树的根是： %c
", g.vexs[0]);
    printf("%d
",ans);
}

int  main()
{
    Mgraph g;
    edge  tree[M-1];  /*用于存放最小生成树的M-1条边*/
    creat(&g,"g.txt",0);  /*创建无向图的邻接矩阵*/

    print(g);
    prim(g,tree);        /*求解图的最小生成树*/
    return 0;

}

/***************************************************/
/*          Dijkstra单源最短路径算法               */
/***************************************************/
#include "ljjz.h"   /*引入邻接矩阵创建程序*/
#include "cstring"
#include "algorithm"

using namespace std;

typedef enum {FALSE,TRUE} boolean; /*false为0,true为1*/
typedef int dist[M];  /* 距离向量类型*/
typedef int path[M];  /* 路径类型*/

/*函数功能：Dijkstra算法求解单源最短路径
函数参数：图的邻接矩阵g;源点v0;路径向量p；距离向量d
*/
void dijkstra(Mgraph g,int v0,path p,dist d)
{
    //boolean final[M]; /*表示当前元素是否已求出最短路径*/
    //int i,k,j,v,min,x;
    bool final[M];
    memset(final,0,sizeof(final));

    /*  第1步  初始化集合S与距离向量d */
    for(int i=0; i<g.n; i++)
    {
        p[i] = v0;
        d[i] = g.edges[v0][i];
    }

    final[v0] = true;
    p[v0] = -1;

    for(int i=0; i<g.n-1; i++)
    {
        /* 第2步  依次找出n-1个结点加入S中   */
        int tmp = FINITY,k = v0;
        for(int j=0; j<g.n; j++)
        {
            if(final[j]) continue;
            if(tmp>d[j])
            {
                tmp = d[j];
                k = j;
            }
        }
        /*第3步 修改S与V-S中各结点的距离*/
        final[k] = true;
        for(int j=0; j<g.n; j++)
        {
            if(final[j]) continue;
            if(d[j]>d[k]+g.edges[k][j]&&g.edges[k][j]<FINITY)
            {
                d[j] = d[k]+g.edges[k][j];
                p[j] = k;
            }
        }
    }
}
/*函数功能：输出有向图的最短路径
函数参数：邻接矩阵g；路径向量p；距离向量d
*/
void print_gpd(Mgraph g,path p,dist d)
{
    int st[M],i,pre,top=-1;
    for (i=0; i<g.n; i++)
    {
        printf("
Distancd: %7d , path:",d[i]);
        st[++top]=i;
        pre=p[i];
        while (pre!=-1)   /*从第i个顶点开始向前搜索最短路径上的顶点*/
        {
            st[++top]=pre;
            pre=p[pre];
        }
        while (top>0)
            printf("%2d",st[top--]);
    }
}
/*---------- 主程序 ------------*/
int main()
{
    Mgraph g;   /* 有向图 */
    path p;     /* 路径向量 */
    dist d;     /* 最短路径向量 */
    int v0;
    creat(&g,"g21.txt",1); /*假设图8.21所示的有向网G21的输入文件为g21.txt */
    print(g);        /*输出图的邻接矩阵*/
    printf("
");
    printf("请输入源点编号：");
    scanf("%d",&v0);       /*输入源点*/
    dijkstra(g,v0,p,d);   /*求v0到其他各点的最短距离*/
    /*输出V0到其它各点的路径信息及距离*/
    print_gpd(g,p,d);

    return 0;
}

/***************************************/
/*             拓扑排序算法            */
/***************************************/
#include<stdlib.h>
#include<stdio.h>
#define M 20
typedef char vertextype;
typedef struct node       /*边结点类型定义*/
{
    int adjvex;
    struct node *next;
} edgenode;
typedef struct de         /*带顶点入度的头结点定义*/
{
    edgenode* FirstEdge;
    vertextype vertex;
    int id;                /*顶点的入度域*/
} vertexnode;

typedef struct            /*AOV网络的邻接表结构*/
{
    vertexnode adjlist[M];
    int n,e;
} AovGraph;

void  creat(AovGraph *g,char *filename)       /*建立AOV网络的存储结构*/
{
    int i,j,k;
    edgenode  *s;
    FILE *fp;
    fp=fopen(filename,"r");
    if (fp)
    {
        fscanf(fp,"%d%d",&g->n,&g->e);  /*输入图中的顶点数与边数*/

        for(i=0; i<g->n; i++)                      /*输入顶点值*/
        {
            fscanf(fp,"%1s",&g->adjlist[i].vertex);
            g->adjlist[i].FirstEdge=NULL;
            g->adjlist[i].id=0;       /*入度初始化为0*/
        }
        for(k=0; k<g->e; k++)
        {
            fscanf(fp,"%d%d",&i,&j);
            s=(edgenode*)malloc(sizeof(edgenode));
            s->adjvex=j;
            g->adjlist[j].id++;    /*顶点j的入度加1*/
            s->next=g->adjlist[i].FirstEdge;
            g->adjlist[i].FirstEdge=s;
        }
    }
}

void print(AovGraph g)
{
    edgenode *p;
    int i;
    for (i=0; i<g.n; i++)
    {
        printf("%c %d   ", g.adjlist[i].vertex,g.adjlist[i].id);
        p=g.adjlist[i].FirstEdge;
        while (p)
        {
            printf("%d-->",p->adjvex);
            p=p->next;
        }
        printf("
");
    }
}
/*函数功能：拓扑排序
函数参数：AOV网邻接表存储结构变量g
函数返回值：拓扑排序输出的顶点个数
*/
int TopSort(AovGraph g)
{
    int k=0,i,j,v, flag[M];
    int queue[M];  /*队列*/
    int h=0,t=0;
    edgenode* p;
    for (i=0; i<g.n; i++)  flag[i]=0; /*访问标记初始化*/
    /*先将所有入度为0的结点进队*/
    /*将程序补充完整*/

    for(int i=0; i<g.n; i++)
    {
        for(int j=0; j<g.n; j++)
        {
            if(g.adjlist[j].id==0)
            {
                printf("%d ",j);
                g.adjlist[j].id = -1;
                p=g.adjlist[i].FirstEdge;
                while (p)
                {
                    g.adjlist[p->adjvex].id--;
                    //printf("%d-->",p->adjvex);
                    p=p->next;
                }
                break;
            }
        }
    }

    return k;  //返回输出的顶点个数
}
int main()
{
    int k=0;
    AovGraph g;
    creat(&g,"aov.txt");    /*假设图8.25所示的AOV网输入文件为aov.txt*/
    printf("
图8.27所示AOV网的邻接表是：
");
    print(g);
    k=TopSort(g);
    if(k<g.n) printf("
该图存在环！
");
    return 0;
}