初学编程C++之图_c++编程图解-CSDN博客

代码示例：
#ifndef NODE_H
#define NODE_H
class Node
{
public:
	Node(char data=0);
	char m_cData;
	bool m_bIsVisited;
};
#endif

#include"Node.h"
Node::Node(char data)
{
	m_cData=data;
	m_bIsVisited=false;
}

#ifndef CMAP_H
#define CMAP_H
#include<vector>
using namespace std;
#include"Node.h"
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);//广度优先遍历实现函数
private:
	int m_iCapacity;//图中最多可以容纳的定点数
	int m_iNodeCount;//已经添加的顶点（结点）个数
	Node*m_pNodeArray;//用来存放的数组
	int *m_pMatrix;//用来存放邻接矩阵
};
#endif

#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));
	 for(int i=0;i<m_iCapacity*m_iCapacity;i++)
	 {
		 m_pMatrix[i]=0;
	 }
}
CMap::~CMap()
{
	delete []m_pNodeArray;
	m_pNodeArray=NULL;
	delete []m_pMatrix;
	m_pMatrix=NULL;
}
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]<<" ";//row
		}
		cout<<endl;
	}
}
void CMap::depthFirstTraverse(int nodeIndex)
{
	int value=0;
	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==1)
		{
			if(m_pNodeArray[i].m_bIsVisited==true)
			{
				continue;
			}
			else
			{
				depthFirstTraverse(i);
			}
		}
		else
		{
			continue;
		}
	}
}
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::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<stdlib.h>
#include"CMap.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
  D 1           1 1
  E     1     1
  F   1     1
  G             1
  H             1
  深度遍历：A B C E F D G H
  广度遍历：A B D C F G H E
  */
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,1);
	pMap->setValueToMatrixForUndirectedGraph(0,3,1);
	pMap->setValueToMatrixForUndirectedGraph(1,2,1);
	pMap->setValueToMatrixForUndirectedGraph(1,5,1);
	pMap->setValueToMatrixForUndirectedGraph(3,6,1);
	pMap->setValueToMatrixForUndirectedGraph(3,7,1);
	pMap->setValueToMatrixForUndirectedGraph(6,7,1);
	pMap->setValueToMatrixForUndirectedGraph(2,4,1);
	pMap->setValueToMatrixForUndirectedGraph(4,5,1);
	pMap->printMatrix();
	cout<<endl;
	pMap->depthFirstTraverse(0);
	cout<<endl;
	pMap->resetNode();
	pMap->breadthFirstTraverse(0);
	system("pause");
	return 0;
}