数据结构造轮子4-----图的操作及其常见算法(例:dijstra,floyd,prim,kruskal)

Graph.h

#pragma once

#include "iostream"

#define MAX_VERTEX_NUM 20
#define INFINITY 9999

using namespace std;

/*
	二维数组表示的无向图
*/
class Graph_Using_Array
{
public:
	/*
		邻接矩阵
	*/
	int matrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
	int arcnum;
	int vexnum;

	/*
		为kruskal算法实现方便此处创建一边数据数组
	*/
	struct arc
	{
		int x0, x1;
		int weight;
	}*arcs;

	void InitGraph();
	void CreateGraph();

	/*
		最短路径
	*/
	void Dijstra(int start_point);
	void Floyd(int start_point);

	/*
		最小生成树
	*/
	void Prim(int start_point);
	void Kruskal();
};

class Graph_Using_Adjacency_List
{
public:
	/*
		边节点
	*/
	typedef struct arc_node
	{
		int start_vex;
		int end_vex;

		int weight;

		arc_node * next_in_arc_node;
		arc_node * next_out_arc_node;
	}arc_node;

	/*
		表头节点
	*/
	typedef struct vex_node
	{
		int vex;
		arc_node * first_in_arc_node;
		arc_node * first_out_arc_node;
	}vex_node;

	/*
		图数据
	*/
	vex_node * graph;

	int vexnum;
	int arcnum;

	void InitGraph();
	void CreateGraph();
	void TopologicalSort();
};

Graph_Using_Array.cpp

#include "stdafx.h"
#include "iostream"
#include "Graph.h"

using namespace std;

void Graph_Using_Array::InitGraph()
{
	int i, j;
	for (i = 0;i < MAX_VERTEX_NUM;i++)
	{
		for (j = 0;j < MAX_VERTEX_NUM;j++)
		{
			if (i != j)matrix[i][j] = INFINITY;
			else matrix[i][j] = 0;
		}
	}
}

void Graph_Using_Array::CreateGraph()
{
	cout << "input arcnum:";
	cin >> arcnum;
	/*
		为kruskal算法方便此处创建一arc数组存放边数据
	*/
	arcs = new arc[arcnum];

	cout << "input vexnum:";
	cin >> vexnum;

	int i;
	int x0, x1, weight;
	for (i = 0;i < arcnum;i++)
	{
		cout << "x0,x1,weight:";
		cin >> x0 >> x1;
		cin >> weight;

		/*
			为arc数组同样赋值
		*/
		arcs[i].x0 = x0;
		arcs[i].x1 = x1;
		arcs[i].weight = weight;

		matrix[x0][x1] = weight;
		matrix[x1][x0] = matrix[x0][x1];
	}
}

void Graph_Using_Array::Dijstra(int start_point)
{
	/*
		创建visited数组判断点是否遍历过
		创建distance数组判断start_point到各点距离
	*/
	int visited[MAX_VERTEX_NUM];
	int distance[MAX_VERTEX_NUM];

	/*
		初始化操作
	*/
	int i;
	for (i = 0;i < MAX_VERTEX_NUM;i++)
	{
		visited[i] = 0;
		distance[i] = INFINITY;
	}
	visited[start_point] = 1;
	distance[start_point] = 0;

	/*
		具体实现
	*/
	int j;
	int arc_length = 0;
	for (i = 0;i < vexnum;i++)
	{
		for (j = 0;j < MAX_VERTEX_NUM;j++)
		{
			if (arc_length + matrix[start_point][j] < distance[j] && !visited[j])
			{
				distance[j] = arc_length + matrix[start_point][j];
			}
		}
		arc_length = INFINITY;
		for (j = 0;j < MAX_VERTEX_NUM;j++)
		{
			if (distance[j] < arc_length && !visited[j])
			{
				start_point = j;
				arc_length = distance[j];
			}
		}
		visited[start_point] = 1;
	}

	/*
		输出结果
	*/
	for (i = 0;i < MAX_VERTEX_NUM;i++)
	{
		if (distance[i] != INFINITY)
		{
			cout << "the distance between "<<start_point<<" to " << i << " is " << distance[i] << endl;
		}
	}
}

