图的基本操作

我们采用邻接矩阵的方式来存储图：
基础练习：
1.图的深度优先遍历
2.图的广度优先遍历

#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 breadFirstTraverse(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

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

CMap:: ~CMap()
{
    delete[] m_pNodeArray;
    delete[]m_pMatrix;

}

bool CMap::addNode(Node* pNode)
{
    m_pNodeArray[m_iNodeCount] = 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()
{
    cout << "  ";
    for (int j = 0; j < m_iCapacity; ++j)
    {
        cout << m_pNodeArray[j].m_cData<<' ';
    }
    cout << endl;
    for (int i = 0; i < m_iCapacity; ++i)
    {
        cout << m_pNodeArray[i].m_cData << ' ';
        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)
{
    val = m_pMatrix[row*m_iCapacity + col];

    return true;
}

//深度优先遍历
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)
            {
                continue;
            }
            else
            {
                depthFirstTraverse(i);
            }
        }
        else
        {
            continue;
        }
    }
}

//广度优先遍历
void CMap::breadFirstTraverse(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)
            {
                continue;
            }
            else
            {
                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);
    }


}

结点信息

#ifndef NODE_H
#define NODE_H

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

};

#endif

测试程序：

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

void Test()
{
    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->resetNode();
    pMap->depthFirstTraverse(0);
    cout <<endl;

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

    system("pause");
}

int main()
{
    Test();
    return 0;
}