基于邻接表的拓扑排序实现

　　上一篇博客实现了图的基本操作(使用邻接表)，包括图的创建、输出、遍历等，这次来实现一下拓扑排序。拓扑排序基本原理可以参考以前转载的一篇博客

http://www.cnblogs.com/zhangbaochong/p/5406159.html

　　由于代码比较简单，就直接贴出来了

#include <queue>
#include <vector>
#include <stack>
#include <iostream>
using namespace std;


enum GraphType
{
    UNDIR_UNWEIGHT_GRAPH,        //无向无权图
    UNDIR_WEIGHT_GRAPH,            //无向带权图
    DIR_UNWEIGHT_GRAPH,            //有向无权图
    DIR_WEIGHT_GRAPH            //有向带权图    
};

//结点颜色代表遍历情况
enum ColorType
{
    WHITE,    //未访问
    GRAY,    //正在访问，邻接点还没访问完
    BLACK    //访问完毕
};

template<typename VertexType, typename InfoType>
class Graph
{
public:
    Graph(int vertexNum, GraphType type) :m_vertexNum(vertexNum), m_type(type), m_arcNum(0)
    {
        for (int i = 0; i < MAX_VERTEX_NUM; ++i)
        {
            m_vertices[i].firstArc = nullptr;
        }
    }

    void Create()
    {
        CreateDirUnweightGraph();
    }


    //输出图的信息
    void Display()
    {
        for (int i = 0; i < m_vertexNum; ++i)
        {
            cout << "第" << i + 1 << "个结点为" << m_vertices[i].data << " 邻接表为：";
            ArcNode* node = m_vertices[i].firstArc;
            while (node)
            {
                cout << "->" << m_vertices[node->vertexIndex].data << "(" << node->info << ")";
                node = node->next;
            }
            cout << endl;
        }
    }

    //拓扑排序
    void TopologicalSort()
    {
        cout << "拓扑排序为：";
        CountInDegree();
        stack<Vertex> s;
        //把所有入度为0的结点入栈
        for (int i = 0; i < m_vertexNum; ++i)
        {
            if (m_inDegreeArray[i] == 0)
                s.push(m_vertices[i]);
        }
        int count = 0;//输出结点计数，用于判断有没有环
        while (!s.empty())
        {
            Vertex v = s.top();
            s.pop();
            cout << v.data << "->";
            ++count;
            ArcNode* node = v.firstArc;
            while (node)
            {
                //从图中删除结点v，v指向的结点入度-1
                //结点 入度为0加入栈中
                if (--m_inDegreeArray[node->vertexIndex] == 0)
                    s.push(m_vertices[node->vertexIndex]);
                node = node->next;
            }
        }
        if (count < m_vertexNum)
            cout << "图中存在环！" << endl;
    }
private:
    struct ArcNode
    {
        int vertexIndex;        //该弧指向的顶点位置
        struct ArcNode* next;    //指向下一个弧
        InfoType info;            //该弧的相关信息，如权重等
    };

    struct Vertex
    {
        VertexType data;    //顶点信息
        ArcNode* firstArc;    //指向第一条依附该节点弧的指针
        ColorType color;    //访问情况
    };

    //最大顶点数
    static const int MAX_VERTEX_NUM = 20;
    Vertex m_vertices[MAX_VERTEX_NUM];    //顶点列表
    int m_vertexNum;    //当前顶点数量
    int m_arcNum;        //当前弧数量
    GraphType m_type;    //图类型：有向无权图、有向带权图、无向无权图、无向无权图

    //结点入度数组
    int m_inDegreeArray[MAX_VERTEX_NUM];
private:
    //初始化顶点列表
    void InitVertices()
    {
        cout << "请输入每个顶点的关键字" << endl;
        VertexType data;
        for (int i = 0; i < m_vertexNum; ++i)
        {
            cin >> data;
            m_vertices[i].data = data;
        }
    }
    //插入一个表结点
    void Insert(int headVertex, int tailVertex, InfoType info)
    {
        //构造一个邻接表结点，即创建一条弧
        ArcNode* newNode = new ArcNode;
        newNode->info = info;
        newNode->next = nullptr;
        newNode->vertexIndex = tailVertex;

        //找到邻接表的最后一个节点
        ArcNode* lastNode = m_vertices[headVertex].firstArc;
        if (lastNode == nullptr)
            m_vertices[headVertex].firstArc = newNode;
        else
        {
            while (lastNode->next)
            {
                lastNode = lastNode->next;
            }
            lastNode->next = newNode;
        }
        ++m_arcNum;
    }

    //创建有向无权图
    void CreateDirUnweightGraph()
    {
        InitVertices();
        cout << "请分别输入每条边的起始结点值:" << endl;
        int head, tail;
        while (cin >> head >> tail)
        {
            Insert(head, tail, 0);
        }
    }
    
    void CountInDegree()
    {
        for (int i = 0; i < m_vertexNum; ++i)
        {
            m_inDegreeArray[i] = 0;
            for (int j = 0; j < m_vertexNum; ++j)
            {
                ArcNode* node = m_vertices[j].firstArc;
                while (node)
                {
                    if (node->vertexIndex == i)
                    {
                        ++m_inDegreeArray[i];
                    }
                    node = node->next;
                }
            }
        }
    }
};

int main()
{
    Graph<char, int> g(6, DIR_UNWEIGHT_GRAPH);
    g.Create();
    g.Display();
    g.TopologicalSort();
}

　　测试用的有向图：

　　输出结果：