void Graph_Using_Array::Floyd(int start_point)
{
	/*
		创建distance数组存放各点间距离
	*/
	int distance[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

	/*
		初始化
	*/
	int i, j;
	for (i = 0;i<MAX_VERTEX_NUM;i++)
	{
		for (j = 0;j < MAX_VERTEX_NUM;j++)
		{
			distance[i][j] = matrix[i][j];
		}
	}
	/*
		i:中继点
		j:起始点
		k:终点
	*/
	int k;
	for (i = 0;i<MAX_VERTEX_NUM;i++)
	{
		for (j = 0;j<MAX_VERTEX_NUM;j++)
		{
			for (k = 0;k<MAX_VERTEX_NUM;k++)
			{
				if (distance[j][i] + distance[i][k] < distance[j][k])
				{
					distance[j][k] = distance[j][i] + distance[i][k];
				}
			}
		}
	}

	/*
	输出结果
	*/
	for (i = 0;i < MAX_VERTEX_NUM;i++)
	{
		if (distance[start_point][i] != INFINITY)
		{
			cout << "the distance between "<<start_point<<" to " << i << " is " << distance[start_point][i] << endl;
		}
	}
}

void Graph_Using_Array::Prim(int start_point)
{
	/*
	创建visited数组判断点是否遍历过
	创建distance数组判断当前树到各点距离
	*/
	int visited[MAX_VERTEX_NUM];
	int distance[MAX_VERTEX_NUM];

	/*
		初始化
	*/
	int i;
	for (i = 0;i < MAX_VERTEX_NUM;i++)
	{
		distance[i] = matrix[start_point][i];
		visited[i] = 0;
	}
	visited[start_point] = 1;
	cout << "put node " << start_point << " into tree" << endl;

	/*
		具体实现
	*/
	int j;
	int closest_distance = INFINITY;
	int closest_node = start_point;
	for (i = 0;i < vexnum - 1;i++)
	{
		/*
			寻找最近顶点纳入原树
		*/
		closest_distance = INFINITY;
		for (j = 0;j < MAX_VERTEX_NUM;j++)
		{
			if (distance[j] < closest_distance && !visited[j])
			{
				closest_distance = distance[j];
				closest_node = j;
			}
		}
		cout << "put node " << closest_node << " into tree" << endl;
		visited[closest_node] = 1;

		/*
			刷新距离表
		*/
		for (j = 0;j < MAX_VERTEX_NUM;j++)
		{
			if (matrix[closest_node][j] < distance[j])
			{
				distance[j] = matrix[closest_node][j];
			}
		}
	}
}

void Graph_Using_Array::Kruskal()
{
	/*
		创建set数组判断是否同一连同分量
	*/
	int set[MAX_VERTEX_NUM];

	/*
		初始化
	*/
	int i;
	for (i = 0;i < MAX_VERTEX_NUM;i++)
	{
		set[i] = i;
	}

	/*
		具体实现
	*/
	int j, k;
	int min_arc;
	int min_pos;
	for (i = 0;i < vexnum - 1;i++)
	{	
		/*
		选出权重最小且两端不在同一连同变量的边纳入树
		*/
		min_arc = INFINITY;
		for (j = 0;j < arcnum;j++)
		{
			if (arcs[j].weight < min_arc && (set[arcs[j].x0]!=set[arcs[j].x1]))
			{
				min_arc = arcs[j].weight;
				min_pos = j;
			}
		}
		set[arcs[min_pos].x1] = set[arcs[min_pos].x0];
		cout << "put arc " << arcs[min_pos].x0 << "---" << arcs[min_pos].x1 << " into tree" << endl;
	}
}