C++实现dijkstra与floyd算法

1. dijkstra是求一个顶点到其他所有顶点的最小距离,类似普里姆算法
2. floyd是把所有结点之间的最小距离求出

• 本程序使用接邻矩阵保存图,测试用例如下图:

#pragma once
#include <iostream>
#include <iomanip>
#include <map>
using namespace std;

template<class T>
class MatriGraphx
{
public:
	MatriGraphx(size_t capacity = 20);
	~MatriGraphx();

	class Vertex//顶点
	{
	public:
		Vertex(T v) : bVisited(0) { val = v; }
		friend class MatriGraphx<T>;
	private:
		T val;
		bool bVisited;
	};
public:
	void addVertex(T);//增加顶点
	void addEdge(int start, int end, int weight = 1);//增加连线，增加边
	void printMatrix();//打印邻接矩阵

	void prim();  //普里姆
	void Kruskal(); //克鲁斯卡尔

	void dijkstra(int begin = 0);  //迪杰斯特拉
	void floyd();  //佛洛依德
private:
	size_t m_size;  //顶点个数
	size_t m_capacity;   //最多可容纳顶点数

	Vertex** m_vArray; //顶点列表
	int** m_pMatrix; //邻接矩阵
};

template<class T>
inline MatriGraphx<T>::MatriGraphx(size_t c)
	:m_size(0),m_capacity(c)
{
	m_vArray = new Vertex* [c];
	m_pMatrix = new int* [c];

	for (size_t i = 0; i < c; i++)
	{
		m_pMatrix[i] = new int[c];
		//memset(m_pMatrix[i], 0, c * sizeof(int)); //初始化为0
	}

	//初始化矩阵,初始化为INT_MAX
	for (size_t i = 0; i < c; i++)
	{
		for (size_t j = 0; j < c; j++)
		{
			if (i != j)
				m_pMatrix[i][j] = INT_MAX;
			else
				m_pMatrix[i][j] = 0;

		}
	}
}

template<class T>
inline MatriGraphx<T>::~MatriGraphx()
{
	delete[] m_vArray;
	delete[] m_pMatrix;
}

template<class T>
inline void MatriGraphx<T>::addVertex(T item)
{
	if (m_size == m_capacity)
		throw "超出容量";
	m_vArray[m_size++] = new Vertex(item);
}

template<class T>
inline void MatriGraphx<T>::addEdge(int start, int end, int weight)
{
	m_pMatrix[start][end] = m_pMatrix[end][start] = weight;
}

template<class T>
inline void MatriGraphx<T>::printMatrix()
{
	std::cout << "顶点个数为 " << m_size << " 个:" << std::endl;
	for (size_t i = 0; i < m_size; i++)
	{
		cout << setw(3) << m_vArray[i]->val << " ";
	}
	cout << endl << endl;

	for (size_t i = 0; i < m_size; i++)
	{
		for (size_t j = 0; j < m_size; j++)
		{
			if (m_pMatrix[i][j] < INT_MAX)
			{
				cout << setw(3) << m_pMatrix[i][j] << " ";
			}
			else
				cout << setw(3) << '-' << " ";
		}
		cout << endl;
	}
}


template<class T>
inline void MatriGraphx<T>::dijkstra(int begin)
{
	int* distance = new int[m_size];  //距离最短的数组
	int* parent = new int[m_size]; //保存父结点
	bool* final = new bool[m_size]; //保存结点是否已确定最小距离

	//初始化数组
	for (int i = 0; i < m_size; i++)
	{
		distance[i] = m_pMatrix[begin][i];
		parent[i] = begin;
		final[i] = false;
	}

	distance[begin] = 0;  //自己到自己为0
	parent[begin] = begin;
	final[begin] = 1;

	int min;
	int v;
	for (size_t i = 0; i < m_size; i++)
	{
		min = INT_MAX;

		//选取最短距离的顶点
		for (int j = 0; j < m_size; j++)
		{
			if (!final[j] && min > distance[j])
			{
				v = j;
				min = distance[j];
			}
		}
		
		//确定到该结点距离最小
		final[v] = true;
		//std::cout << v << " distance :" << distance[v]<< std::endl;

		//更新到各节点的最小距离
		for (int j = 0; j < m_size; j++)
		{
			//以v为跳板,更新距离,使用右边-min而不是左边+min是防止溢出
			if (!final[j] && m_pMatrix[v][j] < distance[j] - min)
			{				
				distance[j] = m_pMatrix[v][j] + distance[v];
				parent[j] = v;
			}
		}

	}

	//输出结果
	for (size_t i = 0; i < m_size; i++)
	{
		int temp = i;
		std::cout << "distance : " << distance[i] << "  " ;
		do
		{
			std::cout << temp << " <- ";
			temp = parent[temp];

		} while (temp != begin);
		std::cout << begin << std::endl;
	}

	delete[] distance;
	delete[] parent;
	delete[] final;
}

template<class T>
inline void MatriGraphx<T>::floyd()
{
	int** distance = new int*[m_size];  //各边之间距离最短的矩阵
	int** parent = new int*[m_size]; //保存父结点

	for (size_t i = 0; i < m_size; i++)
	{
		distance[i] = new int[m_size];
		parent[i] = new int[m_size];
	}

	for (size_t i = 0; i < m_size; i++)
	{
		for (size_t j = 0; j < m_size; j++)
		{
			distance[i][j] = m_pMatrix[i][j];
			parent[i][j] = j;
		}
	}


	for (size_t i = 0; i < m_size; i++)
	{
		for (size_t j = 0; j < m_size; j++)
		{
			for (size_t k = 0; k < m_size; k++)
			{
				if (distance[j][k] - distance[j][i] > distance[i][k])
				{
					distance[j][k] = distance[j][i] + distance[i][k];
					parent[j][k] = parent[j][i];
				}
			}
		}
	}


	for (size_t i = 0; i < m_size; i++)
	{
		for (size_t j = 0; j < m_size; j++)
		{
			if (distance[i][j] < INT_MAX)
			{
				cout << setw(3) << distance[i][j] << " ";
			}
			else
				cout << setw(3) << '-' << " ";
		}
		cout << endl;
	}

	cout << endl;

	for (size_t i = 0; i < m_size; i++)
	{
		for (size_t j = 0; j < m_size; j++)
		{
			if (parent[i][j] < INT_MAX)
			{
				cout << setw(3) << parent[i][j] << " ";
			}
			else
				cout << setw(3) << '-' << " ";
		}
		cout << endl;
	}
	delete[] distance;
	delete[] parent;
}

---

• 测试用例

void main() {
	MatriGraphx<char> g(10);

	g.addVertex('0');//0
	g.addVertex('1');//1
	g.addVertex('2');//2
	g.addVertex('3');//3
	g.addVertex('4');//4
	g.addVertex('5');//5

	g.addEdge(0, 1, 6);
	g.addEdge(0, 2, 1);
	g.addEdge(0, 3, 5);
	g.addEdge(1, 2, 5);
	g.addEdge(1, 4, 3);
	g.addEdge(2, 3, 7);
	g.addEdge(2, 4, 5);
	g.addEdge(2, 5, 4);
	g.addEdge(3, 5, 2);
	g.addEdge(4, 5, 6);

	g.printMatrix();


	std::cout << "迪杰斯特拉算法:" << std::endl;

	g.dijkstra(3);

	std::cout << "弗洛伊德算法:" << std::endl;

	g.floyd();
}