自己总结的关于图论的一些算法实现（C语言实现，有较详细注释，800行左右）

(提示，是C语言实现。)

代码仅供学习使用，如果觉得不错的话，点个赞喔~~Thanks

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define TRUE 1
#define FALSE 0
#define inf 99999
typedef  int BOOL;
typedef  int ElemType;
typedef struct mGraph
{
    ElemType **a;     //邻接矩阵
    int n;            //图的当前顶点数
    int e;            //图的当前边数
    ElemType noEdge;  //两顶点间无边时的值
}MGraph;
typedef struct queue
{
    int front;      //队头
    int rear;       //队尾
    int MaxSize;     //队的最大容量
    ElemType *element;  //存储元素
}Queue;
typedef struct eNode
{
    int adjVex;       //与任意顶点u相邻接的顶点
    ElemType w;       //边的权值
    struct eNode *nextArc;  //指向下一个结点
}ENode;
typedef struct lGraph
{
    int n;               //图当前的顶点数
    int e;               //图当前的边数
    ENode **a;           //指向一维指针数组
}LGraph;
typedef struct stack
{
    int top;       //栈顶
    int maxSize;   //栈所能装最大元素量
    ElemType *element;  //数据
}Stack;

int vis_m[1000];   //邻接矩阵对应图的标记数组。 vis_m[i]用于表示 编号为i的结点是否被使用过，没有使用过则 =0，否则 =1;
int vis_l[1000];   //邻接表对应图的标记数组。 vis_m[i]用于表示 编号为i的结点是否被使用过，没有使用过则 =0，否则 =1;
int path[1000];    //用于记录最佳路径上的结点编号
int Min_Time=999999;       //用于记录最佳路径所花费的时间，初始化时尽量使它大
int count;        //记录最佳路径上结点的个数
int load[1000];   //用于图的遍历，让遍历路径数组的储存空间足够大
int cnt;          //用于表示load[]数组的下标

void Clear_Flag() //标记清零操作
{
    int i;
    cnt=0;
    for( i=0;i<1000;i++ )
        load[i]=vis_m[i]=vis_l[i]=0;
}

