9.图的存储与遍历

已于 2022-09-04 21:22:42 修改
阅读量590 收藏 5
点赞数
分类专栏： 数据结构 文章标签： 队列 链表 算法 数据结构
于 2021-04-13 17:17:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nodd_le/article/details/115673468
版权

什么是图

图是由一系列顶点和若干连结顶点集合内两个顶点的边组成的数据结构。数学意义上的图，指的是由一系列点与边构成的集合，这里我们只考虑有限集，通常我们用G = (V, E)表示一个图结构，其中V表示点集，E表示边集。

在顶点集合所包含的若干个顶点之间，可能存在着某种两两关系——如果某两个点之间的确存在这样的关系的话，我们就在这两个点之间连边，这样就得到了边集的一个成员，也就是一条边。对应到社交网络中，顶点就是网络中的用户，边就是用户之间的好友关系。

简而言之，一条有向边必然是从一个点指向另一个点，而相反方向的边在有向图中则不一定存在；而有的时候我们并不在意构成一条边的两个顶点具体谁先谁后，这样得到的一条边就是无向边。对于图而言，如果图中所有的边都是无向图，反之称为有向图。

一般而言，我们在数据结构中所讨论的图都是有向图，因为有向图相比无向图更具有代表性。实际上，无向图可以由有向图来表示。如果AB两个点之间存在无向边的话，那用有向图也可以表示AB两点之间同时存在A到B与B到A两条有向边。

图的相关概念

很少边或弧（如e < n log n，e指边数，n指点数）的图称为稀疏图，反之称为稠密图。

顶点的度 是指依附于某个顶点的边数。在有向图中，我们需要学习顶点的 入度 和 出度 这两个概念。顶点的入度是指以顶点为弧头的弧的数目，也就是以该顶点为终点的弧的数目；顶点的出度是指以顶点为弧尾的弧的数目，也就是以该顶点为起点的弧的数目。需要注意的是，在有向图里，顶点的度为入度与出度之和。

图的存储

邻接矩阵

邻接矩阵存储结构就是用一维数组存储图中顶点的信息，用矩阵表示图中各顶点之间的邻接关系。

对于有n个顶点的图G = (V,E)来说，我们可以用一个n * n的矩阵A来表示G中各顶点的相邻关系，如果vi和vj之间存在边(或弧)，则A|i|j| = 1 ，否则A[i][j] = 0。

图的邻接矩阵是唯一的，矩阵的大小只与顶点个数N有关。是一个N * N的矩阵。前面我们已经介绍过，在无向图里，如果顶点vi和vj之间有边，则可认为顶点vi和vj有边，顶点vj到vi也有边。对应到邻接矩阵里，则有A[i][j] = A[j][i]。

我们可以发现，无向图的邻接矩阵是一个对称矩阵。在邻接矩阵上，我们可以直观的看出两个顶点之间是否有边（或弧），并能容易求出每个顶点的度，入度和出度。

首先来学习邻接矩阵的实现，我们都知道，邻接矩阵是一个由1和0构成的矩阵。处于第i行、第j列上的元素1和0分别代表顶点i和j之间存在或不存在一条有向边。显然在构造邻接矩阵的时候，我们需要实现一个整形的二维数组。由于当前的图还是空的，因此我们还要把这个二维数组中的每个元素都初始化为 0。

在构造好了一个图的结构后，我们需要把图中各边的情况对应在邻接矩阵上。实际上，这一步的实现非常简单，当从顶点 x 到 y 上存在边时，我们只要把二维数组对应的位置置为 1 就好了。

/*************************************************************************
	> File Name: 11.graph_matrix.c
	> Author: 陈杰
	> Mail: 15193172746@163.com
	> Created Time: 2021年04月13日 星期二 09时59分22秒
  > 邻接矩阵存储有向图
************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX_N 500
typedef struct Graph {
    int mat[MAX_N][MAX_N];
    int n;
}Graph;
/*
* 初始化一个邻接矩阵
* @param len: 邻接矩阵的边界
* */
Graph *init(int len) {
    Graph *g = (Graph *)malloc(sizeof(Graph));
    g->n = len;
    memset(g->mat, 0, sizeof(g->mat));
    return g;
}
/*
* 插入一个边
* @param g: 要操作的矩阵指针
* @param a: 插入关系，a==1时为无向边
* @param x: 初始点编号
* @param y: 终止点编号
* */
void insert(Graph *g, int a, int x, int y) {
    if(x < 1 || y < 1 || x > g->n || y > g->n) return;
    if(a) g->mat[y][x] = 1;
    g->mat[x][y] = 1;
}
/*
* 打印输出
* @param g: 要操作的矩阵指针
* */
void output(Graph *g) {
    for(int i = 0; i < g->n; i++) {
        for(int j = 0; j < g->n; j++) {
            j == 0 || printf(" ");
            printf("%d", g->mat[i][j]);
        }
        printf("\n");
    }
}
int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    Graph *graph = init(n);
    int a, x, y;
    for(int i = 0; i < m; i++) {
        scanf("%d %d %d", &a, &x, &y);
        insert(graph, a, x, y);
    }
    output(graph);
    free(graph);
    return 0;
}
邻接表

