📍 8个景点（索引0-7）：

🛤️ 9条道路（无向边）：

递归背后是栈（Stack）在工作 —— 每次调用压栈，返回时出栈

📋 Day04需要的五大全局变量：

/* DFS递归函数 —— 从顶点i开始深度优先遍历 */
void DFS(ALGraph graph, int i)
{
    // ======== 第1步：标记当前顶点 ========
    visited[i] = 1;                                    // 标记：已访问
    strcpy(path[indexp++], graph.roadlist[i].data);    // 记录到路径

    // ======== 第2步：遍历邻居，递归深入 ========
    for (p = graph.roadlist[i].first; p != NULL; p = p->next)
    {
        if (!visited[p->index])                         // 邻居未访问？
        {
            DFS(graph, p->index);                       // 🔴 递归深入！
            p = graph.roadlist[i].first;               // 🟡 递归返回后重置p！
        }
    }

    // ======== 第3步：自动回溯（不需要写代码）========
    // for循环结束 → 无未访问邻居 → 函数自动返回
}

Step 0：初始状态

visited全0，path空，indexp=0

Step 1：调用DFS(大门=0)

visited[0]=1，path[0]="大门"，indexp=1

Step 2：递归到DFS(红叶林=1)

visited[1]=1，path[1]="红叶林"，indexp=2

等等！实际上头插法的顺序是：

边的插入顺序（共9条，按代码顺序）：

Step 2：DFS(红叶林=1)

visited[1]=1，path[1]="红叶林"，p指向第一个邻居→碧玉潭

碧玉潭未访问！→ 递归！

Step 3：DFS(碧玉潭=4)

visited[4]=1，path[2]="碧玉潭"，indexp=3

p指向碧玉潭的第一个邻居→红叶林（已访问）→ p=p->next→赏花园

赏花园未访问！→ 递归！

Step 4：DFS(赏花园=7)

visited[7]=1，path[3]="赏花园"，p→观月阁（未访问）→ 递归

Step 5：DFS(观月阁=6)

visited[6]=1，path[4]="观月阁"，p→赏花园（已访问）→ p->next→飞云石（未访问）→ 递归

Step 6：DFS(飞云石=5)

visited[5]=1，path[5]="飞云石"，p→观月阁（已访问）→ p->next→九曲桥（未访问）→ 递归

栈深度=6，继续深入！

Step 7：DFS(九曲桥=3)

visited[3]=1，path[6]="九曲桥"，p→飞云石（已访问）→ p->next→碧玉潭（已访问）→ p->next→白虎岩（未访问！）→ 递归

Step 8：DFS(白虎岩=2) 🎯 最深层！

visited[2]=1，path[7]="白虎岩"，indexp=8！

p→九曲桥（已访问）→ p->next→红叶林（已访问）→ p->next→NULL

🔙 for循环结束！没有未访问邻居了！开始回溯！

栈深度=8（最大值），所有顶点都访问了！

回溯过程中每层都要做的事：

📋 我们的例子中：

白虎岩返回九曲桥 → p重置→检查所有邻居：飞云石(✓)、碧玉潭(✓)、白虎岩(✓) → 全访问过→返回
九曲桥返回飞云石 → p重置→检查邻居：观月阁(✓)、九曲桥(✓) → 全访问→返回
飞云石返回观月阁 → p重置→检查邻居：赏花园(✓)、飞云石(✓) → 全访问→返回
观月阁返回赏花园 → p重置→检查邻居：观月阁(✓)、碧玉潭(✓) → 全访问→返回
赏花园返回碧玉潭 → p重置→检查邻居：红叶林(✓)、赏花园(✓)、九曲桥(✓) → 全访问→返回
碧玉潭返回红叶林 → p重置→检查邻居：碧玉潭(✓)、白虎岩(✓)、大门(✓) → 全访问→返回
红叶林返回大门 → p重置→检查邻居：红叶林(✓) → 全访问→返回
大门返回DFSTraverse → DFS完成！🎉

🎉 最终访问顺序：

void createGuideGraph(ALGraph *graph, ALGraph *guideGraph)
{
    int i=0, j=0, k=0, n=0, flag=0, edgenum=0, m=0;
    CNode *node1, *node2;

    // ① 先做DFS，得到path数组
    DFSTraverse(*graph);

    // ② 回溯补边：填充guidePath数组
    for (i = 0; i < graph->nodenum - 1; i++)
    {
        k = 0;
        flag = 1;
        while (flag)
        {
            guidePath[n++] = path[i + k];  // 加入当前景点
            if (isEdge(*graph, path[i+k], path[i+1]))
                flag = 0;  // 有直接边，停止回溯
            else
                k--;         // 没边，后退一步（回溯）
        }
    }
    guidePath[n] = path[i];  // 加入最后一个景点

    // ③ 打印导游路线
    printf("导游路线为：\n");
    for (i = 0; i <= n; i++)
        printf("%s-", guidePath[i]);
    printf("\n");

    // ④ 初始化guideGraph顶点
    for (i = 0; i <= n; i++)
        visited[i] = 0;
    for (i = 0; i < graph->nodenum; i++)
    {
        strcpy(guideGraph->roadlist[i].data, graph->roadlist[i].data);
        guideGraph->roadlist[i].first = NULL;
    }

    // ⑤ 根据guidePath构建导游图的边
    for (k = 0; k < n; k++)
    {
        i = locate(*graph, guidePath[k]);
        j = locate(*graph, guidePath[k+1]);
        if (visited[j])
        {
            // j已访问：这是回边，跳过？不，找近路...
            m = k + 2;
            if (m <= n)
            {
                while (visited[locate(*graph, guidePath[m])])
                {
                    if (isEdge(*graph, guidePath[k], guidePath[m]))
                    {
                        j = locate(*graph, guidePath[m]);
                        // 添加边 i→j
                        node1 = (CNode*)malloc(sizeof(CNode));
                        node1->index = j;
                        node1->length = (int)parray[i][j];
                        node1->next = guideGraph->roadlist[i].first;
                        guideGraph->roadlist[i].first = node1;
                        edgenum++;
                    }
                    if (++m >= n) break;
                }
            }
        }
        else
        {
            // j未访问：这是树边（DFS前进的边）
            visited[i] = 1;
            visited[j] = 1;
            node1 = (CNode*)malloc(sizeof(CNode));
            node1->index = j;
            node1->length = (int)parray[i][j];
            node1->next = guideGraph->roadlist[i].first;
            guideGraph->roadlist[i].first = node1;
            edgenum++;
        }
    }
    guideGraph->nodenum = graph->nodenum;
    guideGraph->edgenum = edgenum;
}