封装 有向图(邻接表) 遍历，删除，插入，拓扑排序等

初始化四个弧：

0 1

0 2

3 1

3 2

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

const int MAXSIZE = 10;                    //最多的顶点数

struct ArcNode
{
    int adjvex;                            //结点在数组中的序号
    ArcNode* next;
};
template<class T>
struct VertexNode
{
    T vertex;                            //结点名字
    ArcNode *firstedge;
    int in;                                //记录顶点的入度
};


template<class T>
class ALGraph
{
public:
    ALGraph(){}
    ALGraph(T a[], int n, int e);        //构造函数，初始哈一个有n个顶点e条边的图
    ~ALGraph();                            //析构函数，释放邻接表中各边表结点的存储空间
    T GetVex(int i);                    //取图中第i个顶点数据信息
    void PutVex(int i, T value);        //将图中第i个顶点的数据域置为value
    void InsertVex(T value);            //在图中插入一个顶点，值为value
    void DeleteVex(int i);                //删除结点序号为i的结点
    void InsertArc(int i, int j);        //在图中插入一条边，其依附的两个顶点标号为i和j
    void DeleteArc(int i, int j);        //删除一边，顶点编号i和j
    void DFSTraverse(int v);
    void BFSTraverse(int v);
    void CalAllNodeIns();                //计算所有节点的入度
    void TopSort();                        //拓扑排序
private:
    VertexNode<T> adjlist[MAXSIZE];        //存放顶点表的数组
    int vertexNum, arcNum;                //图的顶点数和边数
    int visited[MAXSIZE];                //DFS递归法之用
};

int main()
{
    char a[4] = { 'a','b','c','d' };
    ALGraph<char> ag(a,4,4);
    ag.TopSort();
    system("pause");
    return 0;
}

template<class T>
ALGraph<T>::ALGraph(T a[], int n, int e)
{
    int p1, p2;
    ArcNode *s;

    vertexNum = n, arcNum = e;
    for (int i = 0; i < vertexNum; i++)    //顶点信息存储在二维数组中，下标从0开始
    {
        adjlist[i].vertex = a[i];
        adjlist[i].firstedge = NULL;
    }
    for (int i = 0; i < arcNum; i++)
    {
        cin >> p1 >> p2;                //弧尾和弧头结点序号
        s = new ArcNode;                
        s->adjvex = p2;                    //记录弧尾指向结点的序号
        s->next = adjlist[p1].firstedge;//插入关联弧
        adjlist[p1].firstedge = s;
    }
    for (int i = 0; i < MAXSIZE; i++)
        visited[i] = 0;
}

template<class T>
ALGraph<T>::~ALGraph()
{
    ArcNode *p, *s;
    for (int i = 0; i < vertexNum; i++)
    {
        s = adjlist[i].firstedge;
        while (NULL != s) {
            p = s;
            s = s->next;
            delete p;
        }
    }
    arcNum = vertexNum = 0;
}

template<class T>
T ALGraph<T>::GetVex(int i)
{
    if (i < 0 || i >= vertexNum)
    {
        throw"顶点不存在";
    }
    else
    {
        return adjlist[i].vertex;        //返回第i个顶点的数据信息
    }
}

template<class T>
void ALGraph<T>::PutVex(int i, T value)
{
    if (i < 0 || i >= vertexNum)
    {
        cout << "结点不存在" << endl;
        return;
    }
    else
    {
        adjlist[i].vertex = value;        //替换第i个顶点的数据信息
    }
}

template<class T>
void ALGraph<T>::InsertVex(T value)
{
    int flag = 0;
    for (int i = 0; i < vertexNum; i++)
    {
        if (adjlist[i].vertex == value)
        {
            cout << "结点已存在" << endl;
            flag = 1;
            return;
        }
    }
    if (!flag)                            //不在图中，则新增结点
    {
        adjlist[vertexNum].fisrtedge = NULL;
        adjlist[vertexNum++].vertex = value;
    }
}

template<class T>
void ALGraph<T>::DeleteVex(int i)
{
    if (i < 0 || i >= vertexNum)
    {
        cout << "结点不存在" << endl;
        return;
    }

    ArcNode *s, *d;
    s = adjlist[i].firstedge;
    while (s != NULL) {
        d = s;
        s = s->next;
        delete d;
        arcNum--;
    }
                                        //横移
    if (i != vertexNum - 1)
    {
        for (int j = i + 1; j < vertexNum; j++)
        {
            adjlist[j - 1].vertex = adjlist[j].vertex;
            adjlist[j - 1].firstedge = adjlist[j].firstedge;
        }
    }
    vertexNum--;
}