邻接表是图的一种顺序存储与链式存储相结合的存储方法。我们给图 G 中的每个顶点建立一个单链表，第 i 个单链表中的结点表示依附于顶点 vi 的边（对于有向图是以 vi 为起点的弧）。所有单链表的表头结点都存储在一个一维数组中，以便于顶点的访问。下图为图 G1 对应的邻接表。

在无向图的邻接表中，顶点 vi 的度为第 i 个单链表中的结点数；而在有向图中，第 i 个单链表中的结点数表示的是顶点 vi 的出度，如果要求入度，则要遍历整个邻接表。另外，在邻接表中，我们很容易就能知道某一顶点和哪些顶点相连接。

邻接矩阵存储结构最大的优点就是简单直观，易于理解和实现。其适用范围广泛，有向图、无向图、混合图、带权图等都可以直接用邻接矩阵表示。另外，对于很多操作，比如获取顶点度数，判断某两点之间是否有连边等，都可以在常数时间内完成。然而，它的缺点也是显而易见的：当边数很少的时候，就会造成空间的浪费。

因此，具体使用哪一种存储方式，要根据图的特点来决定：如果是稀疏图，我们一般用邻接表来存储，这样可以节省空间；如果是稠密图，考虑到邻接表中要附加链域，我们一般用邻接矩阵来存储。

在构造邻接表需要借助链表的结构。对图中每个顶点的信息，我们都会分别使用一个链表来进行存储。因此，我们需要初始化一个有 n 个元素的链表数组，n 为图中顶点数量。

我们要在邻接表中存储的图的信息，实际上就是顶点之间存在的有向边。当从顶点a到顶点b存在一条有向边时，我们只需要在头结点为a的链表后插入一个节点b，值得注意的是，当一条边从顶点b到顶点a时，我们同样需要在以b为头结点的链表后插入一个节点a。

/*************************************************************************
	> File Name: 11.graph_linklist.c
	> Author: 陈杰
	> Mail: 15193172746@163.com
	> Created Time: 2021年04月13日 星期二 10时37分10秒
  > 邻接表存储有向图
************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX_N  500
/*
* 定义一个链表用来存储每个元素所关联的结点元素
* */
typedef struct Node{
    int vertex;
    struct Node *next;
} Node, *LinkList;
/*
* 再指定链表插入一个新结点
* @param head: 要插入的链表头节点
* @param index: 要插入的值
* */
LinkList insert_node(LinkList head, int index) {
    Node *node = (Node *)malloc(sizeof(Node));
    node->vertex = index;
    node->next = head;
    return node;
}
/*
* 邻接表结构
* */
typedef struct Graph {
    LinkList edges[MAX_N];
    int n;
}Graph;
/*
* 初始化一个邻接矩阵
* @param n:数据范围
* */
Graph *init(int n){
    Graph *g = (Graph *)malloc(sizeof(Graph));
    g->n = n;
    for(int i = 0; i <= n; i++) g->edges[i] = NULL;
    return g;
}
/*
* 插入一条边到邻接表
* @param g: 要操作的图的指针
* @param a: 边的类型，当a==1时为无向边
* @param x: 起始点编号
* @param y: 终止点编号
* */
void insert(Graph *g, int a, int x, int y) {
    if(x < 1 || y < 1 || x > g->n || y > g->n) return;
    g->edges[x] = insert_node(g->edges[x], y);
    if(a) g->edges[y] = insert_node(g->edges[y], x);
}
/*
* 打印邻接表
* @param g: 要操作的图的指针
* */
void output(Graph *g) {
    for(int i = 1; i <= g->n; i++) {
        printf("%d:", i);
        for(Node *node = g->edges[i]; node != NULL; node = node->next) {
            printf("%d", node->vertex);
        }
        printf("\n");
    }
}
/*
* 邻接表清理
* @param g: 要操作的图的指针
* */
void clear(Graph *g) {
    for(int i = 1; i <= g->n; i++) {
        Node *node = g->edges[i];
        while(node != NULL) {
            Node *delete_node = node;
            node = node->next;
            free(delete_node);
        }
    }
    free(g);
}
int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    Graph *graph = init(n);
    for(int i = 0; i < m; i++) {
        int a, x, y;
        scanf("%d %d %d", &a, &x, &y);
        insert(graph, a, x, y);
    }
    output(graph);
    clear(graph);
    return 0;
}

