找出一条从某一顶点A到另一顶点B边数最少的一条路径 同c语言 写代码 用邻接矩阵的方式存储图 且使用广度优先搜素

好的，我可以为您解答这个问题。以下是C语言代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX_VERTEX_NUM 100 // 定义图中最大的顶点数

// 定义邻接矩阵存储图
typedef struct {
    int vertex[MAX_VERTEX_NUM]; // 顶点数组，存储每个顶点的值
    int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 邻接矩阵，存储每个顶点之间的边
    int vertexNum, edgeNum; // 顶点数和边数
} AdjMatrix;

// 定义队列，用于广度优先搜索
typedef struct {
    int *data;
    int front, rear;
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->data = (int*)malloc(sizeof(int) * MAX_VERTEX_NUM);
    q->front = q->rear = -1;
}

// 判断队列是否为空
bool isEmpty(Queue *q) {
    return q->front == q->rear;
}

// 入队
void enqueue(Queue *q, int x) {
    q->rear++;
    q->data[q->rear] = x;
}

// 出队
void dequeue(Queue *q) {
    q->front++;
}

// 获取队首元素
int getFront(Queue *q) {
    return q->data[q->front + 1];
}

// 判断图中是否存在边
bool hasEdge(AdjMatrix *G, int i, int j) {
    if (i < 0 || i >= G->vertexNum || j < 0 || j >= G->vertexNum) {
        return false;
    }
    return G->edges[i][j] != 0;
}

// 广度优先搜索
void BFS(AdjMatrix *G, int start, int end) {
    bool visited[MAX_VERTEX_NUM] = {false}; // 标记每个顶点是否被访问过
    Queue q;
    initQueue(&q);
    visited[start] = true;
    enqueue(&q, start);
    int path[MAX_VERTEX_NUM] = {-1}; // 记录每个顶点的前一个顶点
    while (!isEmpty(&q)) {
        int front = getFront(&q);
        dequeue(&q);
        for (int i = 0; i < G->vertexNum; i++) {
            if (hasEdge(G, front, i) && !visited[i]) {
                visited[i] = true;
                path[i] = front;
                enqueue(&q, i);
                if (i == end) {
                    int p = i;
                    printf("从顶点%d到顶点%d的最短路径为：", start, end);
                    while (p != -1) {
                        printf("%d ", p);
                        p = path[p];
                    }
                    printf("\n");
                    return;
                }
            }
        }
    }
    printf("从顶点%d到顶点%d不存在路径\n", start, end);
}

// 主函数
int main() {
    AdjMatrix G;
    int n, m;
    printf("请输入顶点数和边数：\n");
    scanf("%d%d", &n, &m);
    G.vertexNum = n;
    G.edgeNum = m;
    printf("请输入每个顶点的值：\n");
    for (int i = 0; i < n; i++) {
        scanf("%d", &G.vertex[i]);
    }
    printf("请输入每条边的两个顶点：\n");
    for (int i = 0; i < m; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        G.edges[u][v] = G.edges[v][u] = 1;
    }
    int start, end;
    printf("请输入起点和终点：\n");
    scanf("%d%d", &start, &end);
    BFS(&G, start, end);
    return 0;
}

以上代码实现了广度优先搜索算法，在邻接矩阵存储图的基础上找出从起点到终点的最短路径。