数据结构课设——有向图的深度、广度优先遍历及拓扑排序

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#pragma warning(disable:4996)
#define Max 20//定义数组元素最大个数（顶点最大个数）
typedef struct node//边表结点
{
    int adjvex;//该边所指向结点对应的下标
    struct node* next;//该边所指向下一个结点的指针
}eNode;
typedef struct headnode//顶点表结点
{
    int in;//顶点入度
    char vertex;//顶点数据
    eNode* firstedge;//指向第一条边的指针，边表头指针
}hNode;
typedef struct//邻接表（图）
{
    hNode adjlist[Max];//以数组的形式存储
    int n, e;//顶点数，边数
}linkG;

//以邻接表的存储结构创建图
linkG* creat(linkG* g)
{
    int i, k;
    eNode* s;//边表结点
    int n1, e1;
    char ch;
    g = (linkG*)malloc(sizeof(linkG));//申请结点空间
    printf("请输入顶点数和边数：");
    scanf("%d%d", &n1, &e1);
    g->n = n1;
    g->e = e1;
    printf("顶点数：%d    边数：%d\n", g->n, g->e);
    printf("请输入顶点信息（字母）：");
    getchar();//因为接下来要输入字符串，所以getchar用于承接上一条命令的结束符
    for (i = 0; i < n1; i++)
    {
        scanf("%c", &ch);
        g->adjlist[i].vertex = ch;//获得该顶点数据
        g->adjlist[i].firstedge = NULL;//第一条边设为空
    }
    printf("\n打印顶点下标及顶点数据：\n");
    for (i = 0; i < g->n; i++)//循环打印顶点下标及顶点数据
    {
        printf("顶点下标：%d  顶点数据：%c\n", i, g->adjlist[i].vertex);
    }
    getchar();
    int i1, j1;//相连接的两个顶点序号
    for (k = 0; k < e1; k++)//建立边表
    {

        printf("请输入对<i,j>（空格分隔）：");
        scanf("%d%d", &i1, &j1);
        s = (eNode*)malloc(sizeof(eNode));//申请边结点空间
        s->adjvex = j1;//边所指向结点的位置，下标为j1
        s->next = g->adjlist[i1].firstedge;//将当前s的指针指向当前顶点上指向的结点
        g->adjlist[i1].firstedge = s;//将当前顶点的指针指向s
    }
    return g;//返回指针g
}
int visited[Max];//标记是否访问
void DFS(linkG* g, int i)//深度优先遍历
{
    eNode* p;
    printf("%c ", g->adjlist[i].vertex);
    visited[i] = 1;//将已访问过的顶点visited值改为1
    p = g->adjlist[i].firstedge;//p指向顶点i的第一条边
    while (p)//p不为NULL时（边存在）
    {
        if (visited[p->adjvex] != 1)//如果没有被访问
        {
            DFS(g, p->adjvex);//递归
        }
        p = p->next;//p指向下一个结点
    }
}
void DFSTravel(linkG* g)//遍历非连通图
{
    int i;
    printf("深度优先遍历;\n");
    //printf("%d\n",g->n);
    for (i = 0; i < g->n; i++)//初始化为0
    {
        visited[i] = 0;
    }
    for (i = 0; i < g->n; i++)//对每个顶点做循环
    {
        if (!visited[i])//如果没有被访问
        {
            DFS(g, i);//调用DFS函数
        }
    }
}
void BFS(linkG* g, int i)//广度优先遍历
{
    int j;
    eNode* p;
    int q[Max], front = 0, rear = 0;//建立顺序队列用来存储，并初始化
    printf("%c ", g->adjlist[i].vertex);
    visited[i] = 1;//将已经访问过的改成1
    rear = (rear + 1) % Max;//普通顺序队列的话，这里是rear++
    q[rear] = i;//当前顶点（下标）队尾进队
    while (front != rear)//队列非空
    {
        front = (front + 1) % Max;//循环队列，顶点出队
        j = q[front];
        p = g->adjlist[j].firstedge;//p指向出队顶点j的第一条边
        while (p != NULL)
        {
            if (visited[p->adjvex] == 0)//如果未被访问
            {
                printf("%c ", g->adjlist[p->adjvex].vertex);
                visited[p->adjvex] = 1;//将该顶点标记数组值改为1
                rear = (rear + 1) % Max;//循环队列
                q[rear] = p->adjvex;//该顶点进队
            }
            p = p->next;//指向下一个结点
        }
    }
}
void BFSTravel(linkG* g)//遍历非连通图
{
    int i;
    printf("广度优先遍历：\n");
    for (i = 0; i < g->n; i++)//初始化为0
    {
        visited[i] = 0;
    }
    for (i = 0; i < g->n; i++)//对每个顶点做循环
    {
        if (!visited[i])//如果没有被访问过
        {
            BFS(g, i);//调用BFS函数
        }
    }
}
//因为拓扑排序要求入度为0，所以需要先求出每个顶点的入度
void inDegree(linkG* g)//求图顶点入度
{
    eNode* p;
    int i;
    for (i = 0; i < g->n; i++)//循环将顶点入度初始化为0
    {
        g->adjlist[i].in = 0;
    }
    for (i = 0; i < g->n; i++)//循环每个顶点
    {
        p = g->adjlist[i].firstedge;//获取第i个链表第1个边结点指针
        while (p != NULL)///当p不为空（边存在）
        {
            g->adjlist[p->adjvex].in++;//该边终点结点入度+1
            p = p->next;//p指向下一个边结点
        }
        printf("顶点%c的入度为：%d\n", g->adjlist[i].vertex, g->adjlist[i].in);
    }

}
void topo_sort(linkG *g)//拓扑排序
{
    eNode* p;
    int i, k, gettop;
    int top = 0;//用于栈指针的下标索引
    int count = 0;//用于统计输出顶点的个数
    int* stack=(int *)malloc(g->n*sizeof(int));//用于存储入度为0的顶点
    for (i=0;i<g->n;i++)//第一次搜索入度为0的顶点
    {
        if (g->adjlist[i].in==0)
        {
            stack[++top] = i;//将入度为0的顶点进栈
        }
    }
    while (top!=0)//当栈不为空时
    {
        gettop = stack[top--];//出栈,并保存栈顶元素（下标）
        printf("%c ",g->adjlist[gettop].vertex);
        count++;//统计顶点
        //接下来是将邻接点的入度减一，并判断该点入度是否为0
        p = g->adjlist[gettop].firstedge;//p指向该顶点的第一条边的指针
        while (p)//当p不为空时
        {
            k = p->adjvex;//相连接的顶点（下标）
            g->adjlist[k].in--;//该顶点入度减一
            if (g->adjlist[k].in==0)
            {
                stack[++top] = k;//如果入度为0，则进栈
            }
            p = p->next;//指向下一条边
        }
    }
    if (count<g->n)//如果输出的顶点数少于总顶点数，则表示有环
    {
        printf("\n有回路！\n");
    }
    free(stack);//释放空间
}
void menu()//菜单
{
    system("cls");//清屏函数
    printf("************************************************\n");
    printf("*             1.建立图                         *\n");
    printf("*             2.深度优先遍历                   *\n");
    printf("*             3.广度优先遍历                   *\n");
    printf("*             4.求出顶点入度                   *\n");
    printf("*             5.拓扑排序                       *\n");
    printf("*             6.退出                           *\n");
    printf("************************************************\n");
}
int main()
{
    linkG* g = NULL;
    int c;
    while (1)
    {
        menu();
        printf("请选择：");
        scanf("%d", &c);
        switch (c)
        {
        case 1:g = creat(g); system("pause");
            break;
        case 2:DFSTravel(g); system("pause");
            break;
        case 3:BFSTravel(g); system("pause");
            break;
        case 4:inDegree(g); system("pause");
            break;
        case 5:topo_sort(g); system("pause");
            break;
        case 6:exit(0);
            break;
        }
    }
    return 0;
}