图的遍历

从图中某个顶点出发访问到图中每个顶点，且使得每个顶点刚好被访问一次，这一过程被称为图的遍历。常用的两种图的遍历算法：深度优先搜索和广度优先搜索。

图的遍历和生成树

图的遍历和树或森林的遍历的核心思路很像：都是化繁为简。此前我们通过对二叉树进行遍历，将二叉树转换为一个线性序列，把树这种非线性结构转化为线性序列，这就是化繁为简的方式。这样一来，二叉树的很多问题都可以转化到线性序列上进行求解。

线性序列是树或森林的一个特例，而树或森林则是图结构的一个特例。仿照树的遍历，我们在对图进行遍历的过程中，首先将图这种复杂的非线性结构，转化为图的一种特例，即一棵树——生成树（也叫支撑树）。

这样的一棵生成树，具有两个重要的性质：其一，它的根节点便是我们对图进行遍历时的起始顶点；其二，它包含图中的所有顶点。对于一个图，可能会有很多种合法的生成树。

深度优先搜索算法

深度优先搜索（Depth-First-Search，简称DFS） 是一种常见的用于遍历或搜索树和图的算法，主要用来判断起点与终点之间的连通性问题。

开始我们假设图上所有顶点都未被访问，选择图中任一顶点，开始执行以下操作：

  1. 访问当前顶点v，并将顶点标为已访问。
  2. 遍历与顶点v相邻的所有顶点c，然后对顶点v所有尚未被访问的相邻顶点c，递归地执行第一步操作。如果当前顶点已经没有未访问的相邻顶点了，则说明该分支搜索结束，沿通路回溯到顶点v。
  3. 此时如果还有相邻顶点没有被访问，则从该顶点继续开始深度优先搜索。直到所有顶点都被访问。

从操作方法上我们可以看出，深度优先搜索遍历算法总是沿着图的某一深度进行遍历，尽可能深的搜索与当前相邻的顶点，如果相邻的顶点都已被访问则回溯到上一层，直至所有顶点都已被访问。

仔细分析后我们发现，对一个连通图进行深度优先搜索，其实是在对该图的一个生成树进行搜索，这里我们把这棵生成树称为深度优先搜索树。

对于算法的具体实现，因深度优先搜索的优先遍历深度更大的顶点，所以我们可以借助栈这一数据结构来实现：

  1. 将要访问的第一个顶点v入栈，然后首先对其进行访问。
  2. 将顶点v出栈，依次将与顶点v相邻且未被访问的顶点c压入栈中。
  3. 重复第一步操作，直至栈为空。

为了方便，我们通常以递归的形式实现深度优先搜索。

邻接矩阵的深度优先遍历
/*************************************************************************
	> File Name: 11.graph_matrix_dfs.c
	> Author: 陈杰
	> Mail: 15193172746@163.com
	> Created Time: 2021年04月13日 星期二 11时39分53秒
  > 题目描述
  读入一个用邻接矩阵存储的无向图，输出它的深度优先遍历序列。（以 1 为起点，按照编号越小权值越大的规则）

  > 输入
  第一行一个正整数 N，表示节点个数。（5≤N≤20）
  接下来输入一个邻接矩阵，a[i,j]=0表示 i,j 之间不存在边，=1说明存在边。

  > 输出
  按照遍历顺序输出遍历点的编号。
************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#define MAX_N 500
typedef struct Graph {
    int mat[MAX_N][MAX_N];
    int n;
} Graph;
/*
* 初始化一个邻接矩阵
* @param len: 邻接矩阵的边界
* */
Graph *init(int len) {
    Graph *g = (Graph *)malloc(sizeof(Graph));
    g->n = len;
    memset(g->mat, 0, sizeof(g->mat));
    return g;
}
/*
* 有向边插入
* @param g: 要操作的矩阵指针
* @param x: 初始点编号
* @param y: 终止点编号
* */
void insert(Graph *g, int x, int y) {
    if(x < 1 || y < 1 || y > g->n || y > g->n) return;
    g->mat[x][y] = 1;
}

