2021-04-12 数据结构

学习目标：

最短路径

学习内容：

迪杰斯特拉算法
弗洛伊德算法

学习时间：

2021.4.12 上午

学习产出：

迪杰斯特拉算法:

void printfPath(int path[], int a)
{
	int stack[maxSize], top = -1;                          //这个循环将以叶子结点到根结点的顺序入栈
	while (path[a] = -1)
	{
		stack[++top] = a;
		a = path[a];
	}
	stack[++top] = a;
	while (top != -1）
		cout << stack[top--] << " ";					   //出栈将以逆序方式打印
	cout << end1;
}
//迪杰斯特拉算法
void Dijkstra(MGraph g, int v, int dist[], int path[])
{
	int set[maxSize];
	int min, i, j, u;
	for (i = 0; i < g.n; ++i)
	{
		dist[i] = g.edges[v][i];
		set[i] = 0;
		if = (g.edges[v][i] < INF)
			path[i] = v;
		else
			path[i] = -1;
	}
	set[v] = 1;
	path[v] = -1;
	for (i = 0; i < g.n; ++i)
	{
		min = INF;                                                       //这个循环每次从剩余一个顶点选出一个顶点，通往这个路径的在通往剩余的顶点的路径是最短的
		for (j = 0; j < g.n; ++j)
		{
			u = j;
			min = dist[j];
		}
		set[u] = 1;                                                      //将选出的结点加入到最短路径当中
		for (j = 0; j < g.n; ++j)
		{
			if (set[j] == 0 && dist[u] + g.edges[u][j] < dist[j])        //这个if语句判断顶点u的加入是否会出现顶点j的更短路径，出现就改变原来的
			{
				dist[j] = dist[u] + g.edges[u][j];
				path[j] = u;
			}
		}
	}
}//dist[]数组存放了v点到其他的顶点的最短路径长度，path[]中存放v点到各顶点的最短路径

弗洛伊德算法:

//弗洛伊德算法
void printPath(int u, int v, int path[], [max], int A[][max])
{
	if (A[u][v] == INF)
	else
	{
		if (path[u][v] == -1)
			cout << A[u][v];
		else
		{
			int mid = path[u][v];
			printPath(u, mid, path, A);//处理mid前半段的路径
			printPath(mid, u, path, A);//处理mid后半段的路径
		}
	}
}

//floyd
void Floyd(MGraph* q, int path[][maxSize], int A[][maxSize])
{
	int i, j, k;
	for (i = 0; i < g->n; ++i)                     //双循环进行初始化
		for (j = 0; j < g->n; ++j)
		{
			A[i][j] = g->edges[i][j];
			Path[i][j] = -1;
		}
	for (k = 0; k < g->n; ++k)                    //3层循环是本算法的主要操作，完成了以k为中间点进行检修和修改
		for (i = 0; i < g->n; ++i)
			for (j = 0; j < g->n; ++j)
				if (A[i][j] > A[i][k] + A[k][j])
				{
					A[i][j] = A[i][k] + A[k][j];
					Path[k];
				}
}