邻接表图+遍历+拓扑排序

　　Visit为全局变量，也可以不使用全局，但是必须是 通过引用（&）传递
　　由于不止一次的遍历，所以每一次遍历时都将全局变量还原为 false 
　　bool Visit[max] = { false };  

// 最大存储data[] 数组数据的最大值
const int max = 20;
// 数组链接的链表尾巴结点
struct TNode {
    int index;
    TNode * next;
};
// 数组头结点
struct ArrayHNode {    
    char ch;
    TNode * Anext;
};
// 邻接表图 adjacency list graph
class AGraph {
public:
    AGraph();
    ~AGraph();
    int In_degree(char);        // 某结点的入度
    int Out_degree(char);        // 某结点的出度
    int getIndex(char);            // 某结点所在 data 数组的下标
    void ResetArray(int);        // 重新设置数组（将数组从 index 位置前移）
    bool InsertVex(char);        // 插入一个结点
    bool InsertArc(char, char);    // 插入一条边
    bool DeleteVex(char);        // 删除一个结点
    bool DeleteArc(char, char);    // 删除一条边
    void DFS();                    // 深度优先遍历        注：遍历过程似构建以广度优先树的森林
    void DFS_visit(int);        // 对某个结点深度遍历
    void BFS(char);                // 广度优先遍历        注：遍历过程似构建一颗广度优先树   （故此不需要 BFS_visit()辅助函数）
    void Show_everyArray();        // 输出有效数组元素的所有结点
    bool Topological_order();    // 拓扑排序
private:
    ArrayHNode data[max];
    int Size;                    // 有效数据个数
};

bool AGraph::Topological_order() {
/*
拓扑排序----维基百科
    在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序（英语：Topological sorting）。
    每个顶点出现且只出现一次；
    若A在序列中排在B的前面，则在图中不存在从B到A的路径。
    也可以定义为：拓扑排序是对有向无环图的顶点的一种排序，它使得如果存在一条从顶点A到顶点B的路径，那么在排序中B出现在A的后面。
以上是维基百科上的 解释。 通俗的说是： (注意：上面已经说到的是有向无环的图)
    1.有向图中选一个没有前驱的结点（即入度为0）的顶点并输出
    2.从图中删除该顶点和所有以它为尾的弧（即删除每一个数组中以该顶点作为终点形成的边） 注：删除一个弧时，对应的 degree-1，因为少了一个出度
*/
    int top = -1;
    int Stack[max];        // 使用栈来保存 入度为 0 的数据下标（可以知道对应结点）
    int degree[max] = { 0 };    // 初始化每一个入度为 0
    for (int i = 0; i < Size; ++i) {
        // 保存每一个结点的 入度值至 degree[]中
        degree[i] = In_degree(data[i].ch);    // degree存放的是 每一个对于下标数据结点入度
        if(degree[i] == 0) {
            // 如果入度是 0 的就将其入栈
            Stack[++top] = degree[i];        // Stack 存放的是 每个入度为 0的结点
        }
    }
    int count = 0;        // 计数： 记住操作或输出了几个结点
    int Findex, Lindex;    // Fist_index 是data[]数组的下标  List_index 是data[]数组中 下标为Findex 链接的结点下标
    while(top != -1) {    // 栈空时退出
        Findex = Stack[top--];    // 退栈，退出一个元素用于操作输出
        cout << data[Findex].ch << " ";
        count++;                // 输出一个结点，即操作了一个结点， count++
        for (TNode * TN = data[Findex].Anext; TN != NULL; TN = TN->next) {
            // 根据拓扑排序原理，输出了一个结点，就要将其对应相关联的结点入度 - 1
            Lindex = TN->index;
            degree[Lindex]--;        // ‘删除’一个结点，将相关联的下标为Lindex的结点入度 - 1
            if (degree[Lindex] == 0) {    // 如果由于 入度减一为 0了， 根据拓扑规则，将其入队
                Stack[++top] = Lindex;
            }
        }
    }
    if(count < Size) {
        cout << "    图中存在回路！ 非拓扑序列";
        return false;
    } else {
        cout << "    该图为一个拓扑序列！";
        return true;
    }
}

