Node.h 宣告頂點類

#pragma once
class Node
{
public:
	Node(char data=0);
	char m_cData;
	bool m_bIsVisited;
};

Node.cpp 實現頂點的成員以及操作函式

#include "Node.h"


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

cMap.h宣告圖的成員和操作函式，這裡圖只用了頂點和鄰接矩陣表示

#pragma once
#include "Node.h"
#include<vector>
using namespace std;

class cMap
{
private:
	int m_iCapacity;                                                    // 圖中最多可以容納的定點數
	int m_iNodeCount;                                                   // 已經新增的頂點個數
	Node *m_pNodeArray;                                                 // 用來存放頂點陣列
	int *m_pMatrix;                                                     // 用來存放鄰接矩陣

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();                                                  // 列印鄰接矩陣
	bool getValueFromMatrix(int row, int col, int&val);                  // 訪問鄰接矩陣的值
	void depthFirstTraverse(int nodeIndex);                              // 深度優先搜尋
	void breadthFirstTraverse(int nodeIndex);                            // 廣度優先搜尋
	void breadthFirstTraverseImpl(vector<int> preVec);                   // 對給定的陣列進行廣度優先搜尋

};
 

cMap.cpp實現了圖的成員和操作函式

#include "cMap.h"
#include<iostream>


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));
}


cMap::~cMap()
{
	delete[]m_pNodeArray;
	delete[]m_pMatrix;
}

bool cMap::addNode(Node *pNode)
{
	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)
{
	m_pMatrix[row*m_iCapacity + col] = val;
	return true;
}

bool cMap::setValueToMatrixForUnDirectedGraph(int row, int col, int val)
{
	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;
	}
	
}
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;
	cout << 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)
		{
			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);
	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)
			{
				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
	{
		breadthFirstTraverseImpl(curVec);
	}
}
 

下面是測試主函式

#include<iostream>
#include "cMap.h"
#include "Node.h"
using namespace std;
/*
          A
		/   \
	  B       D
	/   \    / \
   C    F   G   H
    \  /
	  E

	  A B C D E F G H
	A   1   1
	B 1   1     1
	C   1     1 1
	D 1           1 1
	E     1
	F   1 1
	G       1       1
	H       1     1

*/

int main()
{
	cMap *pMap = new cMap(8);
	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(3, 6);
	pMap->setValueToMatrixForUnDirectedGraph(3, 7);
	pMap->setValueToMatrixForUnDirectedGraph(6, 7);
	pMap->setValueToMatrixForUnDirectedGraph(2, 4);
	pMap->setValueToMatrixForUnDirectedGraph(4, 5);

	pMap->printMatrix();
	cout << endl;

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

	pMap->resetNode();

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

    return 0;
}