数据结构探险——图的广度和深度优先遍历

@这篇文档是由C++代码实现的图

图分为有向图和无向图。我们暂且将结点与结点之间的弧的权值不赋其他值，只是分为0和1，两个结点之间有链接就赋值为1，没有连接就赋值为0.这样就会形成一个邻接矩阵，这个矩阵中行和列的交叉处的值，代表行和列所代表的结点之间是否有连接。

本文是以Visual Studio中新建的C++win32的控制台应用程序实现的，其中建立了头文件和源文件以及实现main()的demo文件，分别是Tree.h和Tree.cpp和Node.h和Node.cpp和demo.cpp文件

其中Node.h定义了结点的数据成员，包括储存数据的m_cData和该结点是否被访问过的布尔值，还有结点的构造函数。Cmap.h中定义了图元素所拥有的数据成员和成员函数。demo.h中以下图中的无向图为例，将图元素存入图中，并将图中的弧也存入一个数组中，相当于一个矩阵。

Node.h文件

#ifndef NODE_H
#define NODE_H

class Node
{
public:
	Node(char data=0);
	char m_cData;				//当前结点的数据值
	bool m_bIsVisited;			//当前结点是否被访问过
};

#endif

Node.cpp文件

#include "Node.h"

Node::Node(char data)
{
	m_cData = data;
	m_bIsVisited = false;
}

Cmap.h文件

#ifndef CMAP_H
#define CMAP_H
#include "Node.h"
#include <iostream>
#include <vector>
using namespace std;

class Cmap
{
public:
	Cmap(int capacity);
	~Cmap();
	bool addNode(Node *pNode);			//向图中加入顶点
	void resetNode();					//重置顶点
	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);		//广度优先遍历

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

	int m_iCapacity;			//图中最多可以容纳的顶点数
	int m_iNodeCount;			//已经添加的顶点（结点）个数
	Node *m_pNodeArray;			//用来存放顶点数组
	int *m_pmatrix;				//用来存放邻接矩阵
};

#endif

Camp.cpp文件

#include "Cmap.h"
#include <iostream>
#include <vector>
using namespace std;


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));			//memset(数组名，用于替换的字符，前n个字符)，该函数用于对较大的数组清零操作
	for (int i=0;i<m_iCapacity*m_iCapacity;i++)
	{
		m_pmatrix[i] = 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;
	}
}

/*为有向图设置邻接矩阵,弧的权值由val元素定，可以用0或者1表示他们之间是否连接，也可以使用其他数值给予一定的权值*/
/*只不过有向图中的相同两个结点之间的弧的权值不一定相等，所以要分开赋值*/
/*由于val的值是默认给出的，所以val的参数值可以省略*/
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;
}

/*为有向图设置邻接矩阵,弧的权值由val元素定，可以用0或者1表示他们之间是否连接，也可以使用其他数值给予一定的权值*/
/*而有向图中的相同两个结点之间的弧的权值是相等的，所以统一赋值即可*/
/*由于val的值是默认给出的，所以val的参数值可以省略*/
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 j=0;j<m_iCapacity;j++)
		{
			cout << m_pmatrix[i*m_iCapacity+j] << " ";
		}
		cout << endl;
	}
}

/*获取矩阵中的某条弧的权值，是通过在数组中的位置获得的*/
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;
}


 /*深度优先遍历算法*/
void Cmap::depthFirstTraverse(int nodeIndex)
{
	int value = 0;
	cout << nodeIndex << ":" <<m_pNodeArray[nodeIndex].m_cData << " ";
	m_pNodeArray[nodeIndex].m_bIsVisited = true;
	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 << nodeIndex << ":" << m_pNodeArray[nodeIndex].m_cData << " ";
	m_pNodeArray[nodeIndex].m_bIsVisited = true;

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


void Cmap::breadthFirstTraverseImpl(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],i,value);
			if (value == 0)
			{
				continue;
			} 
			else
			{
				if (!m_pNodeArray[i].m_bIsVisited)
				{
					cout << i << ":" << m_pNodeArray[i].m_cData << " ";		//这其中的i表示第preVec[j]行的第i列，
																			//而第i列也就是m_pNodeArray中的下标为i的元素
					m_pNodeArray[i].m_bIsVisited = true;
					curVec.push_back(i);
				}
				else
				{
					continue;
				}
			}
		}
	}
	if (curVec.size() == 0)
	{
		return;
	} 
	else
	{
		breadthFirstTraverseImpl(curVec);
	}
}

demo.cpp文件

#include "Cmap.h"
#include <iostream>
using namespace std;

int main()
{
	Cmap *pMap = new Cmap(10);

	Node *pNodeA = new Node('A');
	Node *pNodeB = new Node('B');
	Node *pNodeC = new Node('C');
	Node *pNodeD = new Node('D');
	Node *pNodeE = new Node('E');
	Node *pNodeF = new Node('F');
	Node *pNodeG = new Node('G');
	Node *pNodeH = new Node('H');

	pMap->addNode(pNodeA);
	pMap->addNode(pNodeB);
	pMap->addNode(pNodeC);
	pMap->addNode(pNodeD);
	pMap->addNode(pNodeE);
	pMap->addNode(pNodeF);
	pMap->addNode(pNodeG);
	pMap->addNode(pNodeH);


	pMap->setValueToMatrixForUndirectedGraph(0,1);
	pMap->setValueToMatrixForUndirectedGraph(0,3);
	pMap->setValueToMatrixForUndirectedGraph(1,2);
	pMap->setValueToMatrixForUndirectedGraph(1,5);
	pMap->setValueToMatrixForUndirectedGraph(2,4);
	pMap->setValueToMatrixForUndirectedGraph(3,6);
	pMap->setValueToMatrixForUndirectedGraph(3,7);
	pMap->setValueToMatrixForUndirectedGraph(4,5);
	pMap->setValueToMatrixForUndirectedGraph(6,7);

	pMap->printMatrix();

	cout << endl;
	pMap->depthFirstTraverse(0);

	pMap->resetNode();
	cout << endl;
	cout << endl;
	pMap->breadthFirstTraverse(0);
	cout << endl;

	delete pMap;
	pMap = NULL;
	
	system("pause");
	return 0;
}