void AGraph::DFS() {
    // 默认从第一个结点 data[0]进行深度优先遍历
    for (int index = 0; index < Size; ++index) {
        if(Visit[index] == false) {
            // 对没有被访问过的元素访问之
            DFS_visit(index);
        }
    }
    cout << endl;
    //    对改变Visit 进行还原 全为false
    for (int i = 0; i < Size; ++i) {
        Visit[i] = false;
    }
}
void AGraph::DFS_visit(int i) {
    // 执行该函数表示当前 下标为 i的数组元素没有被访问过
    Visit[i] = true;        // 标志该元素被访问,下面输出该元素
    cout << data[i].ch << " ";
    TNode * TN = data[i].Anext;
    while(TN != NULL) {
        // 对当前数组元素链接的链表进行索引
        if (Visit[TN->index] == false)    // 对没有访问过的（false） 进行递归访问
            DFS_visit(TN->index);
        TN = TN->next;
    }
}

void AGraph::BFS(char ch) {
    int Queue[max];                // 使用队列操作
    TNode * TN = NULL;
    int front = -1;
    int rear = -1;
    int index;
    Queue[++rear] = getIndex(ch);    // 找到对应数组位置
    while(front != rear) {
        index = Queue[++front];
        // 取出队头元素操作它链接的结点数据
        cout << data[index].ch << " ";
        TN = data[index].Anext;
        while(TN != NULL) {
            if(Visit[TN->index] == false) {
                Visit[TN->index] = true;
                Queue[++rear] = TN->index;
            }
            TN = TN->next;
        }
    }
    cout << endl;
    //    对改变Visit 进行还原 全为false
    for (int i = 0; i < Size; ++i) {
        Visit[i] = false;
    }
}

#include <iostream>
using namespace std;
// 最大存储data[] 数组数据的最大值
const int max = 20;
// 数组链接的链表尾巴结点
struct TNode {
    int index;
    TNode * next;
};
// 数组头结点
struct ArrayHNode {    
    char ch;
    TNode * Anext;
};
// 邻接表图 adjacency list graph
class AGraph {
public:
    AGraph();
    ~AGraph();
    int In_degree(char);        // 某结点的入度
    int Out_degree(char);        // 某结点的出度
    int getIndex(char);            // 某结点所在 data 数组的下标
    void ResetArray(int);        // 重新设置数组（将数组从 index 位置前移）
    bool InsertVex(char);        // 插入一个结点
    bool InsertArc(char, char);    // 插入一条边
    bool DeleteVex(char);        // 删除一个结点
    bool DeleteArc(char, char);    // 删除一条边
    void DFS();                    // 深度优先遍历        注：遍历过程似构建以广度优先树的森林
    void DFS_visit(int);        // 对某个结点深度遍历
    void BFS(char);                // 广度优先遍历        注：遍历过程似构建一颗广度优先树   （故此不需要 BFS_visit()辅助函数）
    void Show_everyArray();        // 输出有效数组元素的所有结点
    bool Topological_order();    // 拓扑排序
private:
    ArrayHNode data[max];
    int Size;                    // 有效数据个数
};

bool Visit[max] = { false };    // 作为访问标识符，默认全为 false

int main() {

    void launch();
    launch();

    system("pause");
    return 0;
}

