邻接矩阵——图

#include <iostream>
#include <vector>
#include <string.h>
using namespace std;
class Edge
{
public:
	Edge(int node1 = 0, int node2 = 0, int value = 0);
	int m_iNodeA;
	int m_iNodeB;
	int m_iValue;
	bool m_bisTraversed;
};
Edge::Edge(int node1, int node2, int value)
{
	m_iNodeA = node1;
	m_iNodeB = node2;
	m_iValue = value;
	m_bisTraversed = false;
}
class Node
{
public:
	Node(char data = 0);
	char m_cData;
	bool m_bisVisited;
};
Node::Node(char data)
{
	m_cData = data;
	m_bisVisited = false;
}
class Map
{
public:
	Map(int capacity = 0);
	~Map();
	bool addNode(Node *pNode);
	bool setUndirectedGraph(int row, int col, int val = 1);
	bool setDirectedGraph(int row, int col, int val = 1);
	void printMatrix(void);
	void deapthFirstTraverse(int nodeIndex);
	void breadthFirstTraverse(int nodeIndex);
	void primTree(int nodeIndex);
private:
	int getMinEdge(vector<Edge> edgeVec);
	void breadthFirstTraverseImpl(vector<int> curVec);
	bool getValueFromMatrix(int row, int col, int &val);
	int m_iCapacity;
	int m_iCount;
	int* m_pMatrix;
	Node* m_pNode;
	Edge* m_pEdge;
};
Map::Map(int capacity) 
{
	m_iCapacity = capacity;
	m_iCount = 0;
	m_pMatrix = new int[m_iCapacity * m_iCapacity];
	m_pNode = new Node[m_iCapacity];
	memset(m_pMatrix, 0, sizeof(int)*m_iCapacity*m_iCapacity);
}
Map::~Map() 
{
	delete[]m_pNode;
	m_pNode = NULL;
	delete[]m_pMatrix;
	m_pMatrix = NULL;
	delete[]m_pEdge;
	m_pEdge = NULL;
}
bool Map::addNode(Node *pNode)
{
	if (pNode == NULL) 
	{
		return false;
	}
	else 
	{
		m_pNode[m_iCount++].m_cData = pNode->m_cData;
		return true;
	}
}
bool Map::setDirectedGraph(int row, int col, int val) {
	if (row < 0 || row >= m_iCapacity ||
		col < 0 || col >= m_iCapacity)
	{
		return false;
	}
	else {
		m_pMatrix[row * m_iCapacity + col] = val;
		return true;
	}
}
bool Map::setUndirectedGraph(int row, int col, int val) {
	if (row < 0 || row >= m_iCapacity ||
		col < 0 || col >= m_iCapacity)
	{
		return false;
	}
	else {
		m_pMatrix[row * m_iCapacity + col] = val;
		m_pMatrix[col * m_iCapacity + row] = val;
		return true;
	}
}
bool Map::getValueFromMatrix(int row, int col, int &val)
{
	if (row < 0 || row >= m_iCapacity ||
		col < 0 || col >= m_iCapacity)
	{
		return false;
	}
	else {
		val = m_pMatrix[row * m_iCapacity + col];
	}
}
void Map::printMatrix(void) {
	for (int i = 0; i < m_iCapacity; i++)
	{
		for (int j = 0; j < m_iCapacity; j++)
		{
			cout << m_pMatrix[i*m_iCapacity + j] << " ";
		}
		cout << endl;
	}
}
void Map::deapthFirstTraverse(int nodeIndex) {
	cout << m_pNode[nodeIndex].m_cData << endl;
	m_pNode[nodeIndex].m_bisVisited = true;
	int value = 0;
	for (int i = 0; i < m_iCapacity; i++) {
		getValueFromMatrix(nodeIndex, i, value);
		if (value != 0) {
			if (m_pNode[i].m_bisVisited) {
				continue;
			}
			else {
				deapthFirstTraverse(i);
			}
		}
	}
}
void Map::breadthFirstTraverse(int nodeIndex) {
	cout << m_pNode[nodeIndex].m_cData << endl;
	m_pNode[nodeIndex].m_bisVisited = true;
	vector<int> nodeVec;
	nodeVec.push_back(nodeIndex);
	breadthFirstTraverseImpl(nodeVec);
}
void Map::breadthFirstTraverseImpl(vector<int> nodeVec)
{
	vector<int> curVec;
	int value;
	for (int i = 0; i < (int)nodeVec.size(); i++)
	{
		for (int j = 0; j < m_iCapacity; j++)
		{
			getValueFromMatrix(nodeVec[i], j, value);
			if (value != 0) {
				if (m_pNode[j].m_bisVisited) {
					continue;
				}
				else {
					cout << m_pNode[j].m_cData << endl;
					m_pNode[j].m_bisVisited = true;
					curVec.push_back(j);
				}
			}
		}
	}
	if (curVec.size() == 0)
	{
		return;
	}
	else {
		breadthFirstTraverseImpl(curVec);
	}
}
void Map::primTree(int nodeIndex) {
	cout << m_pNode[nodeIndex].m_cData << endl;
	m_pNode[nodeIndex].m_bisVisited = true;
	vector<int> nodeVec;
	vector<Edge> edgeVec;
	nodeVec.push_back(nodeIndex);
	int count = 0;
	int value = 0;
	while (count < m_iCapacity - 1) {
		int temp = nodeVec.back();
		for (int i = 0; i < m_iCapacity; i++) {
			getValueFromMatrix(temp, i, value);
			if (value != 0) {
				if (m_pNode[i].m_bisVisited) {
					continue;
				}
				else {
					Edge edge(temp, i, value);
					edgeVec.push_back(edge);
				}
			}
		}
		int edgeIndex = getMinEdge(edgeVec);
		cout << edgeVec[edgeIndex].m_iNodeA << "----";
		cout << edgeVec[edgeIndex].m_iNodeB << "    ";
		cout << edgeVec[edgeIndex].m_iValue << endl;
		edgeVec[edgeIndex].m_bisTraversed = true;
		cout << m_pNode[edgeVec[edgeIndex].m_iNodeB].m_cData << endl;
		m_pNode[edgeVec[edgeIndex].m_iNodeB].m_bisVisited = true;
		nodeVec.push_back(edgeVec[edgeIndex].m_iNodeB);
		count++;
	}
}
int Map::getMinEdge(vector<Edge> edgeVec) {
	int index = 0;
	int value = 1000;
	for (int i = 0; i < (int)edgeVec.size(); i++) {
		if (!edgeVec[i].m_bisTraversed&&edgeVec[i].m_iValue < value) {
			value = edgeVec[i].m_iValue;
			index = i;
		}
	}
	return index;
}