数据结构——图——邻接矩阵、邻接表、十字链表、邻接多重表——广度优先遍历和深度优先遍历

图(Graph)型结构：

    什么是图型结构：由有穷且非空的顶点和顶点之间边的集合组成

    通常表示： G(V,E)  G表示一个图,V是图中顶点集合(元素),E是图中所有边(元素之间的关系)的集合

    无向图：

        边用(A,B)方式表示，A与B之间互通，边没有指定方向

    无向完全图：

        在无向图中，任意两个顶点之间都有边，这种叫做无向完全图

        含有n个顶点的无向完全图中，共有 n*(n-1)/2 条边

    有向图：

        边用<A,B>方式表示，仅仅表示从A点到B点的边，有向图中边也叫做弧，A是弧尾，B是弧头

    有向完全图：

        在有向图中，任意两个顶点之间都有方向相反的两条弧，这种图叫做有向完全图

        含有n个顶点的有向完全图中，共有 n*(n-1) 条边

    注意：不讨论顶点到自身的边，且不讨论重复的边，这种图统称为简单图，数据结构中只研究简单图

    稀疏图：顶点多边少的图，反之称为稠密图

    边的权重：图中的边附带有意义的数据，这些数据叫做边的权重，带权重的图也称为网

    度：依附于顶点的边的数量称之为该顶点的度，有向图中，度分为出度(从该顶点出发的弧的数量)、入度(指向该顶点的弧的数量)

    路径：顶点到顶点之间经过的边叫做路径

    路径长度：路径上边的条目数

    环：图中某个点通过边最后能绕回该点

    回路：专指有向图，从某点出发，最终有弧回到该点，如果某点只有输出或输入，该点没有回路

    简单路径：边经过顶点序列中不重复的路径称为简单路径

    简单回路：除了第一个顶点和最后一个顶点外，其余顶点不重复的回路称为简单回路

    连通：如果顶点V到顶点V1之间有路径，则称V和V1是连通的

    连通图：任意顶点之间都是连通的，称之为连通图，如果一个图中有n个顶点则至少需要 n-1 条边才能达到连通图

    生成树：顶点数为n，仅需要n-1条边的连通图，称之为生成树，如果给边配上权重，权重和最小的生成树称之为最小生成树

图的遍历：

    深度优先遍历(DFS)

        对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次

    广度优先遍历(BFS)

        系统地展开并遍历图中的所有节点，而且每个节点只能访问一次，与队列配合进行

图的存储结构：

    邻接矩阵：

        用一个一维数组存储n个顶点，用一个n*n的二维数组存储边

        char V[n] = {A,B,C,D,E,F,G};

           A  B  C  D  E  F  G      (弧头)

        A [0][1][0][1][0][0][0]

        B [0][0][0][1][1][0][0]

        C [0][0][0][1][0][1][0]    

        D [0][0][1][0][0][0][1]

        E [0][0][0][0][0][0][1]

        F [0][0][0][0][0][0][1]

        G [0][0][0][0][0][1][0]

       (弧尾)

        在二维数组E[i][j]值为1，则表示顶点V[i]到V[j]有边

        注意：由于不存在自己到自己的边，左对角线上的值一定为0

        如果存储的是无向图则二维数组的值沿对角线对称，可以压缩成一维数组(参考矩阵压缩)

        优点：可以方便地计算顶点的出度和入度

        缺点：当图是稀疏图时，会非常地浪费存储空间

    邻接表：(链式+顺序)

        边：

            顶点下标

            指向下一条边的地址

        顶点：

            顶点数据

            指向第一条边的指针

        图：

            由顶点组成的数组

            顶点数量

        优点：节约存储空间，计算出度方便

        缺点：计算入度麻烦

    十字链表：

        是一种专门存储有向图的一种结构

        边

            弧尾下标

            弧头下标

            指向弧尾相同的下一条边

            指向弧头相同的下一条边

        顶点：

            顶点数据

            指向第一条出度的边

            指向第一条入度的边

        图：

            由顶点组成的数组

            顶点数量

        优点：节约空间、计算出入度很方便

    邻接多重表：

        是一种专门存储无向图的一种结构

        边：

            i j 两个相互依附的顶点的下标

            inext 指向下一条依附于i顶点的边

            jnext 指向下一条依附于j顶点的边

        顶点：

            顶点数据

            指向与顶点有关的一条边的指针

        图：

            由顶点组成的数组

            顶点数量

 

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <string.h>

#include "list_queue.h"

//  邻接矩阵

typedef struct Graph

{

    char* v;    //  顶点一维数组

    char* e;    //  边的二维数组

    int cnt;    //  顶点数量

}Graph;

Graph* create_graph(const char* str)

{

    //  申请邻接矩阵内存

    Graph* graph = malloc(sizeof(Graph));

    //  计算顶点数量

    graph->cnt = strlen(str);

    //  申请顶点所需内存

    graph->v = malloc(graph->cnt+1);

    //  存储顶点

    strcpy(graph->v,str);

    //  申请存储边所需内存

    graph->e = calloc(graph->cnt,graph->cnt);

    return graph;

}

//  添加边

bool add_edge(Graph* graph,char v1,char v2)

{

    int x = -1, y = -1;

    for(int i=0; i<graph->cnt; i++)

    {

        if(graph->v[i] == v1)   x = i;

        if(graph->v[i] == v2)   y = i;

    }

    if(-1==x || -1==y) return false;

    //  有向图

    graph->e[x*graph->cnt+y] = 1;

    //  无向图只需要再加一句

//  graph->e[y*graph->cnt+x] = 1;

    return true;

}

void show_graph(Graph* graph)

{

    printf(" ");

    for(int i=0; i<graph->cnt; i++)

        printf(" %c",graph->v[i]);

    printf("\n");

    for(int i=0; i<graph->cnt; i++)

    {

        printf("%c ",graph->v[i]);

        for(int j=0; j<graph->cnt; j++)

        {

            printf("%hhd ",graph->e[i*graph->cnt+j]);  

        }

        printf("\n");

    }

}

//  计算顶点的出度

int od_graph(Graph* graph,char v)

{

    for(int x=0; x<graph->cnt; x++)

    {

        if(v == graph->v[x])    

        {

            int od = 0;

            for(int y=0; y<graph->cnt; y++)

            {

                od += graph->e[x*graph->cnt+y];

            }

            return od;

        }

    }

    return -1;

}

//  计算顶点的入度

int id_graph(Graph* graph,char v)

{

    for(int y=0; y<graph->cnt; y++)

    {

        if(v == graph->v[y])

        {

            int id = 0;

            for(int x=0; x<graph->cnt; x++)

            {

                id += graph->e[x*graph->cnt+y];

            }

            return id;

        }

    }

    return -1;

}

//  从第i个顶点开始进行深度优先遍历

void _DFS(Graph* graph,int i,char* vflag)

{

    if(vflag[i]) return;

    printf("%c ",graph->v[i]);

    vflag[i] = 1;

    for(int j=0; j<graph->cnt; j++)

    {

        if(graph->e[i*graph->cnt+j])

        {

            _DFS(graph,j,vflag);    

        }

    }

}

//  深度优先遍历

void DFS_show(Graph* graph)

{

    //顶点的标志位

    char vflag[graph->cnt];

    memset(vflag,0,graph->cnt);

    for(int i=0; i<graph->cnt; i++)

        _DFS(graph,i,vflag);

}

//  广度优先遍历

void BFS_show(Graph* graph)

{

    //顶点的标志位

    char vflag[graph->cnt];

    memset(vflag,0,graph->cnt);

   

    ListQueue* queue = create_list_queue();

    for(int i=0; i<graph->cnt; i++)

    {

        if(!vflag[i])

        {

            push_list_queue(queue,i);

            vflag[i] = 1;

        }

        while(!empty_list_queue(queue))

        {

            int j = front_list_queue(queue);

            printf("%c ",graph->v[j]);

            pop_list_queue(queue);

            for(int y=0; y<graph->cnt; y++)

            {

                if(graph->e[j*graph->cnt+y] && !vflag[y])

                {

                    push_list_queue(queue,y);

                    vflag[y] = 1;

                }

            }

        }

    }

}

int main(int argc,const char* argv[])

{

    Graph* graph = create_graph("ABCDEFGX");    

    add_edge(graph,'A','B');

    add_edge(graph,'A','D');

    add_edge(graph,'B','D');

    add_edge(graph,'B','E');

    add_edge(graph,'C','D');

    add_edge(graph,'C','F');

    add_edge(graph,'D','C');

    add_edge(graph,'D','G');

    add_edge(graph,'E','G');

    add_edge(graph,'F','G');

    add_edge(graph,'G','F');

    add_edge(graph,'X','E');

    show_graph(graph);

    DFS_show(graph);

    printf("\n");

    BFS_show(graph);

}

 

//邻接表

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <string.h>

#include "list_queue.h"

//  边

typedef struct Edge

{

    int index;          //  边指向顶点的下标

    struct Edge* next;  //  指向下一条边

}Edge;

//  创建到index顶点的边

Edge* create_edge(int index)

{

    Edge* edge = malloc(sizeof(Edge));

    edge->index = index;

    edge->next = NULL;

    return edge;

}

//  顶点

typedef struct Vertex

{

    char vertex;    //  顶点数据

    Edge* first;    //  指向该顶点的第一条边

}Vertex;

//  图

typedef struct Graph

{

    Vertex* v;      //  顶点数组

    int cnt;        //  顶点数量

}Graph;

//  创建图

Graph* create_graph(const char* str)

{

    //  申请图所需内存

    Graph* graph = malloc(sizeof(Graph));

    //  计算顶点数量

    graph->cnt = strlen(str);

    //  申请存储顶点数组所需内存

    graph->v = malloc(sizeof(Vertex)*graph->cnt);

    //  初始化顶点

    for(int i=0; i<graph->cnt; i++)

    {

        graph->v[i].vertex = str[i];

        graph->v[i].first = NULL;

    }

    return graph;

}

//  添加边

bool add_edge_graph(Graph* graph,char v1,char v2)

{

    for(int i=0; i<graph->cnt; i++)

    {

        if(v1 == graph->v[i].vertex)    //  v1下标 i  

        {

            //  对第i个顶点的first进行头添加

            for(int j=0; j<graph->cnt; j++)

            {

                if(v2 == graph->v[j].vertex)    //  v2下标 j

                {

                    //  创建指向j的边

                    Edge* edge = create_edge(j);

                    edge->next = graph->v[i].first;

                    graph->v[i].first = edge;

                    return true;

                }

            }

        }

    }

    return false;

}

//  计算出度

int od_graph(Graph* graph,char v)

{

    int od = 0;

    for(int i=0; i<graph->cnt; i++)

    {

        if(v == graph->v[i].vertex)

        {

            for(Edge* e=graph->v[i].first; e; e=e->next)

            {

                od++;  

            }

            return od;

        }

    }

    return -1;

}

//  入度

int id_graph(Graph* graph,char v)

{

    //  寻找v的下标

    for(int i=0; i<graph->cnt; i++)

    {

        if(v == graph->v[i].vertex)

        {

            int id = 0;

            for(int j=0; j<graph->cnt; j++)

            {

                for(Edge* e=graph->v[j].first; e; e=e->next)

                {

                    if(e->index == i) id++;

                }

            }

            return id;

        }

    }

    return -1;

}

void _DFS(Graph* graph,int i,char* vflag)

{

    if(vflag[i]) return;

    printf("%c ",graph->v[i].vertex);

    vflag[i] = 1;

    for(Edge* e=graph->v[i].first; e; e=e->next)

    {

        _DFS(graph,e->index,vflag);

    }

}

//  深度优先

void DFS_show(Graph* graph)

{

    char vflag[graph->cnt];

    memset(vflag,0,graph->cnt);

    for(int i=0; i<graph->cnt; i++)

    {

        _DFS(graph,i,vflag);        

    }

    printf("\n");

}

//  广度优先

void BFS_show(Graph* graph)

{

    ListQueue* queue = create_list_queue();

    char vflag[graph->cnt];

    memset(vflag,0,graph->cnt);

    for(int i=0; i<graph->cnt; i++)

    {

        if(!vflag[i])

        {

            push_list_queue(queue,i);

            vflag[i] = 1;

        }

        while(!empty_list_queue(queue))

        {

            int j = front_list_queue(queue);

            printf("%c ",graph->v[j].vertex);

            pop_list_queue(queue);

           

            for(Edge* e=graph->v[j].first; e; e=e->next)

            {

                if(!vflag[e->index])

                {

                    push_list_queue(queue,e->index);

                    vflag[e->index] = 1;

                }

            }

        }

    }

    destory_list_queue(queue);

    printf("\n");

}

void show_graph(Graph* graph)

{

    for(int i=0; i<graph->cnt; i++)

    {

        printf("index:%d v:%c e:",i,graph->v[i].vertex);

        for(Edge* e=graph->v[i].first; e; e=e->next)

        {

            printf("%c ",graph->v[e->index].vertex);    

        }

        printf(" od:%d id:%d",od_graph(graph,graph->v[i].vertex),

            id_graph(graph,graph->v[i].vertex));

        printf("\n");

    }

}

int main(int argc,const char* argv[])

{

    Graph* graph = create_graph("ABCDEFGH");

    add_edge_graph(graph,'A','D');

    add_edge_graph(graph,'A','B');

    add_edge_graph(graph,'B','D');

    add_edge_graph(graph,'B','C');

    add_edge_graph(graph,'C','D');

    add_edge_graph(graph,'D','E');

    add_edge_graph(graph,'D','F');

    add_edge_graph(graph,'E','G');

    add_edge_graph(graph,'G','H');

    add_edge_graph(graph,'F','H');

    show_graph(graph);

    DFS_show(graph);

    BFS_show(graph);

}