void launch() {
    cout << "最大存放数据个数" << max << endl;
    AGraph AG;
    int Times = 3;
    int Order;
    char flag = 'N';
    char ch;
    char ch1, ch2;
    while (Times > 0) {
        cout << "┏=============================================================┓" << endl;
        cout << "｜ 入度 1， 插结点 3， 插边 4, DFS遍历 7, 输出邻接表图 9       ｜" << endl;
        cout << "｜ 出度 2， 删结点 5,  删边 6, BFS遍历 8, 输出拓扑排序 10      ｜" << endl;
        cout << "┗=============================================================┛" << endl;
        cout << endl << "剩余Times= " << Times << "次操作--输入对应数字操作：";
        cin >> Order;
        switch (Order) {
        case 1:    cout << "请输入求入度的字符："; cin >> ch;
            cout <<"￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣"<<endl << AG.In_degree(ch);
            break;
        case 2:    cout << "请输入求出度的字符："; cin >> ch;
            cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl << AG.Out_degree(ch);
            break;
        case 3:    cout << "请输入插入结点字符："; cin >> ch;
            cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl << AG.InsertVex(ch);
            break;
        case 4:    cout << "请输入要插入边的起点结点和终点字符(连续输入)："; cin >> ch1 >> ch2;
            cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl << AG.InsertArc(ch1, ch2);
            break;
        case 5:    cout << "请输入删除结点字符："; cin >> ch;
            cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl << AG.DeleteVex(ch);
            break;
        case 6: cout << "请输入要删除边的起点结点和终点字符(连续输入)："; cin >> ch1 >> ch2;
            cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl << AG.DeleteArc(ch1, ch2);
            break;
        case 7:    cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl ;
            AG.DFS();
            break;
        case 8:    cout << "请输入 BFS 遍历的起始结点字符：";    cin >> ch;
            cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl ;
            AG.BFS(ch);
            break;
        case 9:    cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl;
            AG.Show_everyArray();
            break;
        case 10: cout << "￣￣￣￣￣￣￣￣￣￣￣￣￣￣￣" << endl;
            AG.Topological_order();
            break;
        }
        cout << endl << "＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿" << endl;
        Times--;
        cout << endl;
        if(Times == 0) {
            cout << "Times为 0退出，请输入是否追加 Times值（N 否， Y 是）：";
            cin >> flag;
            if (flag == 'y' || flag == 'Y')
                Times = 3;
        }
    }
}

bool AGraph::Topological_order() {
/*
拓扑排序----维基百科
    在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序（英语：Topological sorting）。
    每个顶点出现且只出现一次；
    若A在序列中排在B的前面，则在图中不存在从B到A的路径。
    也可以定义为：拓扑排序是对有向无环图的顶点的一种排序，它使得如果存在一条从顶点A到顶点B的路径，那么在排序中B出现在A的后面。
以上是维基百科上的 解释。 通俗的说是： (注意：上面已经说到的是有向无环的图)
    1.有向图中选一个没有前驱的结点（即入度为0）的顶点并输出
    2.从图中删除该顶点和所有以它为尾的弧（即删除每一个数组中以该顶点作为终点形成的边） 注：删除一个弧时，对应的 degree-1，因为少了一个出度
*/
    int top = -1;
    int Stack[max];        // 使用栈来保存 入度为 0 的数据下标（可以知道对应结点）
    int degree[max] = { 0 };    // 初始化每一个入度为 0
    for (int i = 0; i < Size; ++i) {
        // 保存每一个结点的 入度值至 degree[]中
        degree[i] = In_degree(data[i].ch);    // degree存放的是 每一个对于下标数据结点入度
        if(degree[i] == 0) {
            // 如果入度是 0 的就将其入栈
            Stack[++top] = degree[i];        // Stack 存放的是 每个入度为 0的结点
        }
    }
    int count = 0;        // 计数： 记住操作或输出了几个结点
    int Findex, Lindex;    // Fist_index 是data[]数组的下标  List_index 是data[]数组中 下标为Findex 链接的结点下标
    while(top != -1) {    // 栈空时退出
        Findex = Stack[top--];    // 退栈，退出一个元素用于操作输出
        cout << data[Findex].ch << " ";
        count++;                // 输出一个结点，即操作了一个结点， count++
        for (TNode * TN = data[Findex].Anext; TN != NULL; TN = TN->next) {
            // 根据拓扑排序原理，输出了一个结点，就要将其对应相关联的结点入度 - 1
            Lindex = TN->index;
            degree[Lindex]--;        // ‘删除’一个结点，将相关联的下标为Lindex的结点入度 - 1
            if (degree[Lindex] == 0) {    // 如果由于 入度减一为 0了， 根据拓扑规则，将其入队
                Stack[++top] = Lindex;
            }
        }
    }
    if(count < Size) {
        cout << "    图中存在回路！ 非拓扑序列";
        return false;
    } else {
        cout << "    该图为一个拓扑序列！";
        return true;
    }
}

void AGraph::BFS(char ch) {
    int Queue[max];                // 使用队列操作
    TNode * TN = NULL;
    int front = -1;
    int rear = -1;
    int index;
    Queue[++rear] = getIndex(ch);    // 找到对应数组位置
    while(front != rear) {
        index = Queue[++front];
        // 取出队头元素操作它链接的结点数据
        cout << data[index].ch << " ";
        TN = data[index].Anext;
        while(TN != NULL) {
            if(Visit[TN->index] == false) {
                Visit[TN->index] = true;
                Queue[++rear] = TN->index;
            }
            TN = TN->next;
        }
    }
    cout << endl;
    //    对改变Visit 进行还原 全为false
    for (int i = 0; i < Size; ++i) {
        Visit[i] = false;
    }
}

