2021-04-11数据结构

学习目标：

图的操作和定义

学习内容：

邻接矩阵
图的定义
邻接表
图的遍历（bfs&dfs）
最小生成树（普利姆算法&克鲁斯卡尔算法）

学习时间：

2021.4.10 上午
2021.4.11 晚上

学习产出：

邻接矩阵:

typedef struct
{
	int no;                             //顶点编号
	char info;                          //顶点其他信息
}VertexType;                            //顶点类型

图的定义：

typedef struct                          //图的定义
{
	int edges[maxSize][maxSzie];        //有权图为float
	int n, e;
	VertexType vex[maxSize];            //存放结点信息
}MGraph;

邻接表;

typedef struct
{
	int adjvex;                          //该边指向结点的位置
	struct ArcNode* nextarc;             //指向下一条边的指针
	int info;                            //该边的相关信息
}ArcNode;
typedef struct
{
	char data;                           //顶点信息
	ArcNode* firstarc;                   //指向第一条边的指针
}VNode;
typedef struct
{
	VNode adjlist[maxSzie];              //邻接表
	int n, e;                            //顶点数和边数
}AGraph;                                 //图的邻接表类型

图的遍历
深度优先搜索遍历:

int visit[maxSzie];

void DFS(AGraph* G, int v)
{
	ArcNode* p;
	visit[v] = 1;                         //已访问标记
	visit(v);
	p = G->adjlist[v].firstarc;           //指向第一条边
	while (p != NULL)
	{
		if (visit[p->adjvex] == 0)        //如果没有访问，则递归访问
			DFS(G, p->adjvex);
		p = p->nextarc;
	}
}

广度优先搜索遍历:

void BFS(AGraph* G, int v, int visit[maxSize])
{
	ArcNode* p;
	int que[maxSize], front = 0.rear = 0;        //队列定义的简单写法
	int j;
	Visit(v);
	visit[v] = 1;
	rear = (rear + 1) & maxSize;
	que[rear] = v;
	while (front != NULL）                       //队空遍历完成
		{
			front = (front + 1) % maxSzie;       //顶点出队
			j = que[front];
			p = G->adjlist[j].firstarc;          //p指向出队结点j的第一条边
			while (p != NULL)                    //将p的所有临界点没有被访问的入队
			{
				if (visit[p->adjevx] = 0)
				{
					 visit(p->adjvex);
					 visit[p->adjvex] = 1;
					 rear = (rear + 1) % maxSize;//该顶点进队
					 que[rear] = p->adjvex;
				}
			 p = p->nextarc;                     //p指向j的下一条边
			}
		}
}

最小代价生成树
普利姆算法：

void Prim(MGraph g, int v0, int& sum)
{
	int lowcost[maxSize], vset[maxSize], v;
	int i, j, k, min;
	v = v0;
	for (i = 0; i < g.n; ++i)
	{
		lowcost[i] = g.edges[v0][i];
		vset[i] = 0;
	}
	vset[v0] = 1;                                            //将v0并入树中
	sum = 0;
	for (i = 0; i < g.n - 1; ++i)
	{
		min = INF;                                           //INF是一个定义的比图所有边权值都大的常量
		for (j = 0; j < g; ++j)                              //选出候选边的最小值
			if (vset[j] == 0 && lowcost[j] < min)
			{                                                //最短边的最短的一条
				min = lowcost[j];
				k = j;
			}
		vset[k] = 1;
		v = k;
		sum += min;                                          //这里用sum纪录了最小生成树的权值
		for (j = 0; j < g.n; ++j)                            //以v为媒介来更新侯选边
			if (vset[j] == 0 && g.edges[v][j] < lowcost[i])
				lowcost[j] = g, edges[v][j];
	}
}

克鲁斯卡尔算法：

typedef struct
{
	int a, b;                                                //a和b为一条边连的两个顶点
	int w;                                                   //边的权值
}Road;
Road road{ maxSize]
int v[maxSize];                                              //定义并查集数组
int getRoot(int a)                                           //查找根节点的函数
{
	while (a != v[a]a = v[a]);
	return a;
}
void Kruskal(MGraph g, int& sum, Road road[])
{
	int i;
	int N, E, a, b;
	N = g.n;
	E = g.e;
	sum = 0;
	for (i = 0; i < N; ++i)v[i] = i;
	sort(road, E);                                            //排序
	for (i = 0; i < E; ++i)
	{
		a = getRoot(road[i].a);
		b = getRoot(road[i].b);
		if (a != b)
		{
			v[a] = b;
			sum += road[i].w;                                 //求生成树的权值
		}
	}
}