图的经典算法

void Prim(MatGraph g, int v)
{
	int closet[MAXV];
	int lowcost[MAXV];
	int min;
	int i, j, k;
	for (i = 0; i < g.n; i++)
	{
		lowcost[i] = g.edges[v][i];
		closet[i] = v;
	}
	for (i = 1; i < g.n; i++)
	{
		min = INF;
		for (j = 0; j < g.n; j++)
		{
			if (lowcost[j] != 0 && lowcost[j] < min)
			{
				min = lowcost[j];
				k = j;
			}
		}
		lowcost[k] = 0;
		printf("边(%d,%d)权为%d\n", closet[k], k, min);
		for (j = 0; j < g.n; j++)
		{
			if (lowcost[j] != 0 && lowcost[j] > g.edges[k][j])
			{
				lowcost[j] = g.edges[k][j];
				closet[j] = k;
			}
		}
	}
}

typedef struct {
	int u;
	int v;
	int w;
}Edge;
void Kruskal(MatGraph g)
{
	int i, j, k;
	int u1, v1;
	int sn1, sn2;
	Edge E[MAXV];
	int vset[MAXV];
	k = 0;
	for (i = 0; i < g.n; i++)
	{
		for (j = 0; j <= i; j++)
		{
			if (g.edges[i][j] != 0 && g.edges[i][j] != INF)
			{
				E[k].u = i;
				E[k].v = j;
				E[k].w = g.edges[i][j];
				k++;
			}
		}
	}
	insert_sort(E, g.e);
	for (i = 0; i < g.n; i++)
		vset[i] = i;
	k = 1;
	j = 0;
	while (k < g.n)
	{
		u1 = E[j].u;
		v1 = E[j].v;
		sn1 = vset[u1];
		sn2 = vset[v1];
		if (sn1 != sn2)
		{
			printf("(%d,%d):%d\n", u1, v1, E[j].w);
			k++;
			for (i = 0; i < g.n; i++)
			{
				if (vset[i] == sn2)
					vset[i] = sn1;
			}
		}
		j++;
	}

}

void Dijkstral(MatGraph g, int v)
{
	int i, j, u;
	int mindist;
	int path[MAXV];
	int dist[MAXV];
	int S[MAXV];
	for (i = 0; i < g.n; i++)
	{
		S[i] = 0;
		dist[i] = g.edges[v][i];
		if (g.edges[v][i] < INF)
			path[i] = v;
		else
			path[i] = -1;
	}
	S[v] = 1;
	path[v] = 0;
	for (i = 1; i < g.n; i++)
	{
		mindist = INF;
		for (j = 0; j < g.n; j++)
		{
			if (S[j] == 0 && dist[j] < mindist)
			{
				u = j;
				mindist = dist[j];
			}
		}
		S[u] = 1;
		for (j = 0; j < g.n; j++)
		{
			if (S[j] == 0)
			{
				if (g.edges[u][j] < INF && dist[u] + g.edges[u][j] < dist[j])
				{
					dist[j] = dist[u] + g.edges[u][j];
					path[j] = u;
				}
			}
		}
	}
	DispPath(g, dist, path, S, v);
}
void DispPath(MatGraph g, int dist[], int path[], int S[], int v)

void Floyd(MatGraph g)
{
	int A[MAXV][MAXV];
	int path[MAXV][MAXV];
	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];
			if (i != j && g.edges[i][j] < INF)
				path[i][j] = i;
			else
				path[i][j] = -1;
		}
	}
	for (k = 0; k < g.n; 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[i][j] = path[k][j];
				}
			}
		}
	}

}
void Dispath(MatGraph g, int A[][MAXV], int path[][MAXV])
{
	int apath[MAXV], d;
	int i, j, k;
	for (i = 0; i < g.n; i++)
	{
		for (j = 0; j < g.n; j++)
		{
			if (A[i][j] < INF && i != j)
			{
				printf("从%d到%d的路径为：", i, j);
				d = 0;
				apath[d] = j;
				k = path[i][j];
				while (k != -1 && k != i)
				{
					apath[++d];
					k = path[i][k];
				}
				apath[++d] = i;
				printf("%d", apath[d]);
				for (k = d - 1; k >= 0; k--)
					printf(",%d", apath[k]);
				printf("\t路径长度为:%d\n", A[i][j]);
			}
		}
	}
}

typedef struct {
	InfoType info;
	int count;//存放入度
	ArcNode* firstarc;
}VNode;
void TopSort(AdjGraph* G)
{
	int i, j;
	int St[MAXV], top = -1;
	ArcNode* p;
	for (i = 0; i < G->n; i++)
		G->adjlist[i].count = 0;
	for (i = 0; i < G->n; i++)
	{
		p = G->adjlist[i].firstarc;
		while (p != NULL)
		{
			G->adjlist[p->adjvex].count++;
			p = p->nextarc;
		}

	}
	for (i = 0; i < G->n; i++)
	{
		if (G->adjlist[i].count == 0)
			St[++top] = i;
	}
	while (top != -1)
	{
		i = St[top--];
		printf("%d ", i);
		p = G->adjlist[i].firstarc;
		while (p != NULL)
		{
			G->adjlist[p->adjvex].count--;
			if (G->adjlist[p->adjvex].count == 0)
				St[++top] = p->adjvex;
			p = p->nextarc;
		}
		
	}
}