template<class T>
void ALGraph<T>::InsertArc(int i, int j)
{
    if (i < 0 || i >= vertexNum)
    {
        cout << "结点不存在" << endl;
        return;
    }
    ArcNode *s, *p;
    s = adjlist[i].firstedge;
    p = adjlist[i].firstedge;
    if (NULL == s) {
        p = new ArcNode;
        p->adjvex = j;
        p->next = NULL;
        arcNum++;
        return;
    }
    while (NULL != s) {
        if (j == s->adjvex) {
            cout << "弧已存在" << endl;
            return;
        }
        p = s;                        //最后一弧
        s = s->next;
    }
    s = new ArcNode;                //动态分配内存
    p->next = s;
    s->adjvex = j;
    s->next = NULL;
    arcNum++;
}

template<class T>
void ALGraph<T>::DeleteArc(int i, int j)
{
    if (i < 0 || i >= vertexNum && j < 0 || j >= vertexNum)
    {
        cout << "顶点不存在" << endl;
        return;
    }

    int flag = 0;
    ArcNode *s, *r;
    s = adjlist[i].firstedge;
    r = adjlist[i].firstedge;
    while (s != NULL)
    {
        if (s->adjvex == j) {
            flag = 1;
            if (s == r) {
                if (NULL == s->next) {
                    delete s;
                    adjlist[i].firstedge = NULL;
                    arcNum--;
                    return;
                }
                else
                {
                    adjlist[i].firstedge = r->next;
                    delete s;
                    arcNum--;
                    return;
                }
            }
            else
            {
                if (NULL == s->next) {
                    delete s;
                    r->next = NULL;
                    arcNum--;
                    return;
                }
                else {
                    r->next = s->next;
                    delete s;
                    arcNum--;
                    return;
                }
            }
        }
        r = s;
        s = s->next;
    }
    if (!flag) {
        cout << "弧不存在" << endl;
    }
}

template<class T>
void ALGraph<T>::DFSTraverse(int v)
{
    cout << adjlist[v].vertex << '	';
    visited[v] = 1;
    ArcNode *p = adjlist[v].firstedge;
    while (p) {
        int j = p->adjvex;
        if (0 == visited[j]) {
            DFSTraverse(j);
        }
        p = p->next;
    }
}

template<class T>
void ALGraph<T>::BFSTraverse(int v)
{
    int visited[MAXSIZE];
    for (int i = 0; i < vertexNum; i++)
        visited[i] = 0;

    int temp, j;
    ArcNode *p;
    queue<int> Qu;
    cout << adjlist[v].vertex << '	';
    visited[v] = 1;
    Qu.push(v);
    while (!Qu.empty()) {
        temp = Qu.front();
        Qu.pop();

        p = adjlist[temp].firstedge;
        while (NULL != p) {
            j = p->adjvex;
            if (!visited[j]) {
                cout << adjlist[p->adjvex].vertex << '	';
                Qu.push(j);
            }
            p = p->next;
        }
    }
}

template<class T>
void ALGraph<T>::CalAllNodeIns()
{
    int count;
    ArcNode *s;
    for (int i = 0; i < vertexNum; i++)
    {
        count = 0;
        for (int j = 0; j < vertexNum; j++)
        {
            s = adjlist[j].firstedge;
            while (NULL != s) {
                if (s->adjvex == i)    //统计入度
                {
                    count++;
                    break;
                }
                s = s->next;
            }
        }
        adjlist[i].in = count;
    }

}

template<class T>
void ALGraph<T>::TopSort()
{
    CalAllNodeIns();

    int k, h, count = 0;
    ArcNode *p;
    stack<int> Stk;
    for (int i = 0; i < vertexNum; i++)
        if (!adjlist[i].in)
            Stk.push(i);            //将入度为0的结点入栈
    while (!Stk.empty())
    {
        k = Stk.top();
        Stk.pop();
        cout << adjlist[k].vertex << '	';
        count++;
        p = adjlist[k].firstedge;    //入度为零的结点的邻接点中
        while (NULL != p) {
            h = p->adjvex;
            if (!(--adjlist[h].in))    //入度为1的结点入栈
                Stk.push(h);
            p = p->next;
        }
    }
    if (count < vertexNum)
        cout << "+ 图中有回路";
}