void Create_S( Stack *s,int size )  //创建栈
{
    s->maxSize=size;
    s->top=-1;       //现在栈还是空的，所以栈顶为“-1”
    s->element=(ElemType*)malloc(sizeof(ElemType));
}
void Destroy_S( Stack *s )  //销毁栈
{
    s->top=-1;
    s->maxSize=0;
    free(s->element);  //因为只申请了一次，所以只释放一次
}
BOOL IsEmpty_S( Stack *s )  //判断栈是否为空栈
{
    return s->top==-1;
}
BOOL IsFull_S( Stack *s )  //判断一个栈是否已满
{
    return s->top==s->maxSize-1;
}
void Top_S( Stack *s,ElemType *x )  //获取栈顶元素
{
    if( IsEmpty_S(s) )  //如果栈为空
    {
        printf("现在栈为空栈，没有东西可取喔。
");
        return ;
    }
    *x=s->element[s->top];
}
void Push_S( Stack *s,ElemType x )  //入栈
{
    if( IsFull_S(s) )  //如果栈已满
    {
        printf("现在栈已满，不能再装东西啦喔。
");
        return ;
    }
    s->top++;
    s->element[s->top]=x;
}
void Pop_S( Stack *s ) //删除栈顶元素
{
    if( IsEmpty_S(s) )  //如果栈为空
    {
        printf("现在栈为空栈喔。
");
        return ;
    }
    s->top--;
}
void Clear_S( Stack *s )  //清空栈，但不释放空间
{
    s->top=-1;
}

void Create_Q( Queue *q,int size )  //创建队列
{
    q->front=q->rear=0;   //创建时，这里为0，都指向队头
    q->MaxSize=size;
    q->element=(ElemType*)malloc(size*sizeof(ElemType));
}
void Destroy_Q( Queue *q )  
{
    q->front=q->rear=-1;
    q->MaxSize=0;
    free(q->element);
}
void Clear_Q( Queue *q )
{
    q->front=q->rear=0;   //注意这里也是0，清空时，让它俩都指向队头
}
BOOL IsEmpty_Q( Queue *q )  //判断队列是否为空
{
    return q->front==q->rear;
}
BOOL IsFull_Q( Queue *q )   //判断队列是否已满
{
    return (q->rear+1)%q->MaxSize==q->front;  
}
void Push_Q( Queue *q,ElemType x )
{
    if( IsFull_Q(q) )
    {
        printf("队列已满，无法再进行入队操作！
");
        return ;
    }
    q->rear=(q->rear+1)%q->MaxSize;
    q->element[q->rear]=x;
}
void DeQueue_Q( Queue *q )   //删除队头元素，出队操作
{
    if( IsEmpty_Q(q) )
    {
        printf("队列为空，无法再进行出队操作！
");
        return ;
    }
    q->front=(q->front+1)%q->MaxSize;
}
void Front_Q( Queue *q,ElemType *x )  //获取队头元素
{
    if( IsEmpty_Q(q) )
    {
        printf("队列为空，无法获取队头元素！
");
        return ;
    }
    *x=q->element[(q->front+1)%q->MaxSize];
}


void Init_M( MGraph *mg,int v,ElemType noEdge )   //v为顶点数，noEdge为：两顶点无边时的值
{
    int i,j;
    mg->n=v;
    mg->e=0;           //初始化时没有边
    mg->noEdge=noEdge;
    mg->a=(ElemType**)malloc(mg->n*sizeof(ElemType*));      //申请二维动态空间
    for( i=0;i<mg->n;i++ )
    {
        mg->a[i]=(ElemType*)malloc(mg->n*sizeof(ElemType));  //申请一维动态空间
        for( j=0;j<mg->n;j++ )
            mg->a[i][j]=mg->noEdge;
        mg->a[i][i]=0;    
    }
    printf("邻接矩阵已成功初始化！
");
    return ;
}
void Destroy_M( MGraph *mg )
{
    int i;
    for( i=0;i<mg->n;i++ )   //申请了几次一维动态空间就要释放几次
        free(mg->a[i]);
    free(mg->a);
    printf("邻接矩阵已经成功撤销！
");
    return ;
}
BOOL Find_M_E( MGraph *mg,int u,int v )   //邻接矩阵的边的搜索,u为出发点，v为被指向点
{
    if( u<0||u>=mg->n||v<0||v>=mg->n||u==v )   //增强代码的健壮性，判断错误输出
    {
        printf("请输入正确的 你所要找查的边的两端的结点值！
");
        return FALSE;
    }
    if( mg->a[u][v]==mg->noEdge )   //如果 u→v 没有边
        return FALSE;
    else              
        return TRUE;
}
void Insert_M_E( MGraph *mg,int u,int v,ElemType x )   //邻接矩阵的边的插入
{
    if( u<0||u>=mg->n||v<0||v>=mg->n||u==v )   //增强代码的健壮性，判断错误输出
    {
        printf("请输入正确的 你所要找插入的边的两端的结点值！
");
        return ;
    }
    if( Find_M_E(mg,u,v) )   //如果该边的已经有了，则不能在进行重复插入操作
    {
        printf("该边已经在图中存在了，请勿重复插入！
");
    }
    else
    {
        mg->a[u][v]=x;  //执行插入操作
        mg->e++;
    }
}
BOOL Delete_M_E( MGraph *mg,int u,int v )   //邻接矩阵的边的删除
{
    if( u<0||u>=mg->n||v<0||v>=mg->n||u==v )   //增强代码的健壮性，判断错误输出
    {
        printf("请输入正确的 你所要找删除的边的两端的结点值！
");
        return FALSE;
    }
    if( !Find_M_E(mg,u,v) )   //如果该边的在图中本身就没有，则不能在进行删除操作
    {
        printf("该边在图中不存在！
");
        return FALSE;
    }
    else
    {
        mg->a[u][v]=mg->noEdge;
        mg->e--;
        return TRUE;
    }
}

//以上述邻接矩阵为存储结构，编写程序，实现图的深度优先遍历、宽度优先遍历
void Dfs_M( MGraph *mg,int u )  //u为开始遍历的起点
{
    int i=0;
    if( !vis_m[u] )
    {
        printf("%3d ",u);
        load[cnt++]=u;
        vis_m[u]=1;    //编号为u的结点 的标记改变
    }
    while( i<mg->n )
    {
        if( !vis_m[i]&&mg->a[u][i]!=mg->noEdge&&u!=i )  //如果u→编号为i的结点有边，并且结点i未被“走过”（即标记过）
        {  
            Dfs_M( mg,i );
        }
        i++;
    }
}
void Bfs_M( MGraph *mg,int u ) //u为开始遍历的起点
{
    int i;
    Queue q;
    Create_Q(&q,mg->n);  //创建队列，最大容量要+1才行
    vis_m[u]=1;            //编号为u的结点 的标记改变
    Push_Q(&q,u);           //编号为u的结点 压入
    while( !IsEmpty_Q(&q) )  //只要队列还不为空，就继续执行
    {
        Front_Q(&q,&u);       //将队头元素传给u
        printf("%3d ",u);      //打印
        load[cnt++]=u;
        DeQueue_Q(&q);        //将队头元素去掉
        for( i=0;i<mg->n;i++ )
        {
           if( !vis_m[i]&&mg->a[u][i]!=mg->noEdge&&u!=i )  //如果u→编号为i的结点有边，并且结点i未被“走过”（即标记过）
           {
             Push_Q(&q,i);
             vis_m[i]=1;   //标记改变
            }
        }
    }
    Destroy_Q(&q);   //撤销队列
    return ;
}

void Init_L( LGraph *lg,int size )   //x表示顶点数的意思
{
    int i;
    lg->n=size;
    lg->e=0;       //刚开始图是没有边的
    lg->a=(ENode**)malloc(lg->n*sizeof(ENode*));
    for( i=0;i<lg->n;i++ )
        lg->a[i]=NULL;      //将指针数组a置空
    return ; 
}
void Destroy_L( LGraph *lg )
{
    ENode *front,*cur;    //指针cur用于释放，指针front用于遍历
    int i;
    for( i=0;i<lg->n;i++ )
    {
        front=lg->a[i];   //指针front指向顶点i的单链表的第一个边结点
        cur=front;
        while( cur )   
        {
            front=front->nextArc;   
            free(cur);
            cur=front;
        }
    }
    free( lg->a );       //释放一维指针数组a的存储空间
    return ;
}
BOOL Find_L_E( LGraph *lg,int u,int v )   //邻接表 边的搜索
{
    ENode *fp=lg->a[u];
    if( u<0||u>=lg->n||v<0||v>=lg->n||u==v )   //增强代码的健壮性，判断错误输出
    {
        printf("请输入正确的 你所要找查的边的两端的结点值！
");
        return FALSE;
    }
    while( fp&&fp->adjVex!=v )   
    {
        fp=fp->nextArc;
    }
    if( fp!=NULL )   //若找到了这条边
        return TRUE;
    else
        return FALSE;
}
void Insert_L_E( LGraph *lg,int u,int v,ElemType w )
{
    ENode *fp;   //front作为前驱指针，指向插入位置的前一个结点
    if( u<0||u>=lg->n||v<0||v>=lg->n||u==v )   //增强代码的健壮性，判断错误输出
    {
        printf("请输入正确的 你所要找插入的边的两端的结点值！
");
        return ;
    }
    if( Find_L_E(lg,u,v) )   //如果在图中找到这条边
    {
        printf("该边已经在图中存在了，请勿重复插入！
");
        return ;
    }
    else
    {
        fp=(ENode*)malloc(sizeof(ENode));  //为新的边结点分配存储空间
        fp->adjVex=v;
        fp->w=w;
        fp->nextArc=lg->a[u];         //将新的边结点插入单链表的最前面
        lg->a[u]=fp;
        lg->e++;            //细节
    }
}        
BOOL Delete_L_E( LGraph *lg,int u,int v )
{
    ENode *front,*fp;   //一般情况下，前驱结点front指向删除结点fp 的前一个结点
    if( u<0||u>=lg->n||v<0||v>=lg->n||u==v )   //增强代码的健壮性，判断错误输出
    {
        printf("请输入正确的 你所要删除的边的两端的结点值！
");
        return FALSE;
    }
    front=NULL;
    fp=lg->a[u];
    while( fp&&fp->adjVex!=v )     //找查待删除的边是否存在
    {
        front=fp;
        fp=fp->nextArc;
    }
    if( fp==NULL )  //指针fp为空，说明该边不存在
    {
        printf("你所要删除的边在图中不存在！
");
        return FALSE;
    }
    if( front==NULL )   //前驱结点为空，说明，要删除的边在表头
    {
        lg->a[u]=fp->nextArc;
        free(fp);
    }
    else       //否则要删除的边不在表头
    {
        front->nextArc=fp->nextArc;
        free(fp);
    }
    lg->e--;    //细节
    return TRUE;
}

/* 以上述邻接表为存储结构，编写程序，实现图的深度、宽度优先遍历 */
void Dfs_L( LGraph *lg,int u )  //u为开始遍历的起点 
{
    ENode *fp;
    printf("%3d ",u);
    load[cnt++]=u;
    vis_l[u]=1;        //标记改变
    for( fp=lg->a[u];fp;fp=fp->nextArc )
    {
        if( !vis_l[fp->adjVex] )   //只要下一结点未被访问过
        {
            Dfs_L(lg,fp->adjVex);
        }
    }
    return ;
}
void Bfs_L( LGraph *lg,int u )
{
    ENode *fp;      //移动指针，在邻接表上移动
    Queue q;
    Create_Q(&q,lg->n);
    Push_Q(&q,u);   //将编号为u的结点入队
    while( !IsEmpty_Q(&q) )   //只要队列还不为空，就继续执行
    {
        Front_Q(&q,&u);
        DeQueue_Q(&q);
        printf("%3d ",u);       //打印
        load[cnt++]=u;
        vis_l[u]=1;             //标记改变
        for( fp=lg->a[u];fp;fp=fp->nextArc )
        {
            if( !vis_l[fp->adjVex] )   //只要与u连接的结点未被访问过，就让他们入队
            {
                Push_Q(&q,fp->adjVex);
                vis_l[fp->adjVex]=1;  //标记改变
            }
        }
    }
    Destroy_Q(&q);  //撤销队列
    return ;
}

void Print_M( MGraph *mg )   //邻接矩阵打印
{
    int i,j;
    printf("

该图的邻接矩阵为：
");
    for( i=0;i<mg->n;i++ )
    {
        for( j=0;j<mg->n;j++ )
        {
            if( mg->a[i][j]!=mg->noEdge )
                printf("%d	",mg->a[i][j]);
            else
                printf("*	");
        }
        printf("
");
    }
    printf("（注：“*”代表结点u到结点v没有边）
");
}
void Print_L( LGraph *lg )     //邻接表打印
{
    ENode *fp;    //移动指针，在邻接表上移动
    int i;
    printf("

该图的邻接表为：（注：“ |2| 1-50 ”代表的意思是，表头结点2，有指向结点1的边，边的值为50）
");
    for( i=0;i<lg->n;i++ )
    {
        printf("表头结点: |%d|",i);
        for( fp=lg->a[i];fp;fp=fp->nextArc )
        {
            printf("%3d-%-3d ",fp->adjVex,fp->w);
        }
        printf("
");
    }
}
void Print_Indegree_1( MGraph *mg )   //（邻接矩阵）每个结点的入度打印，load[]为遍历路径
{
    int i,j,ans;
    int *fp;
    for( i=0;i<cnt;i++ )
    {
        ans=0;
        for( j=0;j<cnt;j++ )
        {
            fp=&(mg->a[j][ load[i] ]);  //以第一排的每个元素 作起始地址 进行向下搜索
            if( *fp!=0&&*fp!=mg->noEdge )
                ans++;    
        }
        printf("%3d ",ans);
    }
}
void Print_Outdegree_1( MGraph *mg )   //（邻接矩阵）每个结点的出度打印，load[]为遍历路径
{
    int i,j,ans;      //ans表示结点度数
    int *fp;
    for( i=0;i<cnt;i++ )
    {
        ans=0;
        fp=mg->a[ load[i] ];
        for( j=0;j<cnt;j++ )
        {
            if( *fp!=0&&*fp!=mg->noEdge )
              ans++;
            fp++;     //指针向右移动
        }
        printf("%3d ",ans);
    }
}
void Print_Indegree_2( LGraph *lg )   //（邻接表）每个结点的入度打印，load[]为遍历路径
{
    int i;
    ENode *fp;
    int *in_degree=(int*)malloc(lg->n*sizeof(int));    //用数组in_degree[]记录每个结点的入度
    for( i=0;i<lg->n;i++ )    //初始化
        in_degree[i]=0;
    for( i=0;i<lg->n;i++ )
    {
        for( fp=lg->a[ load[i] ];fp;fp=fp->nextArc )
        {
            in_degree[fp->adjVex]++;    //编号为 fp->adjVex 的结点的编号 的入度加1
        }
    }
    for( i=0;i<lg->n;i++ )
    {
        printf("%3d ",in_degree[ load[i] ] );
    }
}
void Print_Outdegree_2( LGraph *lg )   //（邻接表）每个结点的出度打印，load[]为遍历路径
{
    int i,ans;      //ans表示结点度数
    ENode *fp;
    for( i=0;i<lg->n;i++ )
    {
        ans=0;
        for( fp=lg->a[ load[i] ];fp;fp=fp->nextArc )
        {
            ans++;
        }
        printf("%3d ",ans);
    }
}

void Bfs_Judge( LGraph *lg,int u )    //用于判断是否是强连通图的辅助函数
{
    ENode *fp;      //移动指针，在邻接表上移动
    Queue q;
    Create_Q(&q,lg->n);
    Push_Q(&q,u);   //将编号为u的结点入队
    while( !IsEmpty_Q(&q) )   //只要队列还不为空，就继续执行
    {
        Front_Q(&q,&u);
        DeQueue_Q(&q);
        cnt++;
        vis_l[u]=1;             //标记改变
        for( fp=lg->a[u];fp;fp=fp->nextArc )
        {
            if( !vis_l[fp->adjVex] )   //只要与u连接的结点未被访问过，就让他们入队
            {
                Push_Q(&q,fp->adjVex);
                vis_l[fp->adjVex]=1;  //标记改变
            }
        }
    }
    Destroy_Q(&q);  //撤销队列
    return ;
}
BOOL Judge_QiangLiTongTu( LGraph *lg )   //判断是否是强连通图（针对于有向图）
{
    int i;
    for( i=0;i<lg->n;i++ )
    {
        Clear_Flag();        //标记清零操作
        Bfs_Judge(lg,i);
        if( cnt!=lg->n )     //若任意一对顶点之间都存在路径，则以某一结点为起点宽度遍历后，路径长度cnt应该为lg->n (注：cnt为全局变量)              
            return FALSE;    //不是连通图,返回FALSE
    }
    return TRUE;   //每个结点都满足，这说明是强连通图
}

void In_Degree_Helper( int *in_degree,LGraph *lg )
{
    ENode *fp;
    int i;
    for( i=0;i<lg->n;i++ )
        in_degree[i]=0;   //先初始化
    for( i=0;i<lg->n;i++ )
    {
        for( fp=lg->a[i];fp;fp=fp->nextArc )
        {
            in_degree[ fp->adjVex ]++;   //编号为fp->adjVex的结点的入度加1
        }
    }
}
void TopSort( LGraph *lg )   //拓扑排序
{
    ENode *fp;
    int *in_degree,i,top_node;
    Stack sta;
    Create_S(&sta,lg->n);
    in_degree=(int*)malloc(lg->n*sizeof(int));
    In_Degree_Helper(in_degree,lg);      //初始化该数组
    for( i=0;i<lg->n;i++ )
    {
        if( in_degree[i]==0 )
            Push_S(&sta,i);
    }
    while( !IsEmpty_S(&sta) )
    {
        Top_S(&sta,&top_node);
        Pop_S(&sta);                          //这条语句不能放到for循环下面！不然栈里的元素不能被覆盖，要出大问题
        load[cnt++]=top_node;
        for( fp=lg->a[top_node];fp;fp=fp->nextArc )
        {
            in_degree[fp->adjVex]--;            //更新编号为fp->adjVex的结点的入度
            if( in_degree[fp->adjVex]==0 )      //并判断编号为fp->adjVex的结点入度是否为零，是则放入栈
                Push_S(&sta,fp->adjVex);
        }
    }
    if( cnt==lg->n )
    {
        printf("
该图的拓扑排序为：");
        for( i=0;i<lg->n;i++ )
            printf("%3d ",load[i]);
    }
    else
    {
        printf("该图中存在有向回路，不能拓扑排序。
");
    }
}

/*
  编写程序，实现智能交通中的最佳路径选择：设有n个地点，编号为0~n-1，m条路径的起点、终点
  和代价由用户输入提供，采用上述邻接表为存储结构，寻找最佳路径方案（花费时间最少）
*/
void DFS_PLF( LGraph *lg,Stack *s,int v,int Time )   //v为终点，起点已经装进了栈里了
{
    ENode *fp;   //fp为移动指针，在邻接表上移动
    int t,i;
    Top_S(s,&t);
    if( t==v&&Time<Min_Time )  //终止条件：栈顶元素为终点。并且所花时间 比 以前记录的所花最少时间还要小
    {
        Min_Time=Time;
        for( i=0;i<=s->top;i++ )
            path[i]=s->element[i];   //记录当前最佳路径
        count=i;
        return ;
    }
    for( fp=lg->a[t];fp;fp=fp->nextArc )
    {
        if( !vis_l[fp->adjVex] )   //如果 编号为t的结点指向的 编号为fp->adjVex的结点未被访问过
        {
            Push_S(s,fp->adjVex);  //入栈
            vis_l[fp->adjVex]=1;  //标记改变
            DFS_PLF(lg,s,v,Time+fp->w);   //时间代价要加fp->w
            vis_l[fp->adjVex]=0;  //标记回溯
            Pop_S(s);            //出栈(回溯)
        }
    }
}
void Prefect_Load_Find( LGraph *lg,int u,int v )  //最佳路径找查(花费时间最少),思路：深度优先搜索
{
    Stack s;
    int i;
    Create_S(&s,lg->n);
    Push_S(&s,u);
    vis_l[u]=1;      //标记改变，编号为u的结点已被访问
    DFS_PLF( lg,&s,v,0 );
    printf("从 编号为%d的起点 到 编号为%d的终点的最佳路径(花费时间最少)为：",u,v);
    for( i=0;i<count;i++ )
        printf("%d ",path[i]);
    printf("
所花费的时间为：%d
",Min_Time);
}
void Experiment_5()        //入口函数：智能交通的最佳路径的实现(花费时间最少)
{
    int n;       //n个地点 ，编号为0~n-1
    int m;       //m条路径
    int u,v,w;   //路径的起点u、终点v和代价w
    int i;
    LGraph lg;
    Clear_Flag();   //标记清零操作
    printf("请分别输入地点个数n和路径个数m：");
    scanf("%d%d",&n,&m);
    Init_L(&lg,n);    //初始化邻接表，n个顶点
    i=m;
    while( i>0 )
    {
        printf("请分别输入第%d条路径的起点、终点和时间代价：",m-i+1);
        scanf("%d%d%d",&u,&v,&w);
        Insert_L_E(&lg,u,v,w);
        i--;
    }
    printf("请输入你想找哪两个结点的最佳路径：（分别输入起点和终点）");
    scanf("%d%d",&u,&v);
    if( u<0||u>=lg.n||v<0||v>=lg.n||u==v )   //增强代码的健壮性，判断错误输出
    {
        printf("请输入正确的 你所要找查最佳路径的起点和终点！
");
        return ;
    }
    Prefect_Load_Find( &lg,u,v );
    return ;
}

void M_Grapg()   //入口函数：邻接矩阵的实现(额外包含矩阵打印出、入度计算) 
{
    int i,u,v,w,n;
    MGraph mg;
    printf("请输入该图的结点数：");
    scanf("%d",&n);
    Init_M(&mg,n,-9999);
    printf("输入u为-999时结束。
");
    while( 1 )
    {
        scanf("%d%d%d",&u,&v,&w);
        if( u==-999 )
            break;
        Insert_M_E(&mg,u,v,w);
    }
    Clear_Flag();   //标记清零操作
    printf("
矩阵的 深度遍历 结果为：
");
    printf("结点  ");
    for( i=0;i<mg.n;i++ )
    {
        if(!vis_m[i])
            Dfs_M(&mg,i);
    }
    printf("
入度  ");
    Print_Indegree_1(&mg);   //每个结点的入度打印
    printf("
出度  ");
    Print_Outdegree_1(&mg);   //每个结点的出度打印
    Print_M(&mg);            //邻接矩阵打印51
    printf("
请分别输入需要删除的边的两端的结点值：");
    scanf("%d%d",&u,&v);
    if( !Delete_M_E(&mg,u,v) )
        return ;
    printf("删除边后矩阵的 宽度遍历 结果为：
");
    printf("结点  ");
    Clear_Flag();        //标记清零操作
    for( i=0;i<mg.n;i++ )
    {
        if(!vis_m[i])
            Dfs_M(&mg,i);
    }
    printf("
入度  ");
    Print_Indegree_1(&mg);   //每个结点的入度打印
    printf("
出度  ");
    Print_Outdegree_1(&mg);   //每个结点的出度打印
    printf("
");
    Print_M(&mg);         //邻接矩阵打印
    Destroy_M(&mg);
}
void L_Graph()  //入口函数：邻接表的实现(额外包含强连通图判断、邻接表打印、拓扑排序)
{
    int i,u,v,w,count=0,n;   //n为结点数
    LGraph lg;
    printf("请输入该图的结点数：");
    scanf("%d",&n);
    Init_L(&lg,n);
    printf("输入u为-999时结束。
");
    while( 1 )
    {
        scanf("%d%d%d",&u,&v,&w);
        if( u==-999 )
            break;
        Insert_L_E(&lg,u,v,w);
    }
    Clear_Flag();   //标记清零操作
    printf("
矩阵的 深度遍历 结果为：
结点  ");
    for( i=0;i<lg.n;i++ )
    {
        if( !vis_l[i] )
            Dfs_L(&lg,i);
    }
    printf("
入度  ");
    Print_Indegree_2(&lg);   //（邻接表）每个结点的入度打印
    printf("
出度  ");
    Print_Outdegree_2(&lg);   //（邻接表）每个结点的出度打印
    Print_L(&lg);            //打印邻接表
    if( Judge_QiangLiTongTu(&lg) )
        printf("
该图 是 强连通图。
");
    else
        printf("
该图 不是 强连通图。
");
    Clear_Flag();   //标记清零操作
    TopSort(&lg);
    printf("

请分别输入需要删除的边的两端的结点值：");
    scanf("%d%d",&u,&v);
    if( !Delete_L_E(&lg,u,v) )
        return ;
    Clear_Flag();   //标记清零操作
    printf("删除后的图的 宽度遍历 为：
结点  ");
    for( i=0;i<lg.n;i++ )
    {
        if( !vis_l[i] )
            Dfs_L(&lg,i);
    }
    printf("
入度  ");
    Print_Indegree_2(&lg);   //（邻接表）每个结点的入度打印
    printf("
出度  ");
    Print_Outdegree_2(&lg);   //（邻接表）每个结点的出度打印
    Print_L(&lg);           //打印邻接表
    Destroy_L(&lg);
}

void Main_Menu()        //主菜单打印
{
    printf("+--------------------------------------------------------------------------+
");
    printf("|                  主菜单                                                  |
");
    printf("|             1、邻接矩阵的实现(额外包含矩阵打印出、入度计算)              |
");
    printf("|             2、邻接表的实现(额外包含强连通图判断、邻接表打印、拓扑排序)  |
");
    printf("|             3、智能交通的最佳路径的实现(花费时间最少)                    |
");
    printf("|             0、退出                                                      |
");
    printf("+--------------------------------------------------------------------------+
");
} 

int main()
{
    int choice;
    do
    {
        system("cls");
        Main_Menu();
        printf("请输入你的选择:
");
        scanf("%d",&choice);
        switch(choice)
        {
        case 1: M_Grapg();      //邻接矩阵的实现(额外包含矩阵打印出、入度计算)
                break;
        case 2: L_Graph();       //邻接表的实现(额外包含强连通图判断、邻接表打印、拓扑排序)
                break;
        case 3: Experiment_5();     //智能交通的最佳路径的实现(花费时间最少)
                break;
        }
        system("pause");
    }while(choice);
    return 0;
}

                 

如果您觉得不错的话，点个赞，编者再接再厉~ Thanks~ ^_^