void AGraph::DFS() {
    // 默认从第一个结点 data[0]进行深度优先遍历
    for (int index = 0; index < Size; ++index) {
        if(Visit[index] == false) {
            // 对没有被访问过的元素访问之
            DFS_visit(index);
        }
    }
    cout << endl;
    //    对改变Visit 进行还原 全为false
    for (int i = 0; i < Size; ++i) {
        Visit[i] = false;
    }
}

void AGraph::DFS_visit(int i) {
    // 执行该函数表示当前 下标为 i的数组元素没有被访问过
    Visit[i] = true;        // 标志该元素被访问,下面输出该元素
    cout << data[i].ch << " ";
    TNode * TN = data[i].Anext;
    while(TN != NULL) {
        // 对当前数组元素链接的链表进行索引
        if (Visit[TN->index] == false)    // 对没有访问过的（false） 进行递归访问
            DFS_visit(TN->index);
        TN = TN->next;
    }
}

void AGraph::Show_everyArray() {
    int index;
    TNode * TN = NULL;
    for (int i = 0; i < Size; ++i) {
        cout << data[i].ch << " -> ";
        TN = data[i].Anext;
        while(TN != NULL) {
            cout << data[TN->index].ch << " ";
            TN = TN->next;
        }
        cout << endl;
    }
}

int AGraph::Out_degree(char ch) {
    TNode * TN = NULL;
    int i = getIndex(ch);
    int number = 0;
    if(i != -1) {
        // 求的结点合法
        TN = data[i].Anext;
        while(TN != NULL) {
            number++;
            TN = TN->next;
        }
    }
    return number;
}

int AGraph::In_degree(char ch) {
    // 入队就是要遍历 n-1个数组下标所链接的结点，来确定有哪些与之构成边
    int index = getIndex(ch);
    int number = 0;
    TNode * TN = NULL;
    for (int i = 0; i < Size; ++i) {
        // 可能存在环 即 A->A，所以遍历全部数组
        TN = data[i].Anext;
        while(TN != NULL) {
            if (TN->index == index)        // 下标相等表示数据相同，记录
                number++;
            TN = TN->next;
        }
    }
    return number;
}

void AGraph::ResetArray(int index) {
    // 类似普通数组一样，将后面的数据覆盖掉前面的数据,链表保存的下标就会发生变化，从 index开始
    TNode * TN = NULL;
    for (int i = index; i < Size-1; ++i) {
        data[i].ch = data[i + 1].ch;    // 元素前移
        data[i].Anext = data[i + 1].Anext;    // 对于的链表也要插入过去
        // 由于数组的 Size 发生变化了，那么就必须作出调整
        TN = data[i].Anext;
        while(TN != NULL) {
            // 对 凡是保存的下标大于等于 index的都必须减一，因为数组从index-1处下降了一个高度，原来下标保存为 F=10的，可能降到了 F=9
            if(TN->index >= index) {
                TN->index = TN->index - 1;
            }
            TN = TN->next;
        }
    }
    data[Size - 1].Anext = NULL;
    // 将data[Size-1]指向那个链表断开，由于 data[Size-1]后面的链表 已经链接到了 data[Size-2]的后面了，所以不用担心该链表不会被析构，此语句可以不写，只是安全起见
    Size--;            // 每一次重置数组就是删除了一个结点才需要重置，所以 Size-1
}

bool AGraph::DeleteVex(char ch) {
    // 删除一个结点的时候，就是将数组的元素重新排一下，并且把与结点相关联的边删除
    int i = getIndex(ch);
    if(i != -1) {
        // 存在要删除的结点数据，要删除的结点合法
        for (int j = 0; j < Size; ++j) {
        // 对待删结点在数组中作为终点构成的边 全部删除，这儿不需要待删除结点所在的下标数据
            if (j != i)    
                DeleteArc(data[j].ch, ch);
        }// 将关联的边删除了，开始删除该结点
        TNode * p = data[i].Anext;
        TNode * tem;
        while(p    != NULL) {
            // 删除该结点的出度，即作为起点关联的边
            tem = p;
            p = p->next;
            delete tem;
        }
        data[i].Anext = NULL;    // 对于要删除的结点，它的 指针域应当置为 NULL
        ResetArray(i);    // Size 在该函数里面再减 1，删除一个结点，空出一个位置，让后面的数据前移，补位
    }
    return true;
}

