【数据结构】七、图

一、概念

图：记为G(V,E)

有向图：每条边都有方向

无向图：边无方向

完全图：每个顶点都与剩下的所有顶点相连

完全有向图有n(n-1)条边；完全无向图有n(n-1)/2条边

带权图：边上标有数值的图

连通图：任意两点都有路可走

要连通具有n个顶点的有向图，至少需要n条边。（构成环）

生成树：该树包含图的所有n个节点，树有n-1条边，将图连通。

如果添加一条边，必定出现环；

邻接点：一条边两端的点互为邻接点。

度：与点相连的边的条数为点的度；有向图中，从点发出的边数叫点的出度，在点终止的边数叫点的入度。

路径：从一个点沿着边走到另一个点，途径的顶点序列叫路径。

路径长度：非带权图的路径长度是指此路径上边的条数；带权图的路径长度是指路径上各边的权之和。

二、图的存储结构

2.1邻接矩阵

建立一个长和宽都为顶点数的数组，用数组元素的值表示点之间的连接情况。

无向图：

点不相连为0，相连为1
无向图邻接矩阵对称
顶点i的度 = 第i行/列中，1的个数

有向图：

不对称
元素 $a_{ij}$ 为1，表明有一条点i指向点j的边（注意方向）
顶点i的出度 = 第i行中，1的个数
顶点i的入度 = 第i列中，1的个数
顶点i的度 = 第i行和第i列中，1的个数之和

带权图：

相当于把有向图的1换为边上的值

设图的邻接矩阵如下所示。各顶点的度依次是( )

A. 1 2 1 2

B. 2 2 1 1

C. 3 4 2 3

D. 4 4 2 2

答案：C 行和列的1求和

空间复杂度：n^2

代码：

int* adjacent_mat(int v, int e, int direct) 
{int* mat = (int*)malloc(sizeof(int) * v * v);  //分配空间if (!mat) return NULL;int i, start, end, weight;for (i = 0; i < v * v; i++)mat[i] = INF;           //节点全部初始化为无穷大（设无穷为65535）for (i = 0; i < e; i++)     //输入边信息{printf("输入起始 终止 权值：");scanf_s("%d %d %d", &start, &end, &weight);direct == 0 ? mat[start * v + end] = mat[end * v + start] = weight : mat[start * v + end] = weight;      //direct=0时生成无向图，对称赋值；等于1生成有向图}for (i = 0; i < v * v; i++) {mat[i] == INF ? printf("0 ") : printf("%d ", mat[i]);if ((i + 1) % v == 0)printf("\n");}return mat;
}

2.2邻接表

适用于稀疏矩阵

对每个节点建立一个链表，把与之相连的点存入节点，连接起来

无向图的邻接表，顶点的度=该节点链表子结点个数：

有向图的邻接表和逆邻接表：

空间复杂度(n+e) 点数加边数

代码：

node* adjacency_list(int v, int e, int direct) 
{headnode* headlist = (headnode*)malloc(sizeof(headnode) * v);if (!headlist) return NULL;int i;for (i = 0; i < v; i++) {headlist[i].data = i;headlist[i].next = NULL;}int start, end, weight;node* p, * newnode;for (i = 0; i < e; i++){printf("输入起始 终止 权值：");scanf_s("%d %d %d", &start, &end, &weight);if (direct != 2) {newnode = (node*)malloc(sizeof(node));newnode->adjvex = newnode->data = end;newnode->next = NULL;p = headlist[start].next;if (!p) {headlist[start].next = newnode;}else {while ((p->next) != NULL)p = p->next;p->next = newnode;}}if (direct == 0 || direct == 2){newnode = (node*)malloc(sizeof(node));newnode->adjvex = newnode->data = start;newnode->next = NULL;p = headlist[end].next;if (!p) {headlist[end].next = newnode;}else {while ((p->next) != NULL)p = p->next;p->next = newnode;}}}for (i = 0; i < v; i++) {printf("%d:", headlist[i].data);p = headlist[i].next;while (p) {printf("%d ", p->data);p = p->next;}printf("\n");}
}

2.3十字链表

考试没要求，先不写

三、图的遍历

3.1深度优先DFS

沿着一条路一直走，没路了再回头找最近的分岔路口

如上图，从v1开始DFS，可得到v1-v2-v4-v8-v5-v3-v6-v7

