#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;
}
邻接矩阵——图
猜你喜欢
转载自blog.csdn.net/WxqHUT/article/details/87891380
今日推荐
周排行