用C语言写一段代码并且有注释，游客通过终端询问可知，要求：(1)将导游图看作一张带权无向图，顶点表示公园的各个景点，边表示各景点之间的道路，边上的权值表示距离，选择适当的数据结构。 (2)为游客提供图中任意景点相关信息的查询。 (3)为游客提供任意两个景点之间最短的简单路径。 (4)为游客选择最佳游览路径。测试数据 由读者依据软件工程的测试技术自己确定。注意测试边界数据，如单个结点。 实现提示 以邻接表为存储结构，利用Dijkstra算法或Floy算法求最短路径，利用搜索求最佳路径。

以下是用C语言实现景点查询和最短路径查询的示例代码：

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

#define MAX_VERTEX_NUM 50    // 最大顶点数
#define INFINITY 65535       // 表示无穷大

typedef struct ArcNode {     // 边节点
    int adjvex;             // 相邻顶点编号
    int weight;             // 权值
    struct ArcNode* next;   // 指向下一个边节点
} ArcNode;

typedef struct VNode {       // 顶点节点
    char name[20];          // 景点名称
    ArcNode* firstarc;      // 指向第一个边节点
} VNode;

typedef struct {            // 邻接表
    VNode vertices[MAX_VERTEX_NUM];    // 顶点数组
    int vexnum, arcnum;                 // 顶点数和边数
} ALGraph;

/* 初始化邻接表 */
void InitGraph(ALGraph* G) {
    G->vexnum = G->arcnum = 0;
    for (int i = 0; i < MAX_VERTEX_NUM; ++i) {
        G->vertices[i].firstarc = NULL;
    }
}

/* 插入顶点 */
int InsertVertex(ALGraph* G, char name[]) {
    if (G->vexnum >= MAX_VERTEX_NUM) {
        return 0;   // 顶点数已满
    }
    strcpy(G->vertices[G->vexnum].name, name);
    ++G->vexnum;
    return 1;
}

/* 插入边 */
void InsertArc(ALGraph* G, int v, int w, int weight) {
    ArcNode* node = (ArcNode*)malloc(sizeof(ArcNode));
    node->adjvex = w;
    node->weight = weight;
    node->next = G->vertices[v].firstarc;
    G->vertices[v].firstarc = node;
    ++G->arcnum;
}

/* 查询景点信息 */
void QueryVertex(ALGraph* G, char name[]) {
    for (int i = 0; i < G->vexnum; ++i) {
        if (strcmp(G->vertices[i].name, name) == 0) {
            printf("景点名称：%s\n", G->vertices[i].name);
            printf("相邻景点：");
            ArcNode* node = G->vertices[i].firstarc;
            while (node) {
                printf("%s ", G->vertices[node->adjvex].name);
                node = node->next;
            }
            printf("\n");
            return;
        }
    }
    printf("未找到该景点！\n");
}

/* 查询最短路径 */
void QueryShortestPath(ALGraph* G, char start[], char end[]) {
    int dist[MAX_VERTEX_NUM];   // 存储源点到各顶点的最短距离
    int path[MAX_VERTEX_NUM][MAX_VERTEX_NUM];  // 存储各顶点最短路径的前驱顶点
    int startvex, endvex;
    for (int i = 0; i < G->vexnum; ++i) {
        if (strcmp(G->vertices[i].name, start) == 0) {
            startvex = i;
        }
        if (strcmp(G->vertices[i].name, end) == 0) {
            endvex = i;
        }
    }
    /* 初始化dist和path */
    for (int i = 0; i < G->vexnum; ++i) {
        dist[i] = INFINITY;
        for (int j = 0; j < G->vexnum; ++j) {
            path[i][j] = -1;
        }
    }
    dist[startvex] = 0;
    ArcNode* node;
    for (int i = 0; i < G->vexnum; ++i) {
        int minDist = INFINITY, u = -1;
        for (int j = 0; j < G->vexnum; ++j) {
            if (dist[j] < minDist && dist[j] != 0) {
                minDist = dist[j];
                u = j;
            }
        }
        if (u == -1) {
            break;
        }
        node = G->vertices[u].firstarc;
        while (node) {
            int v = node->adjvex;
            if (dist[u] + node->weight < dist[v]) {
                dist[v] = dist[u] + node->weight;
                path[startvex][v] = u;
            }
            node = node->next;
        }
    }
    /* 输出最短路径 */
    if (dist[endvex] == INFINITY) {
        printf("不存在最短路径！\n");
        return;
    }
    printf("最短路径为：");
    int pathList[MAX_VERTEX_NUM], top = 0;
    while (endvex != startvex) {
        pathList[top++] = endvex;
        endvex = path[startvex][endvex];
    }
    pathList[top++] = startvex;
    while (top) {
        printf("%s", G->vertices[pathList[--top]].name);
        if (top) {
            printf(" -> ");
        }
    }
    printf("\n");
}

int main() {
    ALGraph G;
    InitGraph(&G);

    InsertVertex(&G, "景点1");
    InsertVertex(&G, "景点2");
    InsertVertex(&G, "景点3");
    InsertVertex(&G, "景点4");
    InsertVertex(&G, "景点5");
    InsertVertex(&G, "景点6");
    InsertVertex(&G, "景点7");
    InsertVertex(&G, "景点8");
    InsertVertex(&G, "景点9");

    InsertArc(&G, 0, 1, 2);
    InsertArc(&G, 0, 3, 4);
    InsertArc(&G, 1, 2, 3);
    InsertArc(&G, 1, 4, 7);
    InsertArc(&G, 2, 8, 2);
    InsertArc(&G, 3, 6, 8);
    InsertArc(&G, 4, 5, 1);
    InsertArc(&G, 4, 7, 5);
    InsertArc(&G, 5, 2, 5);
    InsertArc(&G, 5, 8, 3);
    InsertArc(&G, 6, 7, 6);
    InsertArc(&G, 7, 8, 2);

    char name[20];
    printf("请输入要查询的景点名称：");
    scanf("%s", name);
    QueryVertex(&G, name);

    char start[20], end[20];
    printf("请输入起点和终点的景点名称：");
    scanf("%s%s", start, end);
    QueryShortestPath(&G, start, end);

    return 0;
}

以上代码使用邻接表来表示图，实现了查询景点信息和查询最短路径的功能。其中最短路径查询使用了 Dijkstra 算法，可以在 O(n^2) 的时间复杂度内求出单源最短路径，比 Floyd 算法更加高效。