数据结构实验3--图以邻接矩阵为存储结构的初始化，遍历，迪杰斯特拉算法求最短路径（实验内容1~2,5）

图的指向

运行结果：

源文件：

#include "邻接矩阵宽度优先遍历的queue.h"
//邻接矩阵的初始化
Status Init(MGraph* mg, int nSize, ElemType noEdgeValue)
{
	int i, j;
	mg->numofDot = nSize;
	mg->numofEdg = 0;
	mg->noEdge = noEdgeValue;
	mg->a = (ElemType**)malloc(nSize * sizeof(ElemType*));
	if (!mg->a)
		return ERROR;
	for (int i = 0; i < mg->numofDot; i++)
	{
		mg->a[i] = (ElemType*)malloc(nSize * sizeof(ElemType));
		for (int j = 0; j < mg->numofDot; j++)
		{
			mg->a[i][j] = mg->noEdge;
		}
		mg->a[i][i] = 0;
	}
	return OK;
}

//邻接矩阵的撤销
void Desory(MGraph* mg)
{
	int i;
	for (i = 0; i < mg->numofDot; i++)
	{
		free(mg->a[i]);
	}
	free(mg->a);
}

//边的搜索
Status Exist(MGraph* mg, int u, int v)
{
	if (u<0 || v<0 || u>mg->numofDot - 1 || v>mg->numofDot - 1 || u == v || mg->a[u][v] == mg->noEdge)
		return ERROR;
	return OK;
}

//边的插入
Status Insert(MGraph* mg, int u, int v, ElemType w)
{
	if (u<0 || v<0 || u>mg->numofDot - 1 || v>mg->numofDot - 1 || u == v)
		return ERROR;
	if (mg->a[u][v] != mg->noEdge)
		return Duplicate; //若待插入边已存在，则返回出错信息
	mg->a[u][v] = w;
	mg->numofEdg++;
	return OK;
}

//边的删除
Status Remove(MGraph* mg, int u, int v)
{
	if (u<0 || v<0 || u>mg->numofDot - 1 || v>mg->numofDot - 1 || u == v)
		return ERROR;
	if (mg->a[u][v] == mg->noEdge)
		return NotPresent;
	mg->a[u][v] = mg->noEdge;
	mg->numofEdg--;
	return OK;
}

//打印邻接矩阵
void Print(MGraph* mg)
{
	for (int i = 0; i < mg->numofDot; i++)
	{
		for (int j = 0; j < mg->numofDot; j++)
		{
			if (mg->a[i][j] == INF)
			{
				printf("∞\t");
			}
			else
			{
				printf("%lf\t", mg->a[i][j]);
			}
		}
		printf("\n");
	}
}

//邻接矩阵的深度优先遍历
void DFS(MGraph mg, int visited[], int i)
{
	int j;
	visited[i] = 1;
	printf("%d ", i);
	for (int j = 0; j < mg.numofDot; j++)
	{
		if ((mg.a[i][j] != INF && mg.a[i][j] != 0) && visited[j] != 1)
		{
			DFS(mg, visited, j);
		}
	}
}
void DFSMGrapg(MGraph mg)
{
	int* visited = (int*)malloc(mg.numofDot * sizeof(int));
	for (int i = 0; i < mg.numofDot; i++)
	{
		visited[i] = 0;
	}
	for (int i = 0; i < mg.numofDot; i++)
	{
		if (!visited[i])
		{
			DFS(mg, visited, i);
		}
	}
	free(visited);
}

//邻接矩阵的宽度优选遍历
void BFS(MGraph mg, int visited[], int i)
{
	int j;
	visited[i] = 1;
	printf("%d ", i);
	Queue q;
	queuecreate(&q, mg.numofDot);
	EnQueue(&q, i);
	while (!queueIsEmpty(&q))
	{
		queueFront(&q, &i);
		DeQueue(&q);
		for (int j = 0; j < mg.numofDot; j++)
		{
			if (mg.a[i][j] != INF && mg.a[i][j] != 0 && visited[j] == 0)
			{
				EnQueue(&q, j);
				visited[j] = 1;
				printf("%d ", j);
			}
		}
	}
}
void BFSGraph(MGraph mg)
{
	int i;
	int* visited = (int*)malloc(mg.numofDot * sizeof(int));
	for (i = 0; i < mg.numofDot; i++)
	{
		visited[i] = 0;
	}
	for (i = 0; i < mg.numofDot; i++)
	{
		if (visited[i] == 0)
		{
			BFS(mg, visited, i);
		}
	}
	free(visited);
}



int Choose(ElemType* d, int* s, int n)
{
	int i, minpos;
	ElemType min;
	min = INF;
	minpos = -1;
	for (i = 0; i < n; i++)
	{
		if (d[i] < min && !s[i])
		{
			min = d[i];
			minpos = i;
		}
		return minpos;
	}
}
Status Dijkstra(int v, ElemType* d, int* path, MGraph g)
{
	int i, k, w;
	int* s;
	if (v<0 || v>g.numofDot - 1)
		return ERROR;
	s = (int*)malloc(sizeof(int) * g.numofDot);
	for (i = 0; i < g.numofDot; i++)
	{
		s[i] = 0;
		d[i] = g.a[v][i];
		if (i != v && d[i] < INF)
			path[i];
		path[i] = -1;
	}
	s[v] = 1;
	d[v] = 0;
	for (i = 1; i < g.numofDot - 1; i++)
	{
		k = Choose(d, s, g.numofDot);
		if (k == -1)
			continue;
		s[k] = 1;
		printf("%d ", k);
		for (w = 0; w < g.numofDot; w++)
		{
			if (!s[w] && d[k] + g.a[k][w] < d[w])
			{
				d[w] = d[k] + g.a[k][w];
				path[w] = k;
			}
		}
	}
	for (i = 0; i < g.numofDot; i++)
	{
		printf("%d ", d[i]);
	}
	return OK;
}

