采用邻接矩阵实现图的遍历

#include<stdlib.h>
#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;

class Node
{
public:
	Node(char data = 0);
	char m_cData;  //当前节点的数据值
	bool m_bIsVisited;  //标识当前节点有没有被访问过,如果被访问过则置为true
};
Node::Node(char data /* = 0 */)
{
	m_cData = data;
	m_bIsVisited = false;
}

class CMap
{
public:
	CMap(int capacity);
	~CMap();
	bool addNode(Node *pNode); //向图中添加节点
	void resetNode(); //重置节点,将所有节点设置为未被访问过
	                                     //行      //列    //如果不指定权值,默认为1
	bool setValueToMatrixForDirectedGraph(int row, int col, int val = 1); //为有向图设置邻接矩阵,对边进行设置,即向邻接矩阵中设值
	bool setValueToMatrixForUndirectedGraph(int row, int col, int val = 1);  //为无向图设置邻接矩阵

	void printMatrix(); //打印邻接矩阵

	void depthFirstTraverse(int nodeIndex); //深度优先遍历

	void breadthFirstTraverse(int nodeIndex); //广度优先遍历
	void breadthFirstTraverseImp(vector<int> preVec); 
private:
	bool getValueFromMatrix(int row, int col, int &val); //从矩阵中获取权值
	

private:
	int m_iCapacity; //图中最多可以容纳的节点数
	int m_iNodeCount; //已经添加的节点个数
	Node *m_pNodeArray; //指向一段内存,用来存放顶点数组
	int *m_pMatrix;  //用来存放邻接矩阵
};

CMap::CMap(int capacity)
{
	m_iCapacity = capacity;
	m_iNodeCount = 0;
	m_pNodeArray = new Node[m_iCapacity];
	m_pMatrix = new int[m_iCapacity*m_iCapacity];
	memset(m_pMatrix, 0, m_iCapacity*m_iCapacity*sizeof(int));//将当前数组中的每一个元素都置为0

}

CMap::~CMap()
{
	delete[]m_pNodeArray;
	delete[]m_pMatrix;
}
bool CMap::addNode(Node *pNode)
{
	if (pNode==NULL)
	{
		return false;
	}
	      //该数组下标即为顶点的索引
	m_pNodeArray[m_iNodeCount].m_cData = pNode->m_cData;
	m_iNodeCount++;
	return true;
}
void CMap::resetNode()
{
	for (int i = 0; i < m_iNodeCount;i++)
	 {
		 m_pNodeArray[i].m_bIsVisited = false;
	 }
}

bool CMap::setValueToMatrixForDirectedGraph(int row, int col, int val)
{
	if (row < 0 || row >= m_iCapacity)
	{
		return false;
	}
	if (col < 0 || col >= m_iCapacity)
	{
		return false;
	}
	//有向图 
	//只设置对应的行和列即可
	m_pMatrix[row*m_iCapacity + col] = val;
	return true;
}

bool CMap::setValueToMatrixForUndirectedGraph(int row, int col, int val)
{
	if (row < 0 || row >= m_iCapacity)
	{
		return false;
	}
	if (col < 0 || col >= m_iCapacity)
	{
		return false;
	}
	//无向图
	//设置当前行和列,同时设置对角线的位置为同样的值
	m_pMatrix[row*m_iCapacity + col] = val;
	m_pMatrix[col*m_iCapacity + row] = val;
	return true;
}

void CMap::printMatrix()
{
	for (int i = 0; i < m_iCapacity;i++)
	{
		for (int k = 0; k < m_iCapacity;k++)
		{
			                 //下标的形式
			cout << m_pMatrix[i*m_iCapacity + k] << " ";
		}
		cout << endl;
	}

}

void CMap::depthFirstTraverse(int nodeIndex)
{
	cout << m_pNodeArray[nodeIndex].m_cData << " ";
	m_pNodeArray[nodeIndex].m_bIsVisited = true;

	int value;
	for (int i = 0; i < m_iCapacity;i++)
	{
		getValueFromMatrix(nodeIndex, i, value);
		if (value==1)
		{
			if (m_pNodeArray[i].m_bIsVisited)
			{
				continue;
			}
			else
			{
				depthFirstTraverse(i);
			}
		}
		else
		{
			continue;
		}
	}
}

void CMap::breadthFirstTraverse(int nodeIndex)
{
	cout << m_pNodeArray[nodeIndex].m_cData << " ";
	m_pNodeArray[nodeIndex].m_bIsVisited = true;

	vector<int>curVec;
	curVec.push_back(nodeIndex);

	breadthFirstTraverseImp(curVec);
}
void CMap::breadthFirstTraverseImp(vector<int> preVec)
{
	int value = 0;
	vector<int>curVec;

	for (int j = 0; j < (int)preVec.size(); j++)
	{
		for (int i = 0; i < m_iCapacity;i++)
		{
			getValueFromMatrix(preVec[j],j,value);
			if (value!=0)
			{
				if (m_pNodeArray[i].m_bIsVisited)
				{
					continue;
				}
				else
				{
					cout << m_pNodeArray[i].m_cData << " ";
					m_pNodeArray[i].m_bIsVisited = true;

					curVec.push_back(i);
				}
			}
		}
	}
	if (curVec.size()==0)
	{
		return;
	}
	else
	{
		breadthFirstTraverseImp(curVec);
	}
}

bool CMap::getValueFromMatrix(int row, int col, int & val)
{
	if (row < 0 || row >= m_iCapacity)
	{
		return false;
	}
	if (col < 0 || col >= m_iCapacity)
	{
		return false;
	}
	val = m_pMatrix[row*m_iCapacity + col];
	return true;
}