用邻接表建立的无向图，以及无向图的深度优先遍历和广度优先遍历

需求：

用邻接表的方式建立一个无向图，并且对图进行深度优先遍历和广度优先遍历

---

1.无向图的建立

需要两种节点： 头结点，表结点

2.深度优先遍历dfs
是一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。 当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。 这一过程一直进行到已发现从源节点可达的所有节点为止。

3.广度优先遍历bfs
宽度优先搜索，或横向优先搜索，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。
从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。一般的实现里，其邻居节点尚未被检验过的节点会被放置在一个被称为 open 的容器中（例如队列或是链表），而被检验过的节点则被放置在被称为 closed 的容器中。

包含表节点的头结点所组成的链表或者数组构成图Graph

先输入 顶点个数n 以及 边的个数 e
再通过 边为 的方式 输入 e 条边

---

具体实现如下：

#include 
#include 
#include 
#define maxn 100
#define len sizeof(edgeNode)
/*
const不是一个真真正正的常量，其代表的含义仅仅是只读。
使用const声明的对象是一个运行时对象，无法使用其作为
某个量的初值、数组的长度、case的值或在类型的情形中使用
不能用 const int maxn=100;
*/
//边节点
typedef struct node
{
    int value;
    struct node *next;
} edgeNode;

//头节点
typedef struct vnode
{
    edgeNode *FirstEdge;
} vertexNode;

//头节点的顺序表
typedef struct graph
{
    vertexNode vertex[maxn];
    int n, e;
} Graph;

Graph G;
//标记数组
int visited[maxn];

void insert(int i, int j)
{
    edgeNode *edgetmp;
    edgetmp = (edgeNode *)malloc(len);
    edgetmp->value = j;
    //前插
    edgetmp->next = G.vertex[i].FirstEdge;
    G.vertex[i].FirstEdge = edgetmp;
}

void Create()
{
    // vertexNode *vertmp;
    edgeNode *edgetmp;
    int i, j, n, e;
    scanf("%d%d", &n, &e); //输入n 个节点
    G.n = n;
    G.e = e;
    //初始化表头信息
    for (i = 0; i < n; i++)
    {
        G.vertex[i].FirstEdge = NULL;
    }

    //输入 无向边从 0 开始
    while (e--)
    {
        scanf("%d%d", &i, &j);
        if (i == 0 && j == 0)
            break;
        if (i >= n || j >= n)
            printf("有不存在的点，请重新输入\n");
        insert(i, j);
        insert(j, i);
    }
}

void dfs(Graph g, int i)
{
    edgeNode *p;
    if (visited[i] == 0)
    {
        visited[i] = 1;
        printf("顶点%d ", i);
    }
    p = g.vertex[i].FirstEdge->next;
    while (p != NULL)
    {
        if (!visited[p->value])
        {
            printf("顶点%d ", p->value);
            visited[p->value] = 1;
            //printf(" 访问%d", p->value);
            dfs(g, p->value);
        }
        p = p->next;
    }
}

void DFS(Graph g)
{
    int index;
    for (index = 0; index < G.n; ++index)
    {
        visited[index] = 0;
    }
    printf("开始进行深度优先搜索\n");
    for (index = 0; index < G.n; index++)
    {
        if (!visited[index])
            dfs(g, index);
    }
}

void bfs(Graph g, int i)
{
    int j;
    edgeNode *p;
    //用列队进行bfs
    int queue[maxn];
    // FIFO
    int front, rear;
    front = rear = 0;
    //证明被访问过
    visited[i] = 1;
    queue[rear++] = i; //将访问过的节点加入列队中
    printf("顶点%d ", i);
    while (rear > front)
    {
        j = queue[front++];
        p = G.vertex[j].FirstEdge;
        while (p)
        {
            if (visited[p->value] == 0)
            {
                printf("顶点%d ", p->value);
                queue[rear++] = p->value;
                visited[p->value] = 1;
            }
            p = p->next;
        }
    }
}

void BFS(Graph g)
{
    int index;
    for (index = 0; index < G.n; ++index)
    {
        visited[index] = 0;
    }
    printf("开始进行广度优先搜索\n");
    for (index = 0; index < G.n; index++)
    {
        if (!visited[index])
            bfs(g, index);
    }
}

//用来测试输入的图的形状，判断是否与输入的图的形状相同
void print()
{
    int index = 0;
    edgeNode *p;
    for (index = 0; index < G.n; index++)
    {
        printf("%d子节点是: ", index);
        p = G.vertex[index].FirstEdge;
        while (p)
        {
            printf(" %d ", p->value);
            p = p->next;
        }
        puts("");
    }
}

int main()
{
    Create();
    DFS(G);
    puts("");
    BFS(G);
    puts("");
    //print();
    return 0;
}
/*
测试用例：
1.
5 4
0 1
1 2
2 3
2 4
2.
7 7
0 2
0 1
1 6
3 6
1 5
2 3
2 4
*/