列出连通集的邻接表解题

也许有许多人像我一样，一开始用邻接表做这题，结果发现深搜的顺序是错的导致这题出不来。很多人于是放弃了邻接表，利用邻接矩阵，显然方便很多。但我不信这个邪，咱就一起死磕这题！

先来看看为什么会错。其实你发现深搜是没有问题的，本来深搜就不是唯一的，所以我们的深搜和答案仅仅是顺序不一样而已。

那么答案的顺序是怎样的呢？题目中有“假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点”，显然是按序号从大到小访问顶点。

由于我们是临界表，各个顶点的连接关系可以看作是单链表来实现的，这就要求我们每个顶点后的单链表是递增排序。然鹅我们建立单链表的时候是读到两个顶点，利用前插法在这两个顶点后分别接上另一个顶点。显然输入不是按照递增顺序，这就导致我们为每个顶点建立的单链表不是递增，从而不能满足“按编号递增的顺序访问邻接点”。

好啦，明白问题后，我们想想解决方法。

既然是要死磕邻接表，那么这个存储结构就不变了。想要邻接表做到“按编号递增的顺序访问邻接点”，想来也不难，就是让每个顶点后的单链表按递增顺序排列。

最后一步，让单链表递增排列，那么就只有两种方法了：

1. 待单链表建立完后，对整个单链表进行排序

2. 在生成单链表的时候，按递增顺序确定插入结点位置后再插入

 两种方法都行的，只是多写一个接口的问题。为了避免建立完链表后再对它进行一次循环，我选择了第二种方法。

代码

这是一开始的代码。我们只需注意深搜的接口即可，其余的作为解这题的参考。

#include <iostream>
#include <queue>

using namespace std;

//采用邻接表，一下为定义
typedef struct ArcNode {
    int adjvex;
    struct ArcNode *nextarc;
}ArcNode;
typedef struct VexNode {
    int data;
    struct ArcNode *firstarc;
}VexNode,AdjList[10];
typedef struct {
    AdjList vertices;
    int vexnum, arcnum;
}ALGraph;

//函数声明
void Create(ALGraph &G);
void DFS(ALGraph G, int v);
void BFS(ALGraph G, int v);

bool visited_DFS[10] = { false };
bool visited_BFS[10] = { false };

int main() {
    ALGraph graph;
    Create(graph);
    //输出深搜
    for (int i = 0; i < graph.vexnum; i++) {
        if (visited_DFS[i] == false) {
            cout << "{ ";
            DFS(graph, i);
            cout << "}" << endl;
        }
    }
    //输出广搜
    for (int i = 0; i < graph.vexnum; i++) {
        if (visited_BFS[i] == false) {
            cout << "{ ";
            BFS(graph, i);
            cout << "}" << endl;
        }
    }
    return 0;
}

//创建邻接表
void Create(ALGraph &G) {
    int v1, v2;
    ArcNode *p1, *p2;
    cin >> G.vexnum >> G.arcnum;
    for (int i = 0; i < G.vexnum; i++) {
        G.vertices[i].data = i;
        G.vertices[i].firstarc = NULL;    //初始化为空，避免野指针
    }
    //两点确定一边，前插法
    for (int i = 0; i < G.arcnum; i++) {
        p1 = new ArcNode;
        p2 = new ArcNode;
        cin >> v1 >> v2;
        p1->adjvex = v2;
        p2->adjvex = v1;
        p1->nextarc = G.vertices[v1].firstarc;
        G.vertices[v1].firstarc = p1;
        p2->nextarc = G.vertices[v2].firstarc;
        G.vertices[v2].firstarc = p2;
    }
    //cout << "创建" << endl;
}

//深搜
void DFS(ALGraph G, int v) {
    ArcNode *p = new ArcNode;
    int w = 0;
    cout << G.vertices[v].data << " ";
    visited_DFS[v] = true;
    p = G.vertices[v].firstarc;
    while (p != NULL) {
        w = p->adjvex;
        if (visited_DFS[w] == false) {
            DFS(G, w);
        }
        p = p->nextarc;
    }
}

//广搜,引入队列作为辅助
void BFS(ALGraph G, int v) {
    queue<int> q;
    ArcNode *p = new ArcNode;
    int w = 0;
    cout << G.vertices[v].data << " ";
    visited_BFS[v] = true;
    q.push(v);
    while (!q.empty()) {
        v = q.front();
        q.pop();
        p = G.vertices[v].firstarc;
        while (p!=NULL) {
            w = p->adjvex;
            if (visited_BFS[w] == false) {
                cout << G.vertices[w].data << " ";
                visited_BFS[w] = true;
                q.push(w);
            }
            p = p->nextarc;
        }
    }
}

既然决定了要在插入的时候保持链表的升序，就写出以下接口

ArcNode* Insert(ArcNode *firstarc, ArcNode *p) {
    ArcNode *p1, *p2 = NULL;
    if (firstarc == NULL) {        //原链表为空
        firstarc = p;    
        p->nextarc = NULL;
        return firstarc;
    }
    p1 = firstarc;
    //定位到要插入的位置
    while ((p->adjvex > p1->adjvex) && p1->nextarc != NULL) {    
        p2 = p1;    //p2记住p1
        p1 = p1->nextarc;    //p1指向后一个结点
    }
    if (p->adjvex < p1->adjvex) {    //插在p1前
        p->nextarc = p1;
        if (firstarc == p1) {        //插在表头
            firstarc = p;
        }
        else {        //插在表中
            p2->nextarc = p;
        }
    }
    else {        //插在表尾
        p1->nextarc = p;
        p->nextarc = NULL;
    }
    return firstarc;
}

最后，在建立链表的部分进行调整，注意这个部分前后的区别 

//创建邻接表
void Create(ALGraph &G) {
    int v1, v2;
    ArcNode *p1, *p2;
    cin >> G.vexnum >> G.arcnum;
    for (int i = 0; i < G.vexnum; i++) {
        G.vertices[i].data = i;
        G.vertices[i].firstarc = NULL;    //初始化为空，避免野指针
    }
    //两点确定一边，前插法
    for (int i = 0; i < G.arcnum; i++) {
        p1 = new ArcNode;
        p2 = new ArcNode;
        cin >> v1 >> v2;
        p1->adjvex = v2;
        p2->adjvex = v1;
        p1->nextarc = G.vertices[v1].firstarc;
        G.vertices[v1].firstarc = Insert(G.vertices[v1].firstarc, p1);    //原为G.vertices[v1].firstarc = p1;
        p2->nextarc = G.vertices[v2].firstarc;
        G.vertices[v2].firstarc = Insert(G.vertices[v2].firstarc, p2);    //原为G.vertices[v2].firstarc = p2;
    }
    //cout << "创建" << endl;
}