int mark[25];
/*
* 邻接矩阵深搜
* @param g: 要操作的矩阵指针
* @param s: 起始点
* @param n: 数据上限
* */
void dfs(Graph *g, int s, int n) {
    mark[s] = 1;
    s == 1 || printf("-");;
    printf("%d", s);
    for(int i = 1; i <= n; i++) {
        if(mark[i] == 0 && g->mat[s][i]) {
            dfs(g, i, n);
        }
    }
}
int main() {
    int n;
    scanf("%d", &n);
    Graph *g = init(n);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            int t;
            scanf("%d", &t);
            if(t) insert(g, i, j);
        }
    }
    for(int i = 1; i <= n; i++) {
        if(mark[i] == 0) dfs(g, i,n);
    }
    printf("\n");
    free(g);
    return 0;
}
邻接表的深搜
/*************************************************************************
	> File Name: 11.graph_linklist_dfs.c
	> Author: 陈杰
	> Mail: 15193172746@163.com
	> Created Time: 2021年04月13日 星期二 10时37分10秒
  > 题目描述
  读入一个用邻接矩阵存储的无向图，输出它的深度优先遍历序列。（以 1 为起点，按照编号越小权值越大的规则）

  > 输入
  第一行一个正整数 N，表示节点个数。（5≤N≤20）
  接下来输入一个邻接矩阵，a[i,j]=0表示 i,j 之间不存在边，=1说明存在边。

  > 输出
  按照遍历顺序输出遍历点的编号。
************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX_N  500
/*
* 定义一个链表用来存储每个元素所关联的结点元素
* */
typedef struct Node{
    int vertex;
    struct Node *next;
} Node, *LinkList;
/*
* 再指定链表插入一个新结点
* @param head: 要插入的链表头节点
* @param index: 要插入的值
* */
LinkList insert_node(LinkList head, int index) {
    Node *node = (Node *)malloc(sizeof(Node));
    node->vertex = index;
    node->next = NULL;
    if(head == NULL) return node;
    Node *current = head;
    while(current->next) current = current->next;
    current->next = node;
    return head;
}
/*
* 邻接表结构
* */
typedef struct Graph {
    LinkList edges[MAX_N];
    int n;
}Graph;
/*
* 初始化一个邻接矩阵
* @param n:数据范围
* */
Graph *init(int n){
    Graph *g = (Graph *)malloc(sizeof(Graph));
    g->n = n;
    for(int i = 0; i <= n; i++) g->edges[i] = NULL;
    return g;
}
/*
* 插入一条边到邻接表
* @param g: 要操作的图的指针
* @param x: 起始点编号
* @param y: 终止点编号
* */
void insert(Graph *g, int x, int y) {
    if(x < 1 || y < 1 || x > g->n || y > g->n) return;
    g->edges[x] = insert_node(g->edges[x], y);
}
/*
* 深度优先遍历邻接表
* @param g: 要操作的图的指针
* @param index: 起始点编号
* */
int mark[25];
void dfs(Graph *g, int index) {
    index == 1 || printf("-");
    printf("%d", index);
    mark[index] = 1;
    for(Node *node = g->edges[index]; node; node = node->next) {
        if(mark[node->vertex] == 0) {
            dfs(g, node->vertex);
        }
    }
}
/*
* 邻接表清理
* @param g: 要操作的图的指针
* */
void clear(Graph *g) {
    for(int i = 1; i <= g->n; i++) {
        Node *node = g->edges[i];
        while(node != NULL) {
            Node *delete_node = node;
            node = node->next;
            free(delete_node);
        }
    }
    free(g);
}
int main() {
    int n;
    scanf("%d", &n);
    Graph *graph = init(n);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            int t;
            scanf("%d", &t);
            if(t) insert(graph, i, j);
        }
    }
    for(int i = 1; i <= n; i++) {
        if(mark[i] == 0) dfs(graph, i);
    }
    printf("\n");
    clear(graph);
    return 0;
}
广度优先搜索算法

**广度优先搜索(Breadth-First-Search, 简称BFS)**是一种连通图的常用遍历策略，通常用于求起点到各点的最短路径，以及求两点之间的最优路径等问题。

对于一个连通图，我们假设一开始所有顶点均未被访问，广度优先搜索的主要操作如下：

  1. 选择图中任意一个顶点v作为起点进行访问，并将顶点v标记为已访问。
  2. 遍历并访问与顶点v相邻且未被访问的所有顶点c1,c2…ck，接着遍历并访问与顶点c1,c2…ck相邻且未被访问的顶点，也就是依次访问所有相邻顶点的相邻顶点，以此类推，直到所有顶点均被访问。

从遍历的过程我们可以看到，广度优先搜索总是从某一起点出发逐层进行搜索，每一层的顶点到起点的边数都是一样的。这一过程正好解释了为什么广度优先搜索可以求出图中一点到各点的最短距离，以及求某两点之间的最优路径等问题。

同样我们可以从遍历过程中发现，对一个连通图进行广度优先搜索，其实是在对该图的一个生成树进行搜索，这里我们把这个生成树称为广度优先搜索树。

结合队列先进先出的特性，我们可以借助它来具体实现广度优先搜索：

  1. 任意选择一个顶点v作为起点，加入队列。
  2. 访问队首元素v并标记，将其从队列中删除。
  3. 遍历与定点v相邻且未被访问的所有顶点c1,c2…ck，并依次加入到队列中。
  4. 重复第二步和第三步操作，直到队列为空。