void DFS(int*mat, int v, int num, int*& visited)  //深度优先，递归版。需要传入邻接矩阵，点数，起始点编号，已访问数组
{printf("%d", num);             //输出起始节点visited[num] = 1;              //标记起始节点for (int i = 0; i < v; i++)    //在起始节点这一行从头搜索未遍历过的邻接点，进行递归if (!visited[i] && mat[num * v + i] != INF)DFS(mat, v, i, visited);	
}void DFS2(int* mat, int v) 
{int head = 0, i;int* stack = (int*)malloc(sizeof(int) * v);     //创建栈if (!stack) return;int* visited = (int*)malloc(sizeof(int) * v);   //创建标记数组，初始化为0if (!visited)  return;for (i = 0; i < v; i++)visited[i] = 0;int num;printf("输入开始节点编号：");scanf_s("%d", &num);//循环中，入栈在最后，所以先入栈一个点stack[head++] = num;      //入栈，标记, 输出visited[num] = 1;printf("%d", num);int temp;while (head)    //栈空时结束{temp = stack[head - 1];   //获取栈顶for (i = 0; i < v; i++)   //对栈顶对应的邻接矩阵所在行进行遍历，有未标记且相邻的就赋值退出，找不到则退栈{if (visited[i] == 0 && mat[temp * v + i] != INF) {temp = i;break;}}if (i == v)   //找不到退栈，找到入栈head--;else {stack[head++] = i;visited[i] = 1;printf("%d", i);}}
}void DFS3(int* mat, int v) 
{int top = -1, i;int* stack = (int*)malloc(sizeof(int) * v);     //创建栈if (!stack) return;int* visited = (int*)malloc(sizeof(int) * v);   //创建标记数组，初始化为0if (!visited)  return;for (i = 0; i < v; i++)    //标记数组初始化为0visited[i] = 0;int num;printf("输入开始节点编号：");scanf_s("%d", &num);//循环中，入栈在最后，所以先入栈一个点stack[++top] = num;      //入栈，top指向栈顶元素visited[num] = 1;        //标记int temp;while (top >= 0)    //栈空时结束{temp = stack[top];   //获取栈顶printf("%d", temp);for (i = 0; i < v; i++)   //对栈顶对应的邻接矩阵所在行进行遍历，有未标记且相邻的就赋值退出，找不到则退栈{if (visited[i] == 0 && mat[temp * v + i] != INF) {stack[++top] = i;visited[i] = 1;break;}}if (i == v)   //该节点所有相邻节点访问完毕，退栈top--;}
}

3.2广度优先BFS

访问节点，把它的子节点全部访问，再依次访问子节点的全部子节点

四、最小生成树

生成树：是一个极小连通子图，它含有图中全部顶点，但只有n-1条边

最小生成树：各边权值之和最小的树

PRIM普利姆算法

将所有点分为树U和图V两个集合，找到UV两个点集之间的权值最小边，把该边V中的点移到U里面，重复，直到V点全部到U里面

#include<stdio.h>
#include<stdlib.h>#define INF 65535typedef struct node {int adjvex;int data;struct node* next;
}node;typedef struct {int data;node* next;
}headnode;int* adjacent_mat(int v, int e, int direct)
{int* mat = (int*)malloc(sizeof(int) * v * v);if (!mat) return NULL;int i, start, end, weight;for (i = 0; i < v * v; i++)mat[i] = INF;for (i = 0; i < e; i++){printf("输入起始 终止 权值：");scanf_s("%d %d %d", &start, &end, &weight);direct == 0 ? mat[start * v + end] = mat[end * v + start] = weight : mat[start * v + end] = weight;}for (i = 0; i < v * v; i++) {mat[i] == INF ? printf("0 ") : printf("%d ", mat[i]);if ((i + 1) % v == 0)printf("\n");}return mat;
}void prim(int* mat, int v)   //求最小生成树。始终寻找未标记点到已标记集合的最短距离；而迪杰斯特拉是寻找未标记点到源点的最短距离
{int i, num, min, x, time = 0;int* visited = (int*)malloc(sizeof(int) * v);   //标记是否已遍历if (!visited) return;for (i = 0; i < v; i++)visited[i] = 0;int* lowcost = (int*)malloc(sizeof(int) * v);   //lowcost为未标记点到已标记点集合的最小值，from为与之连接的点的编号if (!lowcost) return;int* from = (int*)malloc(sizeof(int) * v);if (!from) return;printf("输入起始节点：");scanf_s("%d", &num);visited[num] = 1;time++;for (i = 0; i < v; i++) {lowcost[i] = mat[num * v + i];from[i] = num;}while (time != v){min = INF;for (i = 0; i < v; i++)    //找到距离最小点，传播{if (lowcost[i] < min && visited[i] != 1){min = lowcost[i];x = i;}}printf("%d-%d\n", from[x], x);visited[x] = 1;//num = x;time++;for (i = 0; i < v; i++)   //更新距离最小值if (mat[x * v + i] < lowcost[i] && visited[i] != 1) {lowcost[i] = mat[x * v + i];from[i] = x;}}
}int main() {int v, e, direct;printf("输入点数 边数：");scanf_s("%d %d", &v, &e);printf("无向图输入0，有向图输入1：");scanf_s("%d", &direct);int* admat = adjacent_mat(v, e, direct);prim(admat, v);
}

时间复杂度：O(n^2)