c语言编写程序，构造无向图的邻接矩阵基于邻接矩阵存储的DBFS遍历算法，用户输入图的顶点数和边数，顶点序列，图中边的顶点对序列，遍历的起始顶点：，完整代码，算法思想

好的，以下是C语言编写的程序，可构造无向图的邻接矩阵，并基于邻接矩阵存储的DBFS遍历算法进行遍历。程序代码如下：

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 100   // 最多顶点数
#define MAX_EDGE_NUM 100     // 最多边数

// 定义顶点结构体
typedef struct {
    int data;               // 顶点数据
} VertexType;

// 定义邻接矩阵存储结构体
typedef struct {
    int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];   // 邻接矩阵
    int n, e;               // 顶点数和边数
    VertexType vexs[MAX_VERTEX_NUM];             // 存储顶点信息
} MGraph;

// 初始化无向图
void CreateMGraph(MGraph *G) {
    int i, j, w;            // i,j为顶点下标，w为权值
    printf("请输入顶点数和边数：");
    scanf("%d%d", &(G->n), &(G->e));   // 读入顶点数和边数
    printf("请输入%d个顶点的数据：\n", G->n);
    for (i = 0; i < G->n; i++) {
        scanf("%d", &(G->vexs[i].data)); // 读入顶点信息
    }
    for (i = 0; i < G->n; i++) {
        for (j = 0; j < G->n; j++) {
            G->edges[i][j] = 0; // 初始化邻接矩阵
        }
    }
    printf("请输入%d条边的顶点序号和权值：\n", G->e);
    for (i = 0; i < G->e; i++) {
        int v1, v2;
        scanf("%d%d%d", &v1, &v2, &w);   // 读入边的顶点序号和权值
        G->edges[v1][v2] = w;
        G->edges[v2][v1] = w;   // 无向图的邻接矩阵是对称矩阵
    }
}

// 遍历顶点v的邻接点
void Visit(int v) {
    printf("%d ", v);
}

// 深度优先搜索
void DFS(MGraph G, int v, int visited[]) {
    int i;
    visited[v] = 1;         // 标记顶点v为已访问
    Visit(v);               // 访问顶点v
    for (i = 0; i < G.n; i++) {
        if (G.edges[v][i] && !visited[i]) {  // 如果v与i有边且i未访问
            DFS(G, i, visited);     // 递归访问i
        }
    }
}

// 基于邻接矩阵的深度优先遍历
void DFSTraverse(MGraph G) {
    int i;
    int visited[MAX_VERTEX_NUM];    // 记录顶点是否已访问
    for (i = 0; i < G.n; i++) {
        visited[i] = 0;             // 初始化所有顶点为未访问
    }
    for (i = 0; i < G.n; i++) {
        if (!visited[i]) {          // 如果顶点i未访问
            DFS(G, i, visited);     // 从顶点i开始深度优先遍历
        }
    }
}

// 基于邻接矩阵的广度优先遍历
void BFSTraverse(MGraph G, int v) {
    int i, j;
    int visited[MAX_VERTEX_NUM];    // 记录顶点是否已访问
    int queue[MAX_VERTEX_NUM];      // 用数组模拟队列
    int front = 0, rear = 0;        // 队列的头和尾指针
    for (i = 0; i < G.n; i++) {
        visited[i] = 0;             // 初始化所有顶点为未访问
    }
    Visit(v);                       // 访问顶点v
    visited[v] = 1;                 // 标记顶点v为已访问
    queue[rear++] = v;              // 入队顶点v
    while (front < rear) {          // 队列不为空
        int k = queue[front++];     // 出队一个顶点
        for (j = 0; j < G.n; j++) {
            if (G.edges[k][j] && !visited[j]) {   // 如果k与j有边且j未访问
                Visit(j);           // 访问顶点j
                visited[j] = 1;     // 标记顶点j为已访问
                queue[rear++] = j;  // 入队顶点j
            }
        }
    }
}

int main() {
    MGraph G;
    CreateMGraph(&G);
    printf("邻接矩阵为：\n");
    int i, j;
    for (i = 0; i < G.n; i++) {
        for (j = 0; j < G.n; j++) {
            printf("%d ", G.edges[i][j]);
        }
        printf("\n");
    }
    printf("深度优先遍历结果为：");
    DFSTraverse(G);
    printf("\n");
    printf("广度优先遍历结果为：");
    BFSTraverse(G, 0);
    printf("\n");
    return 0;
}

算法思想：

1. 根据用户输入的顶点数和边数，读入顶点信息和边的顶点序号和权值，构造出无向图的邻接矩阵存储结构体MGraph。

2. 基于邻接矩阵的深度优先遍历算法DFSTraverse，从每个未访问的顶点开始进行深度优先遍历，访问完所有与该顶点连通的顶点后，再返回该顶点的前一个未访问的邻接点，直到所有顶点都被访问完毕。

3. 基于邻接矩阵的广度优先遍历算法BFSTraverse，从指定的起始顶点开始，按照广度优先的顺序依次访问所有与该顶点相邻的未访问顶点，直到所有顶点都被访问完毕。在算法实现中，使用数组模拟队列，依次将每个已访问的顶点入队，出队时访问其邻接点，直到队列为空。