bool AGraph::DeleteArc(char ch1, char ch2) {
    // 删除边时，应注意删除的结点是 数组的第一个结点和不是第一个结点是不同的代码
    int i = getIndex(ch1);
    int j = getIndex(ch2);
    if(i != -1 && j != -1) {
        // 存在该两个结点，接下来判断有两结点构成的边就删除    
        TNode * TN = data[i].Anext;
        TNode * pre = NULL;        // 作为索引前驱
        TNode * tem = NULL;        // 指向要删除的结点 对其删除操作
        while (TN != NULL) {
            // 索引两结点构成的边
            if(TN->index == j && pre == NULL) {
                // 存在索引的边 并且 为数组链接的 第一个结点
                tem = TN;
                data[i].Anext = tem->next;
                delete tem;
                return true;
            } else if(TN->index == j && pre != NULL) {
                // 存在索引的边 并且 不是数组链接的 第一个结点
                tem = TN;
                pre->next = tem->next;
                delete tem;
                return true;
            }
            pre = TN;            // 保存当前指向的结点
            TN = TN->next;        // 转入下一个结点， 而 pre 则成了上一次访问的结点
        }
    }
    return false;
}

bool AGraph::InsertVex(char ch) {
    // 插入结点数据就是 将数据插入 数组中
    if(Size == max) {
        return false;
    } else {
        // 还有位置可以插入数据，直接录入数据不初始化相关边
        data[Size].ch = ch;
        data[Size].Anext = NULL;
        Size++;
        return true;
    }
}

bool AGraph::InsertArc(char ch1, char ch2) {
    // 插入边就是 在 起点结点对于的数组下标哪儿 插入一个结点到其后面去
    int i = getIndex(ch1);
    int j = getIndex(ch2);
    TNode * p = NULL;
    if(i != -1 && j != -1) {
        // 当两个结点构成的边合法，通过头插法插入 data[]中
        p = data[i].Anext;
        while(p != NULL) {
            // 索引一下，要构成的边是不是已经存在了，存在的话就不插入
            if (p->index == j)
                return false;
            p = p->next;
        }
        TNode * TN = new TNode();
        TN->index = j;
        TN->next = data[i].Anext;
        data[i].Anext = TN;
        return true;
    } else {
        return false;
    }
}

int AGraph::getIndex(char ch) {
    for (int i = 0; i < Size; ++i) {
        if (ch == data[i].ch)
            return i;
    }
    return -1;
}

AGraph::AGraph() {
    // 初始化数组的结点
    char ch1;
    cout << "请输入结点数据(#作为结束符)：";
    cin >> ch1;
    int i = 0;
    while(ch1 != '#') {
        data[i].ch = ch1;
        data[i].Anext = NULL;
        i++;
        cin >> ch1;
    }
    Size = i;        // 保存实际数据个数，非最大元素的下标
    // 初始化边，也就是数组链接的链表数据
    cout << "以出度构建邻接表图:" << endl;
    char ch2;
    bool flag = true;
    while(flag) {
        cout << "初始化边，请输入一条边的起点（#表终止）：";
        cin >> ch1;
        cout << "初始化边，请输入一条边的终点（#表终止）：";
        cin >> ch2;
        if(ch1 != '#' || ch2 != '#') {
            InsertArc(ch1, ch2);
        } else {
            flag = false;
        }
    }
}

AGraph::~AGraph() {
    TNode * TN = NULL;
    TNode * tem = NULL;
    for (int i = 0; i < Size; ++i) {
        TN = data[i].Anext;
        cout << "析构数组下标为"<<i<<"元素为"<<data[i].ch<<"的尾链表结点:";
        while(TN != NULL) {
            tem = TN;
    //        TN = TN->next;
            cout << TN->index << " ";
            TN = TN->next;
            delete tem;
        }
        cout << endl;
    }
    Size = 0;
}