//迪杰斯特拉算法根据权重求最短路径
void dijkstra(MGraph mg)
{
	int u, v;
	printf("请输入起点u = \t");
	scanf_s("%d", &u);
	double allLength = 0;
	int i, j, index;
	double min;
	double* ahead = (double*)malloc(mg.numofDot * sizeof(double));  //记录离起点最短路径的顶点集合
	double* after = (double*)malloc(mg.numofDot * sizeof(double));  //记录还未求出最短路径的顶点集合(包括其离起点的距离)
	for (i = 0; i < mg.numofDot; i++)
	{
		ahead[i] = INF;
		after[i] = INF;
	}
	//初始化起点u的after和ahead
	for (j = 0; j < mg.numofDot; j++)
	{
		if (mg.a[u][j] != INF&&j!=u)
		{
			after[j] = mg.a[u][j];
		}
	}
	after[u] = 0;
	for (int n = 1; n < mg.numofDot; n++)
	{
		min = INF;
		for (i = 0; i < mg.numofDot; i++)
		{
			if (min > after[i] && after[i] != -1&&i!=u)
			{
				min = after[i];
			}
		}
		for (index = 0; index < mg.numofDot; index++)
		{
			if (index == u)
				continue;
			if (after[index] == min)
				break;
		}
		ahead[index] = min;
		after[index] = -1;


		for (int k = 0; k < mg.numofDot; k++)
		{
			if (mg.a[index][k] != INF && mg.a[index][k] != 0&&k!=u)
			{
				if (after[k] > ahead[index] + mg.a[index][k])
				{
					after[k] = ahead[index] + mg.a[index][k];
				}

			}
		}
	}

	for (i = 0; i < mg.numofDot; i++)
	{
		if (i != u)
		{
			if (ahead[i] != INF)
			{
				printf("\n起点到%d的距离为：%lf", i, ahead[i]);
				allLength += ahead[i];
			}
			else
			{
				printf("\n起点到%d的距离为：∞",i);
			}
			
		}
		
	}
	printf("\n由此点出发去各地的最短总路径为： %lf", allLength);
	free(ahead);
	free(after);
}

void main()
{
	MGraph mg;
	int nSize = 6, noEdgeValue = INF, nEdge;
	int judge = 0;
	double u, v, w;
	printf("请输入图的总点数：\t");
	scanf_s("%d", &nSize);
	printf("请输入图的总边数：\t");
	scanf_s("%d", &nEdge);
	Init(&mg, nSize, noEdgeValue);
	for (int i = 0; i < nEdge; i++)
	{
		printf("请输入边的指向(u->v)和权重,格式:  u  v   w  :  ");
		scanf_s("%lf %lf %lf", &u, &v, &w);
		int judges = Insert(&mg, u, v, w);
		switch (judges)
		{
		case 0:
			printf("\n输入的u或v有问题,插入失败,请重试");
			break;
		case 1:
			printf("");
			break;
		case 5:
			printf("\n此边已存在，插入失败,请重试");
			break;
		default:
			break;
		}
	}
	Print(&mg);
	printf("\n邻接矩阵的深度优先遍历为：\n");
	DFSMGrapg(mg);
	printf("\n邻接矩阵的宽度优先遍历为:\n");
	BFSGraph(mg);
	printf("\n");
	dijkstra(mg);
}

邻接矩阵宽度优先遍历的queue.h

#pragma once
#include "邻接矩阵的基础结构.h"

typedef struct Queue
{
	int front;
	int rear;
	int maxSize;
	int* element;
}Queue;
void queuecreate(Queue* Q, int mSize)
{
	Q->maxSize = mSize;
	Q->element = (int*)malloc(sizeof(int) * mSize);
	Q->front = Q->rear = 0;
}
void queueDestory(Queue* Q)
{
	Q->maxSize = 0;
	Q->front = Q->rear = -1;
	free(Q->element);
}
BOOL queueIsEmpty(Queue* Q)
{
	return Q->front == Q->rear;
}
BOOL queueIsFull(Queue* Q)
{
	return (Q->rear + 1) % Q->maxSize == Q->front;
}
BOOL queueFront(Queue* Q, int* x)
{
	if (queueIsEmpty(Q))
		return false;
	*x = Q->element[(Q->front + 1) % Q->maxSize];
	return true;
}
BOOL EnQueue(Queue* Q, int x)
{
	if (queueIsFull(Q))
		return false;
	Q->rear = (Q->rear + 1) % Q->maxSize;
	Q->element[Q->rear] = x;
	return true;
}
BOOL DeQueue(Queue* Q)
{
	if (queueIsEmpty(Q))
		return false;
	Q->front = (Q->front + 1) % Q->maxSize;
	return true;
}
void queueClear(Queue* Q)
{
	Q->front = Q->rear = 0;
}

邻接矩阵的基础结构.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define ERROR 0 ;
#define OK 1;
#define Overflow 2;
#define Underflow 3;
#define NotPresent 4;
#define Duplicate 5;
typedef int Status;
typedef double ElemType;
typedef bool BOOL;
#define INF 2147483647
typedef struct mGraph
{
	ElemType** a;  //邻接矩阵
	int numofDot;    //图当前的顶点数
	int numofEdg;   //图的当前边数
	ElemType noEdge;   //两顶点间无边时的值
}MGraph;