邻接矩阵的广度优先遍历
/*************************************************************************
	> File Name: 11.graph_matrix_bfs.c
	> Author: 陈杰
	> Mail: 15193172746@163.com
	> Created Time: 2021年04月13日 星期二 16时12分54秒
  > 题目描述
  读入一个用邻接矩阵存储的无向图，输出它的广度优先遍历序列。（以 1 为起点，按照编号越小权值越大的规则）

  > 输入
  第一行一个正整数 N，表示节点个数。（5≤N≤20）
  接下来输入一个邻接矩阵，a[i,j]=0表示 i,j 之间不存在边，=1说明存在边。

  > 输出
  按照遍历顺序输出遍历点的编号。
************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX_N 500
typedef struct Graph {
    int mat[MAX_N][MAX_N];
    int n;
} Graph;
/*
* 初始化一个邻接矩阵
* @param len: 邻接矩阵的边界
* */
Graph *init(int len) {
    Graph *g = (Graph *)malloc(sizeof(Graph));
    g->n = len;
    memset(g->mat, 0, sizeof(g->mat));
    return g;
}
/*
* 有向边插入
* @param g: 要操作的矩阵指针
* @param x: 初始点编号
* @param y: 终止点编号
* */
void insert(Graph *g, int x, int y) {
    if(x < 1 || y < 1 || x > g->n || y > g->n) return;
    g->mat[x][y] = 1;
}
/*
* 定义一个队列
* */
typedef struct Queue {
    int *data;
    int head, tail, size, length;
} Queue;
/*
* 初始化一个队列
* @param size: 队列的大小
* */
Queue *queue_init(int size) {
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->data = (int *)malloc(sizeof(int) * size);
    q->head = q->tail = q->length = 0;
    q->size = size;
    return q;
}
/*
* 判空
* @param q: 要操作的队列指针
* */
int empty(Queue *q) {
    return q->length == 0;                          // 判断队列长度是否为零
}
/*
* 扩容
* @param q: 要操作的队列指针
* */
int expand(Queue *q) {
    if(q == NULL) return 0;
    int extr_size = q->size;
    int *p = NULL;
    while(extr_size) {                              // 空间使用过大，可能造成申请失败
        p = (int *)malloc(sizeof(int) * (q->size + extr_size));
        if(p) {
            for(int j = 0; j < q->length; j++) p[j] = q->data[(q->head + j) % q->size];
            free(q->data);
            q->data = p;
            q->head = 0;
            q->tail = q->length;
            q->size += extr_size;
            return 1;                  
        }
        extr_size >>= 1;                            // 扩容大小减半
    }
    return 0;
}
/*
* 入队
* @param q: 要操作的队列指针
* @param val: 要入队的新元素值
* */
int push(Queue *q, int val) {
    if(q == NULL) return 0;                         // 判断队列是否存在
    if(q->tail == q->length && !expand(q)) return 0;// 队列已满且扩容失败
    q->data[q->tail++] = val;
    if(q->tail == q->size) q->tail = 0;             // tail值达到size时赋值为0
    // q->tail = q->tail % q->size;
    q->length++;
    return 1;
}
/*
* 出队
* @param q: 要操作的队列指针
* */
int pop(Queue *q) {
    if(q == NULL || empty(q)) return 0;             // 队列不存在或者为空
    q->head++;
    if(q->head == q->size) q->head = 0;             // head值达到size值时赋值为0
    // q->head = q->head % q->size;
    q->length--;
    return 1;
}
/*
* 获得队首元素值
* @param q: 要操作的队列指针
* */
int front(Queue *q) {
    return q->data[q->head];
}
/*
* 队列销毁
* @param q: 要操作的队列指针
* */
void clear_queue(Queue *q) {
    if(q == NULL) return;
    free(q->data);
    free(q);
}
int mark[25];
/*
* 广度优先遍历
* @param g: 要操作的矩阵指针
* @param s: 起始点
* @param n: 数据上限
* */
void bfs(Graph *g, int s, int n) {
    Queue *que = queue_init(n);
    push(que, s);
    mark[s] = 1;
    while(!empty(que)) {
        int temp = front(que);
        temp == 1 || printf("-");
        printf("%d", temp);
        pop(que);
        for(int i = 1; i <= n; i++) {
            if(g->mat[temp][i] && mark[i] == 0) {
                push(que, i);
                mark[i] = 1;
            }
        }
    }
    clear_queue(que);
}
int main() {
    int n;
    scanf("%d", &n);
    Graph *g = init(n);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            int t;
            scanf("%d", &t);
            if(t) insert(g, i, j);
        }
    }
    for(int i = 1; i <= n; i++) {
        if(mark[i] == 0) bfs(g, i,n);
    }
    printf("\n");
    free(g);
    return 0;
}
邻接表的广度优先遍历
/*************************************************************************
	> File Name: 11.graph_linklist_bfs.c
	> Author: 陈杰
	> Mail: 15193172746@163.com
	> Created Time: 2021年04月13日 星期二 16时57分31秒
  > 题目描述
  读入一个用邻接矩阵存储的无向图，输出它的广度优先遍历序列。（以 1 为起点，按照编号越小权值越大的规则）

  > 输入
  第一行一个正整数 N，表示节点个数。（5≤N≤20）
  接下来输入一个邻接矩阵，a[i,j]=0表示 i,j 之间不存在边，=1说明存在边。

  > 输出
  按照遍历顺序输出遍历点的编号。
 ************************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX_N  500
/*
* 定义一个链表用来存储每个元素所关联的结点元素
* */
typedef struct Node{
    int vertex;
    struct Node *next;
} Node, *LinkList;
/*
* 再指定链表插入一个新结点
* @param head: 要插入的链表头节点
* @param index: 要插入的值
* */
LinkList insert_node(LinkList head, int index) {
    Node *node = (Node *)malloc(sizeof(Node));
    node->vertex = index;
    node->next = NULL;
    if(head == NULL) return node;
    Node *current = head;
    while(current->next) current = current->next;
    current->next = node;
    return head;
}
/*
* 邻接表结构
* */
typedef struct Graph {
    LinkList edges[MAX_N];
    int n;
}Graph;
/*
* 初始化一个邻接矩阵
* @param n:数据范围
* */
Graph *init(int n){
    Graph *g = (Graph *)malloc(sizeof(Graph));
    g->n = n;
    for(int i = 0; i <= n; i++) g->edges[i] = NULL;
    return g;
}
/*
* 插入一条边到邻接表
* @param g: 要操作的图的指针
* @param x: 起始点编号
* @param y: 终止点编号
* */
void insert(Graph *g, int x, int y) {
    if(x < 1 || y < 1 || x > g->n || y > g->n) return;
    g->edges[x] = insert_node(g->edges[x], y);
}
/*
* 定义一个队列
* */
typedef struct Queue {
    int *data;
    int head, tail, size, length;
} Queue;
/*
* 初始化一个队列
* @param size: 队列的大小
* */
Queue *queue_init(int size) {
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->data = (int *)malloc(sizeof(int) * size);
    q->head = q->tail = q->length = 0;
    q->size = size;
    return q;
}
/*
* 判空
* @param q: 要操作的队列指针
* */
int empty(Queue *q) {
    return q->length == 0;                          // 判断队列长度是否为零
}
/*
* 扩容
* @param q: 要操作的队列指针
* */
int expand(Queue *q) {
    if(q == NULL) return 0;
    int extr_size = q->size;
    int *p = NULL;
    while(extr_size) {                              // 空间使用过大，可能造成申请失败
        p = (int *)malloc(sizeof(int) * (q->size + extr_size));
        if(p) {
            for(int j = 0; j < q->length; j++) p[j] = q->data[(q->head + j) % q->size];
            free(q->data);
            q->data = p;
            q->head = 0;
            q->tail = q->length;
            q->size += extr_size;
            return 1;                  
        }
        extr_size >>= 1;                            // 扩容大小减半
    }
    return 0;
}
/*
* 入队
* @param q: 要操作的队列指针
* @param val: 要入队的新元素值
* */
int push(Queue *q, int val) {
    if(q == NULL) return 0;                         // 判断队列是否存在
    if(q->tail == q->length && !expand(q)) return 0;// 队列已满且扩容失败
    q->data[q->tail++] = val;
    if(q->tail == q->size) q->tail = 0;             // tail值达到size时赋值为0
    // q->tail = q->tail % q->size;
    q->length++;
    return 1;
}
/*
* 出队
* @param q: 要操作的队列指针
* */
int pop(Queue *q) {
    if(q == NULL || empty(q)) return 0;             // 队列不存在或者为空
    q->head++;
    if(q->head == q->size) q->head = 0;             // head值达到size值时赋值为0
    // q->head = q->head % q->size;
    q->length--;
    return 1;
}
/*
* 获得队首元素值
* @param q: 要操作的队列指针
* */
int front(Queue *q) {
    return q->data[q->head];
}
/*
* 队列销毁
* @param q: 要操作的队列指针
* */
void clear_queue(Queue *q) {
    if(q == NULL) return;
    free(q->data);
    free(q);
}
/*
* 深度优先遍历邻接表
* @param g: 要操作的图的指针
* @param index: 起始点编号
* @param n: 数据上限
* */
int mark[25];
void bfs(Graph *g, int index, int n) {
    Queue *que = queue_init(n);
    push(que, index);
    mark[index] = 1;
    while(!empty(que)) {
        int temp = front(que);
        temp == 1 || printf("-");
        printf("%d", temp);
        pop(que);
        for(Node *node = g->edges[index]; node; node = node->next) {
            if(mark[node->vertex] == 0) {
                mark[node->vertex] = 1;
                push(que, node->vertex);
            }
        }
    }
    clear_queue(que);
}
/*
* 邻接表清理
* @param g: 要操作的图的指针
* */
void clear(Graph *g) {
    for(int i = 1; i <= g->n; i++) {
        Node *node = g->edges[i];
        while(node != NULL) {
            Node *delete_node = node;
            node = node->next;
            free(delete_node);
        }
    }
    free(g);
}
int main() {
    int n;
    scanf("%d", &n);
    Graph *graph = init(n);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            int t;
            scanf("%d", &t);
            if(t) insert(graph, i, j);
        }
    }
    for(int i = 1; i <= n; i++) {
        if(mark[i] == 0) bfs(graph, i, n);
    }
    printf("\n");
    clear(graph);
    return 0;
}
nodd_le
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的存储与遍历(数据结构)
12-10
目 录 第一章 课程设计目的 2 第二章 课程设计内容和要求 2 第三章 课程设计分析 3 第四章 算法描述 4 第五章 源代码 8 第六章 运行结果分析 13 第七章 结束语 15 第八章 参考文献 15 第一章 课程设计目的 本学期我们对《数据结构》这门课程进行了学习。这门课程是一门实践性非常强的课程，为了让大家更好地理解与运用所学知识，提高动手能力，我们进行了此次课程设计实习。这次课程设计不但要求实习者掌握《数据结构》中的各方面知识，还要求实习者具备一定的C语言基础和编程能力。 具体说来，这次课程设计主要有两大方面目的。 一是让实习者通过实习掌握《数据结构》中的知识。对于《图的存储与遍历》这一课题来说，所要求掌握的数据结构知识主要有：图的邻接表存贮结构、队列的基本运算实现、邻接表的算法实现、图的广度优先搜索周游算法实现、图的深度优先搜索周游算法实现。 二是通过实习巩固并提高实习者的C语言知识，并初步了解Visual C++的知识，提高其编程能力与专业水平。 第二章 课程设计内容和要求 2.1课程设计内容 该课题要求以邻接表的方式存储图，输出邻接表，并要求实现图的深度、广度两种遍历。
JS for...in 遍历语句用法实例分析
10-21
在这个结构中，`变量`用来存储当前迭代的属性名称，而`对象`是你要遍历的对象。`for...in`会按照属性创建的顺序遍历所有可枚举属性，但不包括原型链中的属性（除非显式地通过`Object.prototype`进行访问）。 例如，...
图的存储和遍历
m0_51711089的博客
07-22 600
深度优先搜索遍历图以"深度"为关键词，沿着一条路直到无法继续前进，才退回到路径上离当前顶点最近的且有未遍历分支的岔路口，并前往访问那些未遍历的分支，直到遍历完整个图。用vector实现邻接表，在一些顶点数目较大（一般顶点个数在1000以上）的情况下，一般是使用邻接表而不是邻接矩阵才存储图。图的遍历是指按一定顺序遍历所有顶点，一般遍历方法有两种，分别是深度优先搜索和广度优先搜索。图的存储方式有两种分别是邻接矩阵和邻接表；只适用于顶点数不太大（.........
用邻接矩阵存储无向图的深度优先遍历
weixin_47511190的博客
08-26 2017
实现代码： #include<iostream> #include<queue> using namespace std; //邻接矩阵存储无向图的深度优先遍历 #define MaxSize 10 #define inf 0x3f3f3f bool book[MaxSize]; int n,m; //顶点数 边数 struct MGraph{ //定义图 int edge[MaxSize][MaxSize]; //存储边 int vexnum,arcnum;
【图形结构】图 {图的基本概念；图的存储结构：邻接矩阵，邻接表；图的遍历：BFS，DFS}
最新发布
芥末虾的博客
05-09 1027
【图形结构】图 {图的基本概念；图的存储结构：邻接矩阵，邻接表；图的遍历：BFS，DFS}
图的遍历 深度优先遍历(爱思创)
HackerYY的博客
07-26 1134
爱思创DFS图的遍历
图论--图的存储及遍历
信息学奥赛学案
07-04 1105
图的存储与遍历
xx.zip_先序遍历_遍历
09-24
"xx.zip"文件可能包含了一棵二叉树的表示，可能是通过某种序列化方法将树结构存储为文本或二进制数据。"新建文件夹"可能包含了这些数据或实现遍历的程序代码。用户可能需要解压文件，然后根据文件内容理解二叉树的...
Python 迭代，for...in遍历，迭代原理与应用示例
09-18
在Python编程语言中，迭代是一种重要的概念，它允许我们遍历任何可迭代对象的元素，无需预先知道集合的大小或结构。`for...in`语句是Python中用于迭代最常用的语法，它使得代码简洁易读。下面我们将深入探讨Python的...
daohang.rar_完全遍历
09-22
遍历图就是按照一定的顺序访问图中所有节点的过程。常见的图遍历方法有深度优先搜索（DFS，Depth-First Search）和广度优先搜索（BFS，Breadth-First Search）。 1. **深度优先搜索**：DFS是一种递归策略，从起始...
erchashu.rar_层序遍历算法
09-20
层序遍历算法是二叉树遍历方法中的一种，主要应用于数据结构和算法领域，尤其是在处理二叉树问题时。二叉树是一种特殊的树结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在二叉树的层序遍历中，我们...
图的存储结构和遍历
12-17
//----------------------图的邻接矩阵存储表示----------------------- typedef struct ArcCell { VRType adj; //顶点关系类型。对无权图，用1或0表示是否相邻 }ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; typedef struct { VertexType vexs[MAX_VERTEX_NUM]; //顶点向量 AdjMatrix arcs; //邻接矩阵 int vexnum,arcnum; //图的当前顶点数和弧数 }MGraph; //-----------------------图的邻接表存储表示------------------------ typedef struct ArcNode { int adjvex; //该弧所指向的顶点的位置 struct ArcNode *nextarc; //指向下一条弧的指针 InfoType *info; //该弧相关信息的指针值 }ArcNode; typedef struct VNode { VertexType data; //顶点信息 ArcNode *firstarc; //指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VERTEX_NUM]; typedef struct { AdjList vertices; int vexnum,arcnum; //图的当前顶点数和弧数 }ALGraph;
图的存储、构造、遍历、应用（代码+注释+图片说明）
bigBbug的博客
01-24 824
图的存储（邻接矩阵、邻接表）、构造、遍历（BFS、DFS）、应用（最小生成树Prim-Kruscal、最短路径BFS-Dijkstra-Floyd、拓扑排序、关键路径）
图的存储结构及遍历算法
执迷不悔
03-09 4214
一、图的存储结构 1.1 邻接矩阵     图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。     设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为：          看一个实例，下图左就是一个无向图。          从上面可以看出，无向图的边数组是一
【数据结构基础】图的遍历方法与应用
wayne_lee_lwc的博客
12-03 2939
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
图的存储与遍历
m0_74082869的博客
05-11 55
【代码】图的存储与遍历。
采用邻接矩阵的形式存储图，进行图的深度优先搜索并输出结果。
weixin_57940917的博客
11-28 1642
一，首先要用邻接矩阵的形式存储图。定义好图的邻接矩阵，定义一维数组vexs[]用来表示与顶点有关的信息，二维数组arcs[][]用来表示图中不同边的权值。由于广度优先遍历需要的循环队列，所以也要构建队列，以及相关的初始化，入队，判空，出队等配套的函数。然后要创建邻接矩阵，并对邻接矩阵中顶点个数，边的个数，不同边的权值进行初始化。完成邻接矩阵的存储。 二，进行深度优先搜索然后遍历。深度优先遍历是个递归过程，所以这个算法可以用递归实现。首先，若访问过顶点，则该标识设置为1，并输出当前顶点。若某个顶点没有被访问
由邻接矩阵存储的图的dfs和bfs
西电卢本伟的博客
12-21 847
题目：图的深度优先遍历 问题描述 已知无向图的邻接矩阵，以该矩阵为基础，给出深度优先搜索遍历序列，并且给出该无向图的连通分量的个数。 在遍历时，当有多个点可选时，优先选择编号小的顶点。（即从顶点1开始进行遍历） 输入格式 第一行是1个正整数，为顶点个数n（n<100），顶点编号依次为1，2，…，n。 后面是邻接矩阵，n行n列。 输出格式 共2行。 第一行输出为无向图的深度优先搜索遍历序列，输出为顶点编号，顶点编号之间用空格隔开； 第二行为无向图的连通分量的个数。 样例输入 6 0 1 0 0 0
研究以二叉树为例（人员个数及权值自定义），实现以下任务： 1.采用树的孩子兄弟链表等存储结构； 2.实现在人事关系树中查找、添加、删除指导人员功能； 3.创建树结构； 4.通过深度优先遍历搜索； 5.通过层次优先遍历搜索.6.构造哈夫曼树，并对其编码。7.采用Java语言编写代码实现，并撰写实验报告。实验的实验思路
06-01
我们可以先遍历左子树，然后遍历右子树，最后访问当前节点。可以定义如下: ``` void dfs(Node node) { if (node == null) { return; } dfs(node.left); dfs(node.right); System.out.print(node.value + " ")...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值