diff --git a/daikuan.cpp b/daikuan.cpp
deleted file mode 100644
index 065d0757a6d399a4edb6bee903da91305353c32e..0000000000000000000000000000000000000000
--- a/daikuan.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#include <stdio.h>
-#include <math.h>
-
-// 函数声明
-void calculateLoan(double principal, double annualRate, int years);
-void displayAmortizationSchedule(double principal, double annualRate, int years, double monthlyPayment);
-void displayResults(double monthlyPayment, double totalPayment, double principal);
-
-int main() {
-    double principal;
-    double annualRate;
-    int years;
-    char showSchedule;
-    
-    printf("=== 高级贷款计算系统 ===\n\n");
-    
-    // 输入贷款信息
-    printf("请输入贷款总额（元）: ");
-    scanf("%lf", &principal);
-    
-    printf("请输入年利率（%%）: ");
-    scanf("%lf", &annualRate);
-    
-    printf("请输入贷款年限: ");
-    scanf("%d", &years);
-    
-    // 验证输入
-    if (principal <= 0 || annualRate <= 0 || years <= 0) {
-        printf("\n错误：输入值必须大于零！\n");
-        return 1;
-    }
-    
-    printf("\n是否显示详细还款计划表？(y/n): ");
-    scanf(" %c", &showSchedule);
-    
-    printf("\n=== 计算结果 ===\n");
-    calculateLoan(principal, annualRate, years);
-    
-    if (showSchedule == 'y' || showSchedule == 'Y') {
-        double monthlyRate = annualRate / 100 / 12;
-        int totalMonths = years * 12;
-        double monthlyPayment = (principal * monthlyRate * pow(1 + monthlyRate, totalMonths)) 
-                              / (pow(1 + monthlyRate, totalMonths) - 1);
-        displayAmortizationSchedule(principal, annualRate, years, monthlyPayment);
-    }
-    
-    return 0;
-}
-
-void calculateLoan(double principal, double annualRate, int years) {
-    double monthlyRate = annualRate / 100 / 12;
-    int totalMonths = years * 12;
-    double monthlyPayment = (principal * monthlyRate * pow(1 + monthlyRate, totalMonths)) 
-                          / (pow(1 + monthlyRate, totalMonths) - 1);
-    double totalPayment = monthlyPayment * totalMonths;
-    
-    displayResults(monthlyPayment, totalPayment, principal);
-}
-
-void displayResults(double monthlyPayment, double totalPayment, double principal) {
-    double totalInterest = totalPayment - principal;
-    
-    printf("\n贷款摘要：\n");
-    printf("═══════════════════════════════\n");
-    printf("?? 贷款总额:   ￥%12.2f 元\n", principal);
-    printf("?? 月均还款:   ￥%12.2f 元\n", monthlyPayment);
-    printf("?? 总还款额:   ￥%12.2f 元\n", totalPayment);
-    printf("?? 支付利息:   ￥%12.2f 元\n", totalInterest);
-    printf("??  还款期限:   %12d 个月\n", (int)(totalPayment / monthlyPayment));
-    printf("═══════════════════════════════\n");
-    
-    printf("\n财务分析：\n");
-    printf("利息占比: %6.2f%%\n", (totalInterest / totalPayment) * 100);
-    printf("本金占比: %6.2f%%\n", (principal / totalPayment) * 100);
-    printf("年均还款: ￥%.2f 元\n", monthlyPayment * 12);
-}
-
-void displayAmortizationSchedule(double principal, double annualRate, int years, double monthlyPayment) {
-    double monthlyRate = annualRate / 100 / 12;
-    int totalMonths = years * 12;
-    double balance = principal;
-    double totalInterest = 0;
-    
-    printf("\n\n=== 还款计划表（前12个月） ===\n");
-    printf("┌───────┬────────────┬────────────┬────────────┬────────────┐\n");
-    printf("│ 期数  │   月供     │   本金     │   利息     │   余额     │\n");
-    printf("├───────┼────────────┼────────────┼────────────┼────────────┤\n");
-    
-    for (int month = 1; month <= totalMonths && month <= 12; month++) {
-        double interest = balance * monthlyRate;
-        double principalPaid = monthlyPayment - interest;
-        balance -= principalPaid;
-        totalInterest += interest;
-        
-        printf("│ %5d │ %10.2f │ %10.2f │ %10.2f │ %10.2f │\n", 
-               month, monthlyPayment, principalPaid, interest, balance);
-    }
-    printf("└───────┴────────────┴────────────┴────────────┴────────────┘\n");
-    
-    // 显示最后12个月的还款情况（如果贷款期限超过24个月）
-    if (totalMonths > 24) {
-        printf("\n=== 还款计划表（最后12个月） ===\n");
-        printf("┌───────┬────────────┬────────────┬────────────┬────────────┐\n");
-        printf("│ 期数  │   月供     │   本金     │   利息     │   余额     │\n");
-        printf("├───────┼────────────┼────────────┼────────────┼────────────┤\n");
-        
-        // 重置余额重新计算到最后12个月
-        balance = principal;
-        for (int month = 1; month <= totalMonths - 12; month++) {
-            double interest = balance * monthlyRate;
-            double principalPaid = monthlyPayment - interest;
-            balance -= principalPaid;
-        }
-        
-        for (int month = totalMonths - 11; month <= totalMonths; month++) {
-            double interest = balance * monthlyRate;
-            double principalPaid = monthlyPayment - interest;
-            balance -= principalPaid;
-            
-            printf("│ %5d │ %10.2f │ %10.2f │ %10.2f │ %10.2f │\n", 
-                   month, monthlyPayment, principalPaid, interest, balance);
-        }
-        printf("└───────┴────────────┴────────────┴────────────┴────────────┘\n");
-    }
-}
diff --git "a/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/.keep" "b/\345\233\276\347\273\223\346\236\204/.keep"
similarity index 100%
rename from "\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/.keep"
rename to "\345\233\276\347\273\223\346\236\204/.keep"
diff --git "a/\345\233\276\347\273\223\346\236\204/\346\272\220\344\273\243\347\240\201" "b/\345\233\276\347\273\223\346\236\204/\346\272\220\344\273\243\347\240\201"
new file mode 100644
index 0000000000000000000000000000000000000000..c37f7c0cca64294202bd0aaf50cc39d9a16e4088
--- /dev/null
+++ "b/\345\233\276\347\273\223\346\236\204/\346\272\220\344\273\243\347\240\201"
@@ -0,0 +1,216 @@
+#include <stdio.h>
+#include <string.h>
+#define MAX_SPOTS 20  // 鏈�澶ф櫙鐐规暟
+#define INF 10000     // 鏃犵┓澶ф爣璁�
+
+// 鏅偣淇℃伅缁撴瀯浣擄紙鏂板鏀惰棌鏍囪涓庡叧閿瘝锛�
+typedef struct {
+    int id;         // 缂栧彿
+    char name[50];  // 鍚嶇О
+    char intro[200];// 绠�浠�
+    char keyword[100];// 鎼滅储鍏抽敭璇嶏紙濡�"瀛︿範 鍥句功"锛�
+    int isCollected;// 鏀惰棌鏍囪锛�1=鏀惰棌锛�0=鏈敹钘忥級
+} Spot;
+
+// 鍥剧粨鏋勶紙淇濈暀閭绘帴鐭╅樀锛�
+typedef struct {
+    Spot spots[MAX_SPOTS];
+    int dist[MAX_SPOTS][MAX_SPOTS];// 璺濈鐭╅樀
+    int crowd[MAX_SPOTS][MAX_SPOTS];// 鎷ユ尋搴︾煩闃碉紙1-5绾э級
+    int spotCount;                 // 瀹為檯鏅偣鏁�
+} CampusGraph;
+
+// 鍒濆鍖栧浘
+void initGraph(CampusGraph *g) {
+    g->spotCount = 0;
+    for (int i = 0; i < MAX_SPOTS; i++) {
+        g->spots[i].isCollected = 0;
+        for (int j = 0; j < MAX_SPOTS; j++) {
+            g->dist[i][j] = (i == j) ? 0 : INF;
+            g->crowd[i][j] = 3; // 榛樿鎷ユ尋搴︿腑绛�
+        }
+    }
+}
+
+// 娣诲姞鏅偣锛堝惈鍏抽敭璇嶏級
+void addSpot(CampusGraph *g, int id, char *name, char *intro, char *keyword) {
+    g->spots[id].id = id;
+    strcpy(g->spots[id].name, name);
+    strcpy(g->spots[id].intro, intro);
+    strcpy(g->spots[id].keyword, keyword);
+    g->spotCount++;
+}
+
+// 娣诲姞璺緞锛堣窛绂�+鎷ユ尋搴︼級
+void addPath(CampusGraph *g, int a, int b, int distance, int crowdLevel) {
+    g->dist[a][b] = g->dist[b][a] = distance;
+    g->crowd[a][b] = g->crowd[b][a] = crowdLevel;
+}
+
+// 1. 鍏抽敭璇嶆悳绱㈡櫙鐐�
+void searchSpot(CampusGraph *g, char *key) {
+    printf("\n===== 鎼滅储缁撴灉 =====\n");
+    int found = 0;
+    for (int i = 0; i < g->spotCount; i++) {
+        if (strstr(g->spots[i].name, key) || strstr(g->spots[i].keyword, key)) {
+            printf("缂栧彿锛�%d | 鍚嶇О锛�%s\n绠�浠嬶細%s\n鏀惰棌鐘舵�侊細%s\n\n",
+                   g->spots[i].id, g->spots[i].name, g->spots[i].intro,
+                   g->spots[i].isCollected ? "宸叉敹钘�" : "鏈敹钘�");
+            found = 1;
+        }
+    }
+    if (!found) printf("鏈壘鍒板惈銆�%s銆嶇殑鏅偣\n", key);
+}
+
+// 2. 鏀惰棌/鍙栨秷鏀惰棌鏅偣
+void toggleCollection(CampusGraph *g, int id) {
+    if (id < 0 || id >= g->spotCount) {
+        printf("鏅偣缂栧彿鏃犳晥锛乗n");
+        return;
+    }
+    g->spots[id].isCollected = !g->spots[id].isCollected;
+    printf("鎿嶄綔鎴愬姛锛�%s宸�%s鏀惰棌\n", g->spots[id].name,
+           g->spots[id].isCollected ? "鍔犲叆" : "鍙栨秷");
+}
+
+// 3. 鏌ョ湅鏀惰棌鍒楄〃
+void showCollection(CampusGraph *g) {
+    printf("\n===== 鏀惰棌鍒楄〃 =====\n");
+    int hasCollected = 0;
+    for (int i = 0; i < g->spotCount; i++) {
+        if (g->spots[i].isCollected) {
+            printf("缂栧彿锛�%d | 鍚嶇О锛�%s\n绠�浠嬶細%s\n\n",
+                   g->spots[i].id, g->spots[i].name, g->spots[i].intro);
+            hasCollected = 1;
+        }
+    }
+    if (!hasCollected) printf("鏆傛棤鏀惰棌鏅偣\n");
+}
+
+// Dijkstra绠楁硶锛堟敮鎸佽窛绂�/鎷ユ尋搴︽潈閲嶏級
+void dijkstra(CampusGraph *g, int start, int type, int res[], int prev[]) {
+    int visited[MAX_SPOTS] = {0};
+    for (int i = 0; i < g->spotCount; i++) {
+        res[i] = (type == 1) ? g->dist[start][i] : g->crowd[start][i];
+        prev[i] = (res[i] != INF && res[i] != 3) ? start : -1;
+    }
+    visited[start] = 1;
+
+    for (int i = 1; i < g->spotCount; i++) {
+        int minVal = INF, u = -1;
+        for (int j = 0; j < g->spotCount; j++) {
+            if (!visited[j] && res[j] < minVal) {
+                minVal = res[j];
+                u = j;
+            }
+        }
+        if (u == -1) break;
+        visited[u] = 1;
+
+        for (int v = 0; v < g->spotCount; v++) {
+            int val = (type == 1) ? g->dist[u][v] : g->crowd[u][v];
+            if (!visited[v] && res[u] + val < res[v]) {
+                res[v] = res[u] + val;
+                prev[v] = u;
+            }
+        }
+    }
+}
+
+// 鎵撳嵃璺緞
+void printPath(CampusGraph *g, int prev[], int end) {
+    if (prev[end] == -1) {
+        printf("%s", g->spots[end].name);
+        return;
+    }
+    printPath(g, prev, prev[end]);
+    printf(" 鈫� %s", g->spots[end].name);
+}
+
+// 澧炲己鐗堜富鑿滃崟
+void showMenu() {
+    printf("\n===== 鏍″洯瀵兼父绯荤粺锛堝寮虹増锛�=====\n");
+    printf("1. 鏌ョ湅鎵�鏈夋櫙鐐筡n2. 鍏抽敭璇嶆悳绱㈡櫙鐐筡n3. 鏀惰棌/鍙栨秷鏀惰棌鏅偣\n");
+    printf("4. 鏌ョ湅鏀惰棌鍒楄〃\n5. 鏌ヨ璺緞锛�1-鏈�鐭紝2-閬垮嘲锛塡n6. 閫�鍑篭n");
+    printf("璇烽�夋嫨鍔熻兘锛�1-6锛夛細");
+}
+
+// 涓诲嚱鏁�
+int main() {
+    CampusGraph g;
+    initGraph(&g);
+    // 鍒濆鍖栨櫙鐐癸紙鍚叧閿瘝锛�
+    addSpot(&g, 0, "鍖楅棬", "杩戝湴閾佸彛锛岃闂ㄧ", "鏍￠棬 鍦伴搧 闂ㄧ");
+    addSpot(&g, 1, "鍥句功棣�", "棣嗚棌涓板瘜锛岃嚜涔犲尯鍏呰冻", "瀛︿範 鍥句功 鑷範");
+    addSpot(&g, 2, "鏁欏妤�", "澶氬獟浣撴暀瀹わ紝瀹為獙瀹�", "涓婅 瀹為獙 鏁欏");
+    addSpot(&g, 3, "椋熷爞", "鍗楀寳鑿滅郴锛屼环鏍间翰姘�", "鍚冮キ 椁愰ギ 骞充环");
+    addSpot(&g, 4, "鎿嶅満", "璺戦亾+绡悆鍦猴紝杩愬姩棣栭��", "杩愬姩 璺戞 绡悆");
+    addSpot(&g, 5, "瀹胯垗鍖�", "娲楄。鎴�+渚垮埄搴�", "浣忓 鐢熸椿 璐墿");
+    addSpot(&g, 6, "浣撹偛棣�", "瀹ゅ唴鍦洪锛岃禌浜嬩妇鍔炲湴", "杩愬姩 璧涗簨 瀹ゅ唴");
+
+    // 鍒濆鍖栬矾寰勶紙璺濈/鎷ユ尋搴︼級
+    addPath(&g, 0, 1, 200, 2);
+    addPath(&g, 0, 2, 150, 3);
+    addPath(&g, 1, 3, 300, 4);
+    addPath(&g, 2, 3, 220, 3);
+    addPath(&g, 2, 4, 400, 2);
+    addPath(&g, 3, 5, 280, 3);
+    addPath(&g, 4, 6, 250, 1);
+    addPath(&g, 5, 6, 350, 2);
+
+    int choice, start, end, type;
+    int res[MAX_SPOTS], prev[MAX_SPOTS];
+    char key[50];
+    while (1) {
+        showMenu();
+        scanf("%d", &choice);
+        switch (choice) {
+            case 1: // 鏌ョ湅鎵�鏈夋櫙鐐�
+                printf("\n===== 鍏ㄩ儴鏅偣 =====\n");
+                for (int i = 0; i < g.spotCount; i++)
+                    printf("缂栧彿锛�%d | 鍚嶇О锛�%s\n绠�浠嬶細%s\n鏀惰棌锛�%s\n\n",
+                           g.spots[i].id, g.spots[i].name, g.spots[i].intro,
+                           g.spots[i].isCollected ? "鏄�" : "鍚�");
+                break;
+            case 2: // 鎼滅储鏅偣
+                printf("\n杈撳叆鎼滅储鍏抽敭璇嶏細");
+                getchar();
+                fgets(key, 50, stdin);
+                key[strcspn(key, "\n")] = '\0';
+                searchSpot(&g, key);
+                break;
+            case 3: // 鏀惰棌鎿嶄綔
+                printf("\n杈撳叆鏅偣缂栧彿锛�");
+                scanf("%d", &start);
+                toggleCollection(&g, start);
+                break;
+            case 4: // 鏌ョ湅鏀惰棌
+                showCollection(&g);
+                break;
+            case 5: // 璺緞鏌ヨ
+                printf("\n閫夋嫨璺緞绫诲瀷锛�1-鏈�鐭窛绂伙紝2-閬垮嘲璺嚎锛夛細");
+                scanf("%d", &type);
+                printf("璧风偣缂栧彿锛�");
+                scanf("%d", &start);
+                printf("缁堢偣缂栧彿锛�");
+                scanf("%d", &end);
+                if (start < 0 || start >= g.spotCount || end < 0 || end >= g.spotCount) {
+                    printf("缂栧彿鏃犳晥锛乗n");
+                    break;
+                }
+                dijkstra(&g, start, type, res, prev);
+                if (res[end] == INF) printf("鏃犲彲杈捐矾寰勶紒\n");
+                else {
+                    printf("\n%s锛�", type == 1 ? "鏈�鐭矾寰�" : "閬垮嘲璺緞");
+                    printPath(&g, prev, end);
+                    printf("\n%s锛�%d%s\n", type == 1 ? "鎬昏窛绂�" : "鎬绘嫢鎸ゅ害",
+                           res[end], type == 1 ? "绫�" : "绾�");
+                }
+                break;
+            case 6: // 閫�鍑�
+                printf("鎰熻阿浣跨敤锛屽啀瑙侊紒\n");
+                return 0;
+            default: printf("杈撳叆閿欒锛岃閲嶈瘯锛乗n");
+        }
+    }
+}
\ No newline at end of file
diff --git "a/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/attendance.c" "b/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/attendance.c"
deleted file mode 100644
index 44095a1e749876b31b5f538a0fe5140d566b2725..0000000000000000000000000000000000000000
--- "a/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/attendance.c"
+++ /dev/null
@@ -1,155 +0,0 @@
-#include <stdio.h> //用于printf，scanf等函数
-#include <stdlib.h> //用于malloc等内存分配函数
-#include <string.h> //用于字符串操作函数
-#include <windows.h> // 用于控制台颜色
-
-#include "attendance.h"
-
-// ========== 全局变量 ==========
-Student *studentHead = NULL; //定义学生链表头指针，用于管理学生信息链表
-ClassRecord *recordHead = NULL; //定义考勤记录链表头指针，用于管理考勤记录链表
-
-// ========== 控制台颜色 ==========
-void setColor(int color) { //定义设置台颜色的参数
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color);  //调用Windows API函数，设置控制台输出文本颜色
-}
-
-// ========== 学生管理 ==========
-void addStudent() {
-    Student *p = (Student*)malloc(sizeof(Student)); //创造新学生节点
-    printf("请输入 学号 姓名 班级："); //提示用户输入学生的学号，姓名，班级信息
-    scanf("%s %s %s", p->id, p->name, p->className); //读取用户输入的学号、姓名、班级信息，存入新学生节点
-    p->next = studentHead;  //将新节点的next指针指向原链表头，实现头插法
-    studentHead = p; //将链表头指针指向新节点，完成新节点插入
-    setColor(10);
-    printf(" 学生添加成功！\n"); //打印学生添加成功的提示信息
-    setColor(7);
-}
-
-void showStudents() {
-    Student *p = studentHead; //定义学生指针，并让其指向学生链表头
-    setColor(11);
-    printf("\n%-10s %-10s %-10s\n", "学号", "姓名", "班级"); //打印学生信息表头，按指定格式对齐
-    setColor(7);
-    while (p) {
-        printf("%-10s %-10s %-10s\n", p->id, p->name, p->className); //打印当前学生的学号、姓名、班级信息，按格式对齐
-        p = p->next; //指针指向下一个学生节点
-    } //循环结束
-} //函数结束
-
-//删除学生信息
-void deleteStudent(char *id) {
-    Student *p = studentHead, *pre = NULL; //遍历查找要删除的学生
-    while (p) {
-        if (strcmp(p->id, id) == 0) {   //找到匹配学号
-            if (pre) pre->next = p->next;  //前驱节点指向当前节点的后继
-            else studentHead = p->next;
-            free(p);                     //释放内存
-            setColor(12);                
-            printf(" 已删除学号 %s\n", id);
-            setColor(7);
-            return;
-        }
-        pre = p;         //更新前驱节点
-        p = p->next;       //移动到下一个节点
-    }
-    printf("未找到该学生！\n");
-}
-
-//开始考勤记录
-// ========== 考勤管理 ==========
-void startAttendance(int lessonNo) {  
-    ClassRecord *cr = (ClassRecord*)malloc(sizeof(ClassRecord));  //分配课程记录内存
-    cr->lessonNo = lessonNo;
-    cr->attList = NULL;       //初始化考勤链表为空
-    cr->next = recordHead;    //新记录插入链表头部
-    recordHead = cr;          //更新记录链表头
-
-    Student *p = studentHead;    //遍历所有学生进行考勤
-    printf("\n 第%d节课考勤：\n", lessonNo);
-    while (p) {
-        int st;
-        printf("学号:%s 姓名:%s 出勤输入1 缺勤输入0: ", p->id, p->name);
-        scanf("%d", &st);
-        Attendance *a = (Attendance*)malloc(sizeof(Attendance)); //分配考勤记录内存
-        strcpy(a->studentId, p->id); //复制学号
-        a->status = st;   //设置考勤状态
-        a->next = cr->attList;   //插入考勤链表头部
-        cr->attList = a;       //更新考勤链表头
-        p = p->next;
-    }
-    setColor(10);//设置颜色为绿色，输出考勤完成提示
-    printf(" 考勤记录完成！\n");
-    setColor(7);
-}
-//显示某次课程考勤情况的函数，参数lessonNo是课程编号
-void showLessonAttendance(int lessonNo) {//定义指针cr指向考勤记录链表头，用于查找目标课程
-    ClassRecord *cr = recordHead;//遍历考勤记录链表，查找指定课程编号的记录//当cr不为NULL且课程编号不匹配时继续查找
-    while (cr && cr->lessonNo != lessonNo) cr = cr->next;// 移动到下一个课程记录
-    if (!cr) {// 检查是否找到目标课程记录
-        printf(" 未找到第%d节课记录！\n", lessonNo);  // 如果没有找到，输出提示信息
-        return;  // 退出函数
-    }
-    Attendance *a = cr->attList;   // 定义指针a指向当前课程的考勤链表头
-    setColor(14);  // 设置颜色为黄色（14代表黄色），输出表头
-    printf("\n第%d节课考勤情况：\n", lessonNo);
-    printf("%-10s %-10s %-10s\n", "学号", "姓名", "状态");
-    setColor(7);
-    while (a) { // 遍历当前课程的所有考勤记录
-        Student *p = studentHead; // 定义指针p指向学生链表头，用于查找对应学号的学生信息
-        while (p && strcmp(p->id, a->studentId) != 0) p = p->next;       // 在学生链表中查找与当前考勤记录学号匹配的学生
-        if (p) { // 移动到下一个学生    // 如果找到对应的学生信息
-            printf("%-10s %-10s ", p->id, p->name);      // 打印学生的学号和姓名
-            if (a->status) { setColor(10); printf("出勤\n"); setColor(7); }  // 根据考勤状态显示不同的颜色和信息
-            else { setColor(12); printf("缺勤\n"); setColor(7); } // 如果状态为1（出勤），设置绿色并显示"出勤"
-        }// 如果状态为0（缺勤），设置红色并显示"缺勤"
-        a = a->next;     // 移动到下一个考勤记录
-    }
-}
-// 显示指定学生所有考勤记录的函数，参数id是学生学号
-void showStudentAttendance(char *id) {
-    ClassRecord *cr = recordHead;   // 定义指针cr指向考勤记录链表头
-    printf("\n学号 %s 的考勤情况：\n", id);   // 输出查询提示
-    while (cr) {//遍历所有课程记录
-        Attendance *a = cr->attList;   // 定义指针a指向当前课程的考勤链表头
-        while (a) { // 遍历当前课程的所有考勤记录
-            if (strcmp(a->studentId, id) == 0) {  // 检查当前考勤记录是否与指定学号匹配
-                printf("第%d节课: %s\n", cr->lessonNo, a->status ? "出勤" : "缺勤");     // 如果匹配，输出该课程的考勤情况
-            } // 使用三元运算符根据status显示"出勤"或"缺勤"
-            a = a->next;  // 移动到下一个考勤记录
-        }
-        cr = cr->next;     // 移动到下一个课程记录
-    }
-}
-
-// ========== 统计 ==========
-void countLessonRate(int lessonNo) {
-    ClassRecord *cr = recordHead;//从课次记录链表头部开始查找
-    while (cr && cr->lessonNo != lessonNo) cr = cr->next;//不匹配就移动到下一个课次记录
-    if (!cr) {//cr为NULL表示遍历整个链表都没有找到匹配的课次
-        printf("未找到该课次！\n");
-        return;//提前结束函数执行
-    }
-    int total = 0, present = 0;//总学生人数计数器；出勤学生人数计数器
-    Attendance *a = cr->attList;
-    while (a) {
-        total++;//每有一条考勤记录，总人数加1
-        if (a->status) present++;//检查考勤状态，a->status为真（非0）表示出勤；出勤人数加1
-        a = a->next;//移动到下一个考勤记录
-    }
-    printf("第%d节课出勤率: %.2f%%\n", lessonNo, (double)present / total * 100);
-}
-
-void countStudentAbsence(char *id) {
-    ClassRecord *cr = recordHead;//获取课次记录链表头部
-    int cnt = 0;//初始化缺勤次数计数器
-    while (cr) {//这个循环检查该学生在每一节课的考勤情况
-        Attendance *a = cr->attList;//获取当前课次的考勤记录链表头部
-        while (a) {
-            if (strcmp(a->studentId, id) == 0 && a->status == 0) cnt++;//满足条件，缺勤次数加1
-            a = a->next;//移动到当前课次的下一个考勤记录
-        }
-        cr = cr->next;//移动到下一个课次记录
-    }
-    printf("学号 %s 缺勤次数: %d\n", id, cnt);
-}
diff --git "a/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/attendance.h" "b/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/attendance.h"
deleted file mode 100644
index 6a32f49c58c2c0ef246e1b289c3aae35b0a1630a..0000000000000000000000000000000000000000
--- "a/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/attendance.h"
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef ATTENDANCE_H
-#define ATTENDANCE_H
-
-// 学生信息结构体
-typedef struct Student {
-    char id[20];
-    char name[20];
-    char className[20];//学生所在班级
-    struct Student *next;//指向下一个学生节点的指针，用于链表连接
-} Student;
-
-// 考勤记录结构体：用于存储单次考勤的信息，采用链表结构
-typedef struct Attendance {
-    char studentId[20];//学生学号
-    int status; // 考勤状态，1=出勤, 0=缺勤
-    struct Attendance *next;//指向下一条考勤记录的指针，用于链表连接
-} Attendance;
-
-// 课程记录结构体：用于存储某一次课程的考勤集合，采用链表结构
-typedef struct ClassRecord {
-    int lessonNo;//课程编号
-    Attendance *attList;//指向该次课程考勤记录链表的头指针
-    struct ClassRecord *next;//指向下一次课程记录的指针，用于链表连接
-} ClassRecord;
-
-// ========== 函数声明 ==========
-
-// 学生管理
-void addStudent(); //添加学生信息
-void showStudents();//显示所有学生信息
-void deleteStudent(char *id);//根据学号删除学生信息
-
-// 考勤管理
-void startAttendance(int lessonNo);// 开始某一次课程的考勤
-void showLessonAttendance(int lessonNo);// 显示某一次课程的考勤记录
-void showStudentAttendance(char *id);// 显示某个学生的所有考勤记录
-
-// 统计
-void countLessonRate(int lessonNo);// 统计某一次课程的出勤率
-void countStudentAbsence(char *id);// 统计某个学生的缺勤次数
-
-// 工具
-void setColor(int color);// 设置控制台输出颜色（color为颜色代码）
-
-#endif
diff --git "a/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/main.c" "b/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/main.c"
deleted file mode 100644
index 835577e9568dee653bf9bfedc3840ff3114d6ee0..0000000000000000000000000000000000000000
--- "a/\345\255\246\347\224\237\350\200\203\345\213\244\347\263\273\347\273\237/main.c"
+++ /dev/null
@@ -1,82 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "attendance.h"
-
-int main() {
-    int choice; // 用户选择
-    
-    // 主循环
-    while (1) {
-        // 显示系统菜单
-        setColor(11); // 青色标题
-        printf("\n========= 学生考勤系统 =========\n");
-        setColor(7); // 恢复默认颜色
-        
-        // 菜单选项
-        printf("1. 添加学生\n");
-        printf("2. 删除学生\n");
-        printf("3. 显示学生列表\n");
-        printf("4. 开始考勤\n");
-        printf("5. 查看某节课考勤\n");
-        printf("6. 查看某个学生考勤\n");
-        printf("7. 统计某节课出勤率\n");
-        printf("8. 统计某学生缺勤次数\n");
-        printf("0. 退出系统\n");
-        printf("请输入选项：");
-
-        // 获取用户输入
-        scanf("%d", &choice);
-        if (choice == 0) break; // 退出系统
-
-        char id[20]; // 学号缓冲区
-        int lesson;  // 课次变量
-        
-        // 根据用户选择执行相应功能
-        switch(choice) {
-            case 1: 
-                addStudent(); // 添加学生
-                break;
-            case 2: 
-                printf("输入学号: "); 
-                scanf("%s", id); 
-                deleteStudent(id); // 删除学生
-                break;
-            case 3: 
-                showStudents(); // 显示学生列表
-                break;
-            case 4: 
-                printf("输入课次: "); 
-                scanf("%d", &lesson); 
-                startAttendance(lesson); // 开始考勤
-                break;
-            case 5: 
-                printf("输入课次: "); 
-                scanf("%d", &lesson); 
-                showLessonAttendance(lesson); // 查看课次考勤
-                break;
-            case 6: 
-                printf("输入学号: "); 
-                scanf("%s", id); 
-                showStudentAttendance(id); // 查看学生考勤
-                break;
-            case 7: 
-                printf("输入课次: "); 
-                scanf("%d", &lesson); 
-                countLessonRate(lesson); // 统计出勤率
-                break;
-            case 8: 
-                printf("输入学号: "); 
-                scanf("%s", id); 
-                countStudentAbsence(id); // 统计缺勤次数
-                break;
-            default: 
-                printf("无效输入！\n"); // 错误输入处理
-        }
-    }
-    
-    // 退出系统
-    setColor(10); // 绿色退出信息
-    printf(" 感谢使用，再见！\n");
-    setColor(7); // 恢复默认颜色
-    return 0;
-}
diff --git "a/\346\240\221\347\273\223\346\236\204/.keep" "b/\346\240\221\347\273\223\346\236\204/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/\346\240\221\347\273\223\346\236\204/campus_tree.h" "b/\346\240\221\347\273\223\346\236\204/campus_tree.h"
new file mode 100644
index 0000000000000000000000000000000000000000..ae3bc7590c3fea889117a5361a5243128fcbd0dc
--- /dev/null
+++ "b/\346\240\221\347\273\223\346\236\204/campus_tree.h"
@@ -0,0 +1,65 @@
+#ifndef CAMPUS_TREE_ENHANCE_H
+#define CAMPUS_TREE_ENHANCE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+// 鍦扮偣淇℃伅缁撴瀯浣�
+typedef struct Place {
+    int id;                 // 鍦扮偣ID
+    char name[50];          // 鍦扮偣鍚嶇О
+    float x;                // 妯潗鏍�
+    float y;                // 绾靛潗鏍�
+    char desc[200];         // 鍔熻兘鎻忚堪
+    char openTime[50];      // 寮�鏀炬椂闂�
+} Place;
+
+// 鏍戣妭鐐圭粨鏋勪綋
+typedef struct TreeNode {
+    Place data;             // 鑺傜偣瀛樺偍鐨勫湴鐐规暟鎹�
+    struct TreeNode* parent;// 鐖惰妭鐐规寚閽�
+    struct TreeNode* child; // 绗竴涓瓙鑺傜偣鎸囬拡
+    struct TreeNode* sibling;// 鍏勫紵鑺傜偣鎸囬拡
+    int childCount;         // 瀛愯妭鐐规暟閲�
+} TreeNode, *Tree;
+
+// 鏍堢粨鏋勪綋
+typedef struct Stack {
+    int top;
+    int type;               // 0: 鑺傜偣鏍堬紝1: 鎿嶄綔鏍�
+    union {
+        TreeNode** nodes;   // 鍔ㄦ�佽妭鐐规暟缁�
+        char** ops;         // 鍔ㄦ�佸瓧绗︿覆鏁扮粍
+    } data;
+} Stack;
+
+// 宸茶闂妭鐐圭粨鏋勪綋
+typedef struct {
+    TreeNode* node;
+    int visited;
+} VisitedNode;
+
+// 鏍戞搷浣滃嚱鏁�
+Tree InitTree();
+TreeNode* CreateTreeNode(Place place);
+int AddChildNode(TreeNode* parent, Place place);
+TreeNode* SearchNodeByName(Tree tree, const char* name);
+void SearchNodesByType(Tree tree, const char* type, Place* result, int* count);
+void DFS_Traverse(TreeNode* node, int depth);
+void Level_Traverse(Tree tree);
+float CalculateDistance(TreeNode* a, TreeNode* b);
+void DestroyTree(Tree* tree);
+
+// 鏍堟搷浣滃嚱鏁�
+void InitStack(Stack* stack, int type);
+int PushStack(Stack* stack, void* data);
+int PopStack(Stack* stack, void* data);
+void DestroyStack(Stack* stack);
+
+// 璺緞鎼滅储鍑芥暟
+int DFS_PathSearch_WithVisited(TreeNode* start, TreeNode* end, Stack* nodeStack, Stack* pathStack, VisitedNode* visited, int maxNodes);
+int DFS_PathSearch(TreeNode* start, TreeNode* end, Stack* nodeStack, Stack* pathStack);
+
+#endif
\ No newline at end of file
diff --git "a/\346\240\221\347\273\223\346\236\204/compus_tree.c" "b/\346\240\221\347\273\223\346\236\204/compus_tree.c"
new file mode 100644
index 0000000000000000000000000000000000000000..27173b8d3b7da98019a0be294aaf3d6ed71456aa
--- /dev/null
+++ "b/\346\240\221\347\273\223\346\236\204/compus_tree.c"
@@ -0,0 +1,245 @@
+#include "campus_tree.h"
+
+// 鍒濆鍖栨爲
+Tree InitTree() {
+    Tree root = (Tree)malloc(sizeof(TreeNode));
+    if (!root) return NULL;
+    root->data.id = 0;
+    strcpy(root->data.name, "鏍″洯鎬昏");
+    root->data.x = 0.0f;
+    root->data.y = 0.0f;
+    strcpy(root->data.desc, "鏍″洯鍦扮偣鏍硅妭鐐�");
+    strcpy(root->data.openTime, "鍏ㄥぉ");
+    root->parent = NULL;
+    root->child = NULL;
+    root->sibling = NULL;
+    root->childCount = 0;
+    return root;
+}
+
+// 鍒涘缓鏍戣妭鐐�
+TreeNode* CreateTreeNode(Place place) {
+    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
+    if (!node) return NULL;
+    node->data = place;
+    node->parent = NULL;
+    node->child = NULL;
+    node->sibling = NULL;
+    node->childCount = 0;
+    return node;
+}
+
+// 涓虹埗鑺傜偣娣诲姞瀛愯妭鐐�
+int AddChildNode(TreeNode* parent, Place place) {
+    if (!parent) return -1;
+    TreeNode* newNode = CreateTreeNode(place);
+    if (!newNode) return -2;
+    newNode->parent = parent;
+
+    if (!parent->child) {
+        parent->child = newNode;
+    } else {
+        TreeNode* temp = parent->child;
+        while (temp->sibling) temp = temp->sibling;
+        temp->sibling = newNode;
+    }
+    parent->childCount++;
+    return 0;
+}
+
+// 鎸夊悕绉伴�掑綊鏌ユ壘鑺傜偣
+TreeNode* SearchNodeByName(Tree tree, const char* name) {
+    if (!tree) return NULL;
+    if (strcmp(tree->data.name, name) == 0) return tree;
+    TreeNode* find = SearchNodeByName(tree->child, name);
+    if (find) return find;
+    return SearchNodeByName(tree->sibling, name);
+}
+
+// 鎸夌被鍨嬫煡鎵炬墍鏈夎妭鐐癸紙鐩存帴妫�鏌ヨ妭鐐硅嚜韬殑desc瀛楁锛�
+void SearchNodesByType(Tree tree, const char* type, Place* result, int* count) {
+    if (!tree || !type || !result || !count) return;
+    TreeNode* queue[100];
+    int front = 0, rear = 0;
+    queue[rear++] = tree;
+
+    while (front < rear) {
+        TreeNode* temp = queue[front++];
+        // 鐩存帴妫�鏌ヨ妭鐐硅嚜韬殑绫诲瀷锛坉esc瀛楁锛�
+        if (temp->data.id > 0 && strcmp(temp->data.desc, type) == 0) {
+            result[*count] = temp->data;
+            (*count)++;
+        }
+        // 瀛愯妭鐐瑰叆闃�
+        temp = temp->child;
+        while (temp) {
+            queue[rear++] = temp;
+            temp = temp->sibling;
+        }
+    }
+}
+
+// 娣卞害浼樺厛閬嶅巻鏍�
+void DFS_Traverse(TreeNode* node, int depth) {
+    if (!node) return;
+    for (int i = 0; i < depth; i++) printf("  ");
+    printf("|-%s锛圛D锛�%d锛塡n", node->data.name, node->data.id);
+    DFS_Traverse(node->child, depth + 1);
+    DFS_Traverse(node->sibling, depth);
+}
+
+// 灞傛閬嶅巻鏍�
+void Level_Traverse(Tree tree) {
+    if (!tree) return;
+    TreeNode* queue[100];
+    int front = 0, rear = 0;
+    queue[rear++] = tree;
+
+    while (front < rear) {
+        TreeNode* temp = queue[front++];
+        printf("ID锛�%d | 鍚嶇О锛�%s | 鍧愭爣锛�(%.1f,%.1f) | 绫诲瀷锛�%s\n",
+               temp->data.id, temp->data.name, temp->data.x, temp->data.y, temp->data.desc);
+        // 瀛愯妭鐐瑰叆闃�
+        temp = temp->child;
+        while (temp) {
+            queue[rear++] = temp;
+            temp = temp->sibling;
+        }
+    }
+}
+
+// 璁＄畻涓ょ偣璺濈
+float CalculateDistance(TreeNode* a, TreeNode* b) {
+    if (!a || !b) return 0.0f;
+    float dx = a->data.x - b->data.x;
+    float dy = a->data.y - b->data.y;
+    return sqrt(dx*dx + dy*dy);
+}
+
+// 鍒濆鍖栨爤
+void InitStack(Stack* stack, int type) {
+    stack->top = -1;
+    stack->type = type;
+    if (type == 0) {
+        stack->data.nodes = (TreeNode**)malloc(100 * sizeof(TreeNode*));
+    } else {
+        stack->data.ops = (char**)malloc(100 * sizeof(char*));
+    }
+}
+
+// 鍏ユ爤
+int PushStack(Stack* stack, void* data) {
+    if (stack->top >= 99) return -1;
+    stack->top++;
+    if (stack->type == 0) {
+        stack->data.nodes[stack->top] = (TreeNode*)data;
+    } else {
+        stack->data.ops[stack->top] = strdup((char*)data);
+    }
+    return 0;
+}
+
+// 鍑烘爤
+int PopStack(Stack* stack, void* data) {
+    if (stack->top < 0) return -1;
+    if (stack->type == 0) {
+        *(TreeNode**)data = stack->data.nodes[stack->top];
+    } else {
+        *(char**)data = stack->data.ops[stack->top];
+    }
+    stack->top--;
+    return 0;
+}
+
+// 閿�姣佹爤
+void DestroyStack(Stack* stack) {
+    if (stack->type == 1) {
+        for (int i = 0; i <= stack->top; i++) {
+            free(stack->data.ops[i]);
+        }
+        free(stack->data.ops);
+    } else if (stack->type == 0) {
+        free(stack->data.nodes);
+    }
+    stack->top = -1;
+}
+
+// 甯﹀凡璁块棶鏍囪鐨凞FS璺緞鎼滅储
+int DFS_PathSearch_WithVisited(TreeNode* start, TreeNode* end, Stack* nodeStack, Stack* pathStack, VisitedNode* visited, int maxNodes) {
+    if (!start || !end) return -1;
+
+    // 妫�鏌ユ槸鍚﹀凡璁块棶
+    for (int i = 0; i < maxNodes; i++) {
+        if (visited[i].node == start && visited[i].visited) {
+            return 0;
+        }
+    }
+
+    // 鏍囪涓哄凡璁块棶
+    for (int i = 0; i < maxNodes; i++) {
+        if (visited[i].node == NULL) {
+            visited[i].node = start;
+            visited[i].visited = 1;
+            break;
+        }
+    }
+
+    PushStack(nodeStack, start);
+    PushStack(pathStack, start);
+
+    if (start == end) return 1;
+
+    // 閬嶅巻瀛愯妭鐐�
+    TreeNode* child = start->child;
+    while (child) {
+        if (DFS_PathSearch_WithVisited(child, end, nodeStack, pathStack, visited, maxNodes) == 1) {
+            return 1;
+        }
+        child = child->sibling;
+    }
+
+    // 閬嶅巻鍏勫紵鑺傜偣
+    TreeNode* sibling = start->sibling;
+    while (sibling) {
+        if (DFS_PathSearch_WithVisited(sibling, end, nodeStack, pathStack, visited, maxNodes) == 1) {
+            return 1;
+        }
+        sibling = sibling->sibling;
+    }
+
+    // 鍥炴函鐖惰妭鐐�
+    if (start->parent != NULL) {
+        if (DFS_PathSearch_WithVisited(start->parent, end, nodeStack, pathStack, visited, maxNodes) == 1) {
+            return 1;
+        }
+    }
+
+    // 鍥炴函
+    for (int i = 0; i < maxNodes; i++) {
+        if (visited[i].node == start) {
+            visited[i].visited = 0;
+            break;
+        }
+    }
+    PopStack(pathStack, &start);
+    return 0;
+}
+
+// 瀵瑰鏆撮湶鐨凞FS璺緞鎼滅储鎺ュ彛
+int DFS_PathSearch(TreeNode* start, TreeNode* end, Stack* nodeStack, Stack* pathStack) {
+    VisitedNode visited[20] = {0};
+    for (int i = 0; i < 20; i++) {
+        visited[i].node = NULL;
+        visited[i].visited = 0;
+    }
+    return DFS_PathSearch_WithVisited(start, end, nodeStack, pathStack, visited, 20);
+}
+
+// 閿�姣佹爲
+void DestroyTree(Tree* tree) {
+    if (!*tree) return;
+    DestroyTree(&((*tree)->child));
+    DestroyTree(&((*tree)->sibling));
+    free(*tree);
+    *tree = NULL;
+}
\ No newline at end of file
diff --git "a/\346\240\221\347\273\223\346\236\204/\346\240\221\347\273\223\346\236\204 main.c" "b/\346\240\221\347\273\223\346\236\204/\346\240\221\347\273\223\346\236\204 main.c"
new file mode 100644
index 0000000000000000000000000000000000000000..9b240cccb630f07bf1bca8ea384f53815fede3ea
--- /dev/null
+++ "b/\346\240\221\347\273\223\346\236\204/\346\240\221\347\273\223\346\236\204 main.c"	
@@ -0,0 +1,278 @@
+#include "campus_tree.h"
+
+// -------------------------- 鍓嶅簭閬嶅巻 --------------------------
+void PreOrder_Traverse(TreeNode* node, int depth) {
+    if (!node) return;
+    for (int i = 0; i < depth; i++) printf("  ");
+    printf("|-%s锛圛D锛�%d锛岀埗鑺傜偣锛�%s锛塡n", 
+           node->data.name, node->data.id, 
+           node->parent ? node->parent->data.name : "鏃�");
+    PreOrder_Traverse(node->child, depth + 1);
+    PreOrder_Traverse(node->sibling, depth);
+}
+
+// -------------------------- 娓呯悊杈撳叆缂撳啿鍖� --------------------------
+void clearInputBuffer() {
+    while (getchar() != '\n'); // 娓呯┖缂撳啿鍖烘畫鐣欑殑瀛楃
+}
+
+// -------------------------- 浜や簰鍑芥暟 --------------------------
+void PrintMenu() {
+    printf("\n      鏍″洯瀵兼父绯荤粺    ");
+    printf("\n======================================");
+    printf("\n1. 鏌ョ湅鏍戠粨鏋勶紙鍓嶅簭閬嶅巻锛�");
+    printf("\n2. 鏌ョ湅鎵�鏈夊湴鐐癸紙灞傛閬嶅巻锛�");
+    printf("\n3. 鎸夊悕绉版煡璇㈠湴鐐�");
+    printf("\n4. 鎸夌被鍨嬫煡璇㈠湴鐐�");
+    printf("\n5. 瀵艰埅璺緞瑙勫垝锛堟爲DFS瀹炵幇锛�");
+    printf("\n6. 鎾ら攢涓婁竴姝ユ搷浣�");
+    printf("\n7. 閫�鍑虹郴缁�");
+    printf("\n======================================");
+    printf("\n璇疯緭鍏ュ姛鑳界紪鍙凤紙1-7锛夛細");
+}
+
+void InteractiveSearchByName(Tree tree, Stack* opStack) {
+    char name[50], op[100];
+    printf("\n璇疯緭鍏ュ湴鐐瑰悕绉帮細");
+    fgets(name, 50, stdin);
+    name[strcspn(name, "\n")] = '\0';
+
+    sprintf(op, "鏌ヨ鍦扮偣锛�%s", name);
+    PushStack(opStack, op);
+
+    TreeNode* node = SearchNodeByName(tree, name);
+    if (node) {
+        printf("\n銆愭煡璇㈢粨鏋溿�慭n");
+        printf("鍚嶇О锛�%s | ID锛�%d\n", node->data.name, node->data.id);
+        printf("鍧愭爣锛�(%.1f, %.1f)\n", node->data.x, node->data.y);
+        printf("绫诲瀷锛�%s\n", node->data.desc);
+        printf("寮�鏀炬椂闂达細%s\n", node->data.openTime);
+        printf("鐖惰妭鐐癸細%s\n", node->parent->data.name);
+    } else {
+        printf("\n鏈壘鍒板湴鐐癸細%s\n", name);
+    }
+}
+
+void InteractiveSearchByType(Tree tree, Stack* opStack) {
+    char type[20], op[50];
+    printf("\n璇疯緭鍏ュ湴鐐圭被鍨嬶紙濡傛暀瀛︽ゼ銆侀鍫傦級锛�");
+    fgets(type, 20, stdin);
+    type[strcspn(type, "\n")] = '\0';
+
+    sprintf(op, "鏌ヨ绫诲瀷锛�%s", type);
+    PushStack(opStack, op);
+
+    Place result[10];
+    int count = 0;
+    SearchNodesByType(tree, type, result, &count);
+    if (count > 0) {
+        printf("\n銆愭煡璇㈢粨鏋溿�戝叡%d涓�%s锛歕n", count, type);
+        for (int i = 0; i < count; i++) {
+            printf("%d. %s | 寮�鏀炬椂闂达細%s\n",
+                   i+1, result[i].name, result[i].openTime);
+        }
+    } else {
+        printf("\n鏈壘鍒拌绫诲瀷鍦扮偣\n");
+    }
+}
+
+// 鏍慏FS璺緞鎼滅储锛堟敮鎸佹牴鑺傜偣涓浆锛屼换鎰忓湴鐐逛簰閫氾級
+int TreeDFS_PathSearch(TreeNode* start, TreeNode* end, Stack* pathStack, VisitedNode* visited, int maxNodes) {
+    if (!start || !end) return -1;
+
+    // 妫�鏌ュ凡璁块棶
+    for (int i = 0; i < maxNodes; i++) {
+        if (visited[i].node == start && visited[i].visited) return 0;
+    }
+
+    // 鏍囪璁块棶
+    for (int i = 0; i < maxNodes; i++) {
+        if (visited[i].node == NULL) {
+            visited[i].node = start;
+            visited[i].visited = 1;
+            break;
+        }
+    }
+
+    PushStack(pathStack, start);
+
+    // 鎵惧埌缁堢偣
+    if (start == end) return 1;
+
+    // 1. 閬嶅巻瀛愯妭鐐�
+    TreeNode* child = start->child;
+    while (child) {
+        if (TreeDFS_PathSearch(child, end, pathStack, visited, maxNodes) == 1) return 1;
+        child = child->sibling;
+    }
+
+    // 2. 閬嶅巻鍏勫紵鑺傜偣
+    TreeNode* sibling = start->sibling;
+    while (sibling) {
+        if (TreeDFS_PathSearch(sibling, end, pathStack, visited, maxNodes) == 1) return 1;
+        sibling = sibling->sibling;
+    }
+
+    // 3. 鍥炴函鍒扮埗鑺傜偣锛堝叧閿細閫氳繃鏍硅妭鐐逛腑杞級
+    if (start->parent != NULL) {
+        if (TreeDFS_PathSearch(start->parent, end, pathStack, visited, maxNodes) == 1) return 1;
+    }
+
+    // 鍥炴函
+    PopStack(pathStack, &start);
+    for (int i = 0; i < maxNodes; i++) {
+        if (visited[i].node == start) visited[i].visited = 0;
+    }
+    return 0;
+}
+
+void InteractiveNavigation(Tree tree, Stack* nodeStack, Stack* opStack) {
+    char startName[50], endName[50], op[200]; 
+    printf("\n璇疯緭鍏ヨ捣鐐癸細");
+    fgets(startName, 50, stdin);
+    startName[strcspn(startName, "\n")] = '\0';
+
+    printf("璇疯緭鍏ョ粓鐐癸細");
+    fgets(endName, 50, stdin);
+    endName[strcspn(endName, "\n")] = '\0';
+
+    snprintf(op, sizeof(op), "瀵艰埅锛�%s -> %s", startName, endName);
+    PushStack(opStack, op);
+
+    TreeNode* start = SearchNodeByName(tree, startName);
+    TreeNode* end = SearchNodeByName(tree, endName);
+    if (!start || !end) {
+        printf("\n璧风偣鎴栫粓鐐逛笉瀛樺湪锛乗n");
+        return;
+    }
+
+    Stack pathStack;
+    InitStack(&pathStack, 0);
+    Stack tempStack;
+    InitStack(&tempStack, 0);
+    VisitedNode visited[20] = {0};
+
+    // 璋冪敤鏍慏FS鎼滅储
+    if (TreeDFS_PathSearch(start, end, &pathStack, visited, 20) == 1) {
+        printf("\n鏈�浼樿矾寰勶紙绾爲DFS鐢熸垚锛夛細\n");
+        float totalDist = 0.0f;
+        TreeNode* prev = NULL;
+        TreeNode* node;
+        int idx = 1;
+
+        // 鍙嶈浆璺緞骞惰繃婊ゆ牴鑺傜偣
+        while (PopStack(&pathStack, &node) == 0) {
+            if (strcmp(node->data.name, "鏍″洯鎬昏") != 0) {
+                PushStack(&tempStack, node);
+            }
+        }
+
+        // 杈撳嚭璺緞
+        while (PopStack(&tempStack, &node) == 0) {
+            printf("%d. %s", idx++, node->data.name);
+            if (prev != NULL) {
+                float dist = CalculateDistance(prev, node);
+                totalDist += dist;
+                printf("锛堣窛绂诲墠涓�绔欙細%.1f绫筹級", dist);
+            }
+            printf("\n");
+            prev = node;
+        }
+
+        // 姝ヨ鏃堕棿淇濆簳1鍒嗛挓
+        float walkTime = totalDist / 80.0f;
+        walkTime = walkTime < 1.0f ? 1.0f : walkTime;
+        printf("\n鎬昏窛绂伙細%.1f绫� | 棰勪及姝ヨ鏃堕棿锛�%.0f鍒嗛挓\n", totalDist, walkTime);
+    } else {
+        printf("\n鏈壘鍒板彲琛岃矾寰勶紒\n");
+    }
+
+    DestroyStack(&pathStack);
+    DestroyStack(&tempStack);
+}
+
+// 鎾ら攢鍔熻兘瀹炵幇
+void InteractiveUndo(Stack* opStack) {
+    if (opStack->top == -1) {
+        printf("\n鏆傛棤鎿嶄綔鍙挙閿�\n");
+        return;
+    }
+    char* lastOp;
+    if (PopStack(opStack, &lastOp) == 0) {
+        printf("\n宸叉挙閿�鎿嶄綔锛�%s\n", lastOp);
+        free(lastOp);
+    } else {
+        printf("\n鎾ら攢澶辫触\n");
+    }
+}
+
+// -------------------------- 4. main鍑芥暟 --------------------------
+int main() {
+    Tree campusTree = InitTree();
+    Stack opStack;
+    InitStack(&opStack, 1);
+    Stack nodeStack;
+    InitStack(&nodeStack, 0);
+
+    // 鏍″洯鍦扮偣鏁版嵁锛坉esc瀛楁瀛樺偍绫诲瀷锛�
+    Place places[] = {
+        {1, "澶ф垚妤糄", 10.0f, 20.0f, "鏁欏妤�", "6:00-23:00"},
+        {2, "闀块妤糃", 15.0f, 25.0f, "鏁欏妤�", "6:00-23:00"},
+        {3, "涓�椋熷爞", 5.0f, 30.0f, "椋熷爞", "5:00-21:00"},
+        {4, "浜旈鍫�", 20.0f, 10.0f, "椋熷爞", "5:00-21:00"},
+        {5, "鍥句功棣�", 12.0f, 15.0f, "鍥句功棣�", "6:00-23:00"},
+        {6, "鏍￠棬", 0.0f, 0.0f, "鍏朵粬", "鍏ㄥぉ"},
+        {7, "鎿嶅満", 18.0f, 35.0f, "鍏朵粬", "6:00-22:00"},
+        {8, "鏌氬瓙鏋�", 4.0f, 32.0f, "椋熷爞", "5:00-21:00"},
+        {9, "灏忓悆琛�", 3.0f, 5.0f, "鍏朵粬", "鍏ㄥぉ"},
+        {10, "瀹胯垗1鍖�", 65.0f, 35.0f, "鍏朵粬", "6:00-23:00"}
+    };
+
+    // 鏍戠粨鏋勶細鎵�鏈夊湴鐐逛綔涓烘牴鑺傜偣鐨勫瓙鑺傜偣锛堝厔寮熷叧绯伙級
+    int placeCount = sizeof(places) / sizeof(Place);
+    for (int i = 0; i < placeCount; i++) {
+        AddChildNode(campusTree, places[i]);
+    }
+
+    // 涓诲惊鐜�
+    int choice;
+    while (1) {
+        PrintMenu();
+        while (scanf("%d", &choice) != 1) {
+            clearInputBuffer();
+            printf("\n璇疯緭鍏ユ湁鏁堢殑鏁板瓧缂栧彿锛�1-7锛夛細");
+        }
+        clearInputBuffer();
+
+        switch (choice) {
+            case 1:
+                printf("\n銆愭爲缁撴瀯锛堝墠搴忛亶鍘嗭級銆慭n");
+                PreOrder_Traverse(campusTree, 0);
+                break;
+            case 2:
+                printf("\n銆愭墍鏈夊湴鐐癸紙灞傛閬嶅巻锛夈�慭n");
+                Level_Traverse(campusTree);
+                break;
+            case 3:
+                InteractiveSearchByName(campusTree, &opStack);
+                break;
+            case 4:
+                InteractiveSearchByType(campusTree, &opStack);
+                break;
+            case 5:
+                InteractiveNavigation(campusTree, &nodeStack, &opStack);
+                break;
+            case 6:
+                InteractiveUndo(&opStack);
+                break;
+            case 7:
+                printf("\n鎰熻阿浣跨敤锛屽啀瑙侊紒\n");
+                DestroyTree(&campusTree);
+                DestroyStack(&opStack);
+                DestroyStack(&nodeStack);
+                return 0;
+            default:
+                printf("\n杈撳叆閿欒锛岃閲嶆柊閫夋嫨锛乗n");
+        }
+    }
+}
\ No newline at end of file
diff --git "a/\347\272\277\346\200\247\350\241\250/.keep" "b/\347\272\277\346\200\247\350\241\250/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/\347\272\277\346\200\247\350\241\250/\344\273\243\347\240\201" "b/\347\272\277\346\200\247\350\241\250/\344\273\243\347\240\201"
new file mode 100644
index 0000000000000000000000000000000000000000..6733ac28f41461d3a40549e48bb4b3c23f418fba
--- /dev/null
+++ "b/\347\272\277\346\200\247\350\241\250/\344\273\243\347\240\201"
@@ -0,0 +1,429 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+// 甯搁噺瀹氫箟
+#define MAX_PLACE 50       // 鏈�澶у湴鐐规暟閲�
+#define MAX_HISTORY 10     // 鏈�澶у巻鍙茶褰曟暟
+#define MAX_OPERATE 20     // 鏈�澶ф搷浣滆褰曟暟
+#define MAX_PATH 30        // 鏈�澶ц矾寰勯暱搴�
+#define WALK_SPEED 50      // 姝ヨ閫熷害锛�50绫�/鍒嗛挓锛堢敤浜庝及绠楁椂闂达級
+
+// 1. 鏁版嵁缁撴瀯瀹氫箟
+// 鍦扮偣缁撴瀯浣擄紙椤剁偣锛�
+typedef struct {
+    int id;               // 鍦扮偣ID
+    char name[50];        // 鍦扮偣鍚嶇О
+    int x;                // X鍧愭爣
+    int y;                // Y鍧愭爣
+    char desc[200];       // 鍔熻兘鎻忚堪
+    char openTime[50];    // 寮�鏀炬椂闂�
+} Place;
+
+// 椤哄簭琛紙瀛樺偍鍦扮偣搴撱�佸巻鍙茶褰曪級
+// 鍦扮偣椤哄簭琛�
+typedef struct {
+    Place data[MAX_PLACE];
+    int length;
+} PlaceList;
+
+// 瀵艰埅璁板綍缁撴瀯浣�
+typedef struct {
+    char time[20];        // 鏌ヨ鏃堕棿
+    char start[50];       // 璧风偣
+    char end[50];         // 缁堢偣
+    char path[MAX_PATH*50];// 璺緞淇℃伅
+} NavHistory;
+
+// 鍘嗗彶璁板綍椤哄簭琛�
+typedef struct {
+    NavHistory data[MAX_HISTORY];
+    int length;
+} HistoryList;
+
+// 椤哄簭鏍堬紙鐢ㄤ簬DFS璺緞鎼滅储銆佹搷浣滄挙閿�锛�
+// 璺緞鏍堬紙瀛樺偍鍦扮偣ID锛�
+typedef struct {
+    int data[MAX_PATH];
+    int top;
+} PathStack;
+
+// 鎿嶄綔鏍堬紙瀛樺偍鐢ㄦ埛鎿嶄綔鎻忚堪锛�
+typedef struct {
+    char data[MAX_OPERATE][100];
+    int top;
+} OperateStack;
+
+// 鍥剧殑閭绘帴鐭╅樀锛堝瓨鍌ㄥ湴鐐归棿璺緞锛岃竟鏉冮噸涓鸿窛绂伙級
+int graph[MAX_PLACE][MAX_PLACE];
+int graphSize;            // 鍥句腑椤剁偣鏁伴噺锛堝嵆鍦扮偣鏁伴噺锛�
+
+// 鍏ㄥ眬鍙橀噺锛堢畝鍖栬皟鐢紝瀹為檯椤圭洰鍙皝瑁呬负缁撴瀯浣擄級
+PlaceList placeList;      // 鏍″洯鍦扮偣搴�
+HistoryList historyList;  // 瀵艰埅鍘嗗彶璁板綍
+PathStack pathStack;      // DFS璺緞鏍�
+OperateStack operateStack;// 鎿嶄綔鎾ら攢鏍�
+char bestPath[MAX_PATH*50];// 鏈�浼樿矾寰勫瓨鍌�
+int minDistance = 0x7fffffff; // 鏈�鐭窛绂伙紝鍒濆涓烘瀬澶у��
+
+// 2. 鍒濆鍖栧嚱鏁�
+// 鍒濆鍖栧湴鐐归『搴忚〃
+void initPlaceList() {
+    placeList.length = 0;
+    memset(placeList.data, 0, sizeof(placeList.data));
+}
+
+// 鍒濆鍖栧巻鍙茶褰曢『搴忚〃
+void initHistoryList() {
+    historyList.length = 0;
+    memset(historyList.data, 0, sizeof(historyList.data));
+}
+
+// 鍒濆鍖栬矾寰勬爤
+void initPathStack() {
+    pathStack.top = -1;
+}
+
+// 鍒濆鍖栨搷浣滄爤
+void initOperateStack() {
+    operateStack.top = -1;
+}
+
+// 鍒濆鍖栭偦鎺ョ煩闃�
+void initGraph() {
+    graphSize = 0;
+    for (int i = 0; i < MAX_PLACE; i++) {
+        for (int j = 0; j < MAX_PLACE; j++) {
+            graph[i][j] = (i == j) ? 0 : 0x7fffffff; // 鍒濆鏃犺繛鎺ヤ负鏋佸ぇ鍊�
+        }
+    }
+}
+
+// 3. 绾挎�ц〃鐩稿叧鎿嶄綔锛堝湴鐐圭鐞嗐�佸巻鍙茶褰曪級
+// 娣诲姞鍦扮偣鍒伴『搴忚〃
+void addPlace(Place p) {
+    if (placeList.length >= MAX_PLACE) {
+        printf("鍦扮偣搴撳凡婊★紝鏃犳硶娣诲姞锛乗n");
+        return;
+    }
+    placeList.data[placeList.length++] = p;
+    graphSize++; // 鍥鹃《鐐规暟澧炲姞
+    printf("娣诲姞鍦扮偣銆�%s銆戞垚鍔燂紒\n", p.name);
+    // 璁板綍鎿嶄綔
+    char op[100];
+    sprintf(op, "娣诲姞鍦扮偣锛�%s", p.name);
+    operateStack.top++;
+    strcpy(operateStack.data[operateStack.top], op);
+}
+
+// 鏌ヨ鍦扮偣锛堟寜鍚嶇О锛�
+Place* queryPlaceByName(char* name) {
+    for (int i = 0; i < placeList.length; i++) {
+        if (strcmp(placeList.data[i].name, name) == 0) {
+            return &placeList.data[i];
+        }
+    }
+    return NULL; // 鏈壘鍒�
+}
+
+// 娣诲姞瀵艰埅璁板綍鍒板巻鍙茶〃锛堟寜鏃堕棿鍊掑簭锛�
+void addHistory(char* start, char* end, char* path) {
+    NavHistory h;
+    // 鑾峰彇褰撳墠鏃堕棿
+    time_t now = time(NULL);
+    strftime(h.time, sizeof(h.time), "%Y-%m-%d %H:%M", localtime(&now));
+    strcpy(h.start, start);
+    strcpy(h.end, end);
+    strcpy(h.path, path);
+    
+    // 鍘嗗彶璁板綍婊″垯绉婚櫎鏈�鏃х殑锛堟渶鍚庝竴涓級
+    if (historyList.length >= MAX_HISTORY) {
+        for (int i = MAX_HISTORY-1; i > 0; i--) {
+            historyList.data[i] = historyList.data[i-1];
+        }
+        historyList.data[0] = h;
+    } else {
+        // 鏂拌褰曟彃鍏ュご閮紙鍊掑簭锛�
+        for (int i = historyList.length; i > 0; i--) {
+            historyList.data[i] = historyList.data[i-1];
+        }
+        historyList.data[0] = h;
+        historyList.length++;
+    }
+    printf("鍘嗗彶璁板綍宸蹭繚瀛橈紒\n");
+}
+
+// 鏄剧ず鎵�鏈夊巻鍙茶褰�
+void showHistory() {
+    if (historyList.length == 0) {
+        printf("鏆傛棤瀵艰埅鍘嗗彶璁板綍锛乗n");
+        return;
+    }
+    printf("\n===== 瀵艰埅鍘嗗彶璁板綍 =====\n");
+    for (int i = 0; i < historyList.length; i++) {
+        printf("%d. 鏃堕棿锛�%s\n   璧风偣锛�%s -> 缁堢偣锛�%s\n   璺緞锛�%s\n",
+               i+1, historyList.data[i].time,
+               historyList.data[i].start,
+               historyList.data[i].end,
+               historyList.data[i].path);
+    }
+    printf("========================\n");
+}
+
+// 4. 鏍堢浉鍏虫搷浣滐紙DFS璺緞銆佹搷浣滄挙閿�锛�
+// 璺緞鏍堝帇鏍�
+void pushPath(int placeId) {
+    if (pathStack.top >= MAX_PATH-1) {
+        printf("璺緞杩囬暱锛屾棤娉曠户缁帰绱紒\n");
+        return;
+    }
+    pathStack.data[++pathStack.top] = placeId;
+}
+
+// 璺緞鏍堝嚭鏍�
+int popPath() {
+    if (pathStack.top == -1) {
+        printf("璺緞鏍堜负绌猴紒\n");
+        return -1;
+    }
+    return pathStack.data[pathStack.top--];
+}
+
+// 鎿嶄綔鏍堝帇鏍�
+void pushOperate(char* op) {
+    if (operateStack.top >= MAX_OPERATE-1) {
+        printf("鎿嶄綔璁板綍宸叉弧锛屾棤娉曡褰曪紒\n");
+        return;
+    }
+    operateStack.top++;
+    strcpy(operateStack.data[operateStack.top], op);
+}
+
+// 鎿嶄綔鎾ら攢锛堝嚭鏍堝苟鎭㈠鐘舵�侊級
+void undoOperate() {
+    if (operateStack.top == -1) {
+        printf("鏃犳搷浣滃彲鎾ら攢锛乗n");
+        return;
+    }
+    printf("鎾ら攢鎿嶄綔锛�%s\n", operateStack.data[operateStack.top]);
+    operateStack.top--;
+    // 姝ゅ绠�鍖栫姸鎬佹仮澶嶏紝瀹為檯闇�鏍规嵁鎿嶄綔绫诲瀷澶勭悊锛堝鎾ら攢娣诲姞鍦扮偣鍒欏垹闄ゆ渶鍚庝竴涓級
+    if (strstr(operateStack.data[operateStack.top+1], "娣诲姞鍦扮偣") != NULL) {
+        placeList.length--;
+        graphSize--;
+    }
+}
+
+// 5. DFS璺緞鎼滅储锛堥�掑綊瀹炵幇锛�
+// 鍙傛暟锛氬綋鍓嶅湴鐐笽D銆佺粓鐐笽D銆佸凡璧拌窛绂汇�佽闂爣璁�
+void dfs(int currentId, int endId, int distance, int visited[]) {
+    // 鏍囪褰撳墠鍦扮偣宸茶闂�
+    visited[currentId] = 1;
+    // 灏嗗綋鍓嶅湴鐐瑰帇鏍�
+    pushPath(currentId);
+    
+    // 鍒拌揪缁堢偣锛屾洿鏂版渶鐭矾寰�
+    if (currentId == endId) {
+        if (distance < minDistance) {
+            minDistance = distance;
+            // 娓呯┖鏈�浼樿矾寰�
+            memset(bestPath, 0, sizeof(bestPath));
+            // 灏嗘爤涓矾寰勮浆涓哄瓧绗︿覆
+            for (int i = 0; i <= pathStack.top; i++) {
+                strcat(bestPath, placeList.data[pathStack.data[i]].name);
+                if (i != pathStack.top) {
+                    strcat(bestPath, " -> ");
+                }
+            }
+        }
+        // 鍥炴函锛氬嚭鏍堝苟鍙栨秷鏍囪
+        popPath();
+        visited[currentId] = 0;
+        return;
+    }
+    
+    // 閬嶅巻鎵�鏈夌浉閭诲湴鐐�
+    for (int i = 0; i < graphSize; i++) {
+        // 鑻ユ湭璁块棶涓旀湁璺緞锛堣窛绂讳笉涓烘瀬澶у�硷級
+        if (visited[i] == 0 && graph[currentId][i] != 0x7fffffff) {
+            dfs(i, endId, distance + graph[currentId][i], visited);
+        }
+    }
+    
+    // 鍥炴函锛氬嚭鏍堝苟鍙栨秷鏍囪
+    popPath();
+    visited[currentId] = 0;
+}
+
+// 璁＄畻涓ょ偣闂寸洿绾胯窛绂伙紙浣滀负杈规潈閲嶅垵濮嬪寲绀轰緥锛�
+int calcDistance(Place p1, Place p2) {
+    // 绠�鍖栦负鏁存暟璺濈锛堝疄闄呭彲鎸夊嬀鑲″畾鐞嗚绠楃簿纭�硷級
+    return abs(p1.x - p2.x) + abs(p1.y - p2.y);
+}
+
+// 鍒濆鍖栧浘鐨勮竟锛堟牴鎹湴鐐瑰潗鏍囪绠楄窛绂伙級
+void initGraphEdges() {
+    for (int i = 0; i < placeList.length; i++) {
+        for (int j = 0; j < placeList.length; j++) {
+            if (i != j) {
+                graph[i][j] = calcDistance(placeList.data[i], placeList.data[j]);
+            }
+        }
+    }
+}
+
+// 瀵艰埅鍔熻兘锛氳緭鍏ヨ捣鐐圭粓鐐癸紝鐢熸垚鏈�鐭矾寰�
+void navigate(char* startName, char* endName) {
+    // 鏌ユ壘璧风偣鍜岀粓鐐�
+    Place* start = queryPlaceByName(startName);
+    Place* end = queryPlaceByName(endName);
+    if (start == NULL || end == NULL) {
+        printf("璧风偣鎴栫粓鐐逛笉瀛樺湪锛乗n");
+        return;
+    }
+    if (start == end) {
+        printf("璧风偣鍜岀粓鐐圭浉鍚岋紝鏃犻渶瀵艰埅锛乗n");
+        return;
+    }
+    
+    // 鍒濆鍖朌FS鐩稿叧鍙傛暟
+    initPathStack();
+    minDistance = 0x7fffffff;
+    memset(bestPath, 0, sizeof(bestPath));
+    int visited[MAX_PLACE] = {0};
+    
+    // 鎵цDFS鎼滅储鏈�鐭矾寰�
+    dfs(start->id, end->id, 0, visited);
+    
+    if (minDistance == 0x7fffffff) {
+        printf("鏃犳硶鎵惧埌浠庛��%s銆戝埌銆�%s銆戠殑璺緞锛乗n", startName, endName);
+        return;
+    }
+    
+    // 璁＄畻棰勪及鏃堕棿
+    int time = minDistance / WALK_SPEED;
+    if (minDistance % WALK_SPEED != 0) time++;
+    
+    // 鏄剧ず缁撴灉
+    printf("\n===== 瀵艰埅缁撴灉 =====\n");
+    printf("璧风偣锛�%s\n缁堢偣锛�%s\n", startName, endName);
+    printf("鏈�鐭矾寰勶細%s\n", bestPath);
+    printf("鎬昏窛绂伙細%d绫砛n", minDistance);
+    printf("棰勪及姝ヨ鏃堕棿锛�%d鍒嗛挓\n", time);
+    printf("=====================\n");
+    
+    // 淇濆瓨鍒板巻鍙茶褰�
+    addHistory(startName, endName, bestPath);
+    
+    // 璁板綍鎿嶄綔
+    char op[100];
+    sprintf(op, "瀵艰埅锛�%s -> %s", startName, endName);
+    pushOperate(op);
+}
+
+// 6. 娴嬭瘯鏁版嵁涓庝富鍑芥暟
+// 鍔犺浇娴嬭瘯鍦扮偣鏁版嵁
+void loadTestData() {
+    // 鍒濆鍖栧湴鐐�
+    Place p1 = {0, "鏍￠棬", 0, 0, "鏍″洯涓诲叆鍙�", "00:00-24:00"};
+    Place p2 = {1, "鏁欏妤糀", 100, 200, "涓昏鏁欏鍖�", "08:00-22:00"};
+    Place p3 = {2, "鍥句功棣�", 300, 200, "鍥句功鍊熼槄涓庤嚜涔�", "08:30-21:30"};
+    Place p4 = {3, "绗竴椋熷爞", 200, 400, "鎻愪緵涓夐", "06:30-21:00"};
+    Place p5 = {4, "鎿嶅満", 100, 500, "浣撹偛娲诲姩鍦哄湴", "06:00-23:00"};
+    
+    // 娣诲姞鍒板湴鐐瑰簱
+    addPlace(p1);
+    addPlace(p2);
+    addPlace(p3);
+    addPlace(p4);
+    addPlace(p5);
+    
+    // 鍒濆鍖栧浘杈癸紙璺濈锛�
+    initGraphEdges();
+}
+
+// 涓昏彍鍗�
+void showMenu() {
+    printf("\n===== 鏍″洯瀵兼父绯荤粺 =====\n");
+    printf("1. 鏌ョ湅鍦扮偣淇℃伅\n");
+    printf("2. 瀵艰埅璺嚎鏌ヨ\n");
+    printf("3. 鏌ョ湅鍘嗗彶璁板綍\n");
+    printf("4. 鎾ら攢涓婁竴姝ユ搷浣淺n");
+    printf("5. 閫�鍑虹郴缁焅n");
+    printf("========================\n");
+    printf("璇疯緭鍏ユ搷浣滅紪鍙凤細");
+}
+
+int main() {
+    // 鍒濆鍖栨墍鏈夋暟鎹粨鏋�
+    initPlaceList();
+    initHistoryList();
+    initPathStack();
+    initOperateStack();
+    initGraph();
+    
+    // 鍔犺浇娴嬭瘯鏁版嵁锛堝疄闄呭彲鎵嬪姩娣诲姞锛�
+    loadTestData();
+    printf("绯荤粺鍒濆鍖栧畬鎴愶紝娆㈣繋浣跨敤鏍″洯瀵兼父绯荤粺锛乗n");
+    
+    int choice;
+    char name[50], start[50], end[50];
+    Place* p;
+    
+    while (1) {
+        showMenu();
+        scanf("%d", &choice);
+        getchar(); // 鍚告敹鎹㈣绗�
+        
+        switch (choice) {
+            case 1:
+                // 鏌ョ湅鍦扮偣淇℃伅
+                printf("璇疯緭鍏ヨ鏌ヨ鐨勫湴鐐瑰悕绉帮細");
+                fgets(name, sizeof(name), stdin);
+                name[strlen(name)-1] = '\0'; // 鍘婚櫎鎹㈣绗�
+                p = queryPlaceByName(name);
+                if (p != NULL) {
+                    printf("\n===== 鍦扮偣璇︽儏 =====\n");
+                    printf("ID锛�%d\n鍚嶇О锛�%s\n鍧愭爣锛�(%d,%d)\n鍔熻兘锛�%s\n寮�鏀炬椂闂达細%s\n",
+                           p->id, p->name, p->x, p->y, p->desc, p->openTime);
+                    printf("=====================\n");
+                } else {
+                    printf("鏈壘鍒拌鍦扮偣锛乗n");
+                }
+                break;
+                
+            case 2:
+                // 瀵艰埅璺嚎鏌ヨ
+                printf("璇疯緭鍏ヨ捣鐐癸細");
+                fgets(start, sizeof(start), stdin);
+                start[strlen(start)-1] = '\0';
+                printf("璇疯緭鍏ョ粓鐐癸細");
+                fgets(end, sizeof(end), stdin);
+                end[strlen(end)-1] = '\0';
+                navigate(start, end);
+                break;
+                
+            case 3:
+                // 鏌ョ湅鍘嗗彶璁板綍
+                showHistory();
+                break;
+                
+            case 4:
+                // 鎾ら攢涓婁竴姝ユ搷浣�
+                undoOperate();
+                break;
+                
+            case 5:
+                // 閫�鍑虹郴缁�
+                printf("鎰熻阿浣跨敤锛屽啀瑙侊紒\n");
+                exit(0);
+                
+            default:
+                printf("杈撳叆閿欒锛岃閲嶆柊閫夋嫨锛乗n");
+                break;
+        }
+    }
+    
+    return 0;
+}
\ No newline at end of file
diff --git "a/\351\241\271\347\233\256\346\226\207\346\241\243/.keep" "b/\351\241\271\347\233\256\346\226\207\346\241\243/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/\351\241\271\347\233\256\346\226\207\346\241\243/24\350\256\241\347\256\227\346\234\272\346\210\220\345\221\230\350\247\222\350\211\262.docx" "b/\351\241\271\347\233\256\346\226\207\346\241\243/24\350\256\241\347\256\227\346\234\272\346\210\220\345\221\230\350\247\222\350\211\262.docx"
new file mode 100644
index 0000000000000000000000000000000000000000..e84a0d8c2835a2d1af6a2099cb749120a62b21da
Binary files /dev/null and "b/\351\241\271\347\233\256\346\226\207\346\241\243/24\350\256\241\347\256\227\346\234\272\346\210\220\345\221\230\350\247\222\350\211\262.docx" differ
diff --git "a/\351\241\271\347\233\256\346\226\207\346\241\243/\351\241\271\347\233\256\344\271\246" "b/\351\241\271\347\233\256\346\226\207\346\241\243/\351\241\271\347\233\256\344\271\246"
new file mode 100644
index 0000000000000000000000000000000000000000..6dfebfc11bd67bd17a87dd3d29770d1e3a60e339
--- /dev/null
+++ "b/\351\241\271\347\233\256\346\226\207\346\241\243/\351\241\271\347\233\256\344\271\246"
@@ -0,0 +1,85 @@
+鏍″洯瀵兼父绯荤粺椤圭洰涔�
+ 
+涓�銆侀」鐩儗鏅笌鐩爣
+ 
+椤圭洰鑳屾櫙
+ 
+褰撳墠鏍″洯闈㈢Н鎵╁ぇ銆佸缓绛戝垎甯冨鏉傦紝鏂扮敓鎶ュ埌銆佽瀹㈡潵璁挎椂鏄撹糠澶辨柟鍚戯紝浼犵粺绾歌川鍦板浘鏇存柊鎱€�佹寚寮曚笉鐩磋銆傛湰绯荤粺缁撳悎鏁版嵁缁撴瀯鐭ヨ瘑锛屽紑鍙戣交閲忓寲鏍″洯瀵兼父宸ュ叿锛岃В鍐虫牎鍥鑸棝鐐广��
+ 
+椤圭洰鐩爣
+ 
+1. 瀹炵幇鏍″洯鏍稿績鍦扮偣锛堟暀瀛︽ゼ銆侀鍫傘�佸浘涔﹂绛夛級淇℃伅鐨勫瓨鍌ㄤ笌鏌ヨ銆�
+2. 鏀寔鐢ㄦ埛杈撳叆璧风偣鍜岀粓鐐癸紝蹇�熺敓鎴愭渶浼樻琛岃矾绾裤��
+3. 鏍稿績杩愮敤绾挎�ц〃涓庢爤涓ょ鏁版嵁缁撴瀯锛屼繚闅滃姛鑳借惤鍦颁笌杩愯鏁堢巼銆�
+ 
+浜屻�佹牳蹇冨姛鑳借璁�
+ 
+1. 鍦扮偣淇℃伅绠＄悊锛氬瓨鍌ㄥ湴鐐瑰悕绉般�佷綅缃潗鏍囥�佸姛鑳戒粙缁嶃�佸紑鏀炬椂闂寸瓑淇℃伅锛屾敮鎸佹柊澧炪�佷慨鏀广�佹煡璇㈡搷浣溿��
+2. 璺緞瀵艰埅锛氱敤鎴烽�夋嫨璧风偣鍜岀粓鐐瑰悗锛岀郴缁熻绠楀苟灞曠ず鏈�鐭矾寰勶紝鏍囨敞閫旂粡鍦扮偣鍙婇浼版琛屾椂闂淬��
+3. 鍘嗗彶璁板綍绠＄悊锛氫繚瀛樼敤鎴疯繎10娆℃煡璇㈢殑璺嚎璁板綍锛屾敮鎸佹煡鐪嬩笌鍐嶆瀵艰埅銆�
+4. 鎿嶄綔鎾ら攢锛氱敤鎴疯閫夊湴鐐规垨鍙戣捣閿欒鏌ヨ鏃讹紝鍙挙閿�涓婁竴姝ユ搷浣滐紝鍥炲綊涔嬪墠鐘舵�併��
+ 
+涓夈�佹暟鎹粨鏋勫簲鐢ㄨ璁�
+ 
+1. 绾挎�ц〃锛堥『搴忚〃锛�
+ 
+- 搴旂敤鍦烘櫙锛氭牎鍥湴鐐逛俊鎭簱瀛樺偍銆佺敤鎴峰鑸巻鍙茶褰曞瓨鍌ㄣ��
+- 璁捐閫昏緫锛�
+- 瀹氫箟鈥滃湴鐐光�濇暟鎹厓绱狅紝鍖呭惈 鍦扮偣ID銆佸悕绉般�佸潗鏍嘪銆佸潗鏍嘫銆佸姛鑳芥弿杩� 5涓睘鎬э紝鐢ㄩ『搴忚〃瀛樺偍鎵�鏈夊湴鐐逛俊鎭�傞『搴忚〃鏀寔闅忔満璁块棶锛岀敤鎴锋煡璇⑩�滃浘涔﹂鈥濇椂锛屽彲閫氳繃閬嶅巻椤哄簭琛ㄥ揩閫熷尮閰嶅搴斿厓绱狅紝鑾峰彇璇︾粏淇℃伅銆�
+- 鐢ㄩ『搴忚〃瀛樺偍鐢ㄦ埛鍘嗗彶璁板綍锛屾瘡涓褰曞寘鍚� 鏌ヨ鏃堕棿銆佽捣鐐广�佺粓鐐广�佽矾寰� 锛屾寜鏌ヨ鏃堕棿鍊掑簭鎺掑垪锛岀敤鎴风偣鍑烩�滃巻鍙茶褰曗�濆嵆鍙洿鎺ヨ皟鍙栵紝鏃犻渶閲嶅璁＄畻璺緞銆�
+ 
+2. 鏍堬紙椤哄簭鏍堬級
+ 
+- 搴旂敤鍦烘櫙锛氳矾寰勬悳绱㈢殑娣卞害浼樺厛閬嶅巻锛圖FS锛夈�佺敤鎴锋搷浣滄挙閿�銆�
+- 璁捐閫昏緫锛�
+- 璺緞鎼滅储锛氬皢鏍″洯鍦板浘鎶借薄涓衡�滃湴鐐癸紙椤剁偣锛�-璺緞锛堣竟锛夆�濈殑鍥剧粨鏋勶紝鐢―FS閬嶅巻鎵炬渶鐭矾寰勩�傛瘡璁块棶涓�涓湴鐐癸紙濡備粠鈥滄牎闂ㄢ�濆埌鈥滄暀瀛︽ゼA鈥濓級锛屽氨灏嗚鍦扮偣鍘嬪叆鏍堬紱鑻ュ悗缁矾绾夸笉閫氾紙濡傗�滄暀瀛︽ゼA鈥濆埌鈥滃浘涔﹂鈥濇棤鐩磋揪璺級锛屽垯浠庢爤椤跺脊鍑衡�滄暀瀛︽ゼA鈥濓紝鍥炴函鍒颁笂涓�鍦扮偣鈥滄牎闂ㄢ�濓紝閲嶆柊鎺㈢储鍏朵粬璺嚎锛岀洿鑷虫壘鍒扮粓鐐广��
+- 鎿嶄綔鎾ら攢锛氱敤鏍堝瓨鍌ㄧ敤鎴锋瘡涓�姝ユ搷浣滐紙濡傗�滈�夋嫨璧风偣锛氭牎闂ㄢ�濃�滈�夋嫨缁堢偣锛氬浘涔﹂鈥濓級銆傜敤鎴风偣鍑烩�滄挙閿�鈥濇椂锛屽脊鍑烘爤椤舵搷浣滆褰曪紝绯荤粺鎭㈠鍒颁笂涓�姝ョ姸鎬侊紙濡傛挙閿�鈥滈�夋嫨缁堢偣鈥濓紝鍥炲埌鈥滃緟閫夌粓鐐光�濈晫闈級銆�
+ 
+鍥涖�侀鏈熸垚鏋�
+ 
+1. 鍙繍琛岀殑鏍″洯瀵兼父绯荤粺锛堟敮鎸佸湴鐐规煡璇€�佽矾寰勫鑸�佸巻鍙茶褰曘�佹搷浣滄挙閿�4澶у姛鑳斤級銆�
+2. 瀹屾暣鏂囨。锛氬惈闇�姹傚垎鏋愩�佹暟鎹粨鏋勮璁″浘銆佹牳蹇冧唬鐮侊紙闄勬敞閲婏級銆佹祴璇曟姤鍛娿��
+3. 婕旂ずDemo锛氳兘鐩磋灞曠ず鈥滅嚎鎬ц〃鏌ュ湴鐐光�濃�滄爤瀹炵幇DFS璺緞鈥濈殑杩囩▼锛岀鍚堟暟鎹粨鏋勮绋嬭姹傘��
+
+棣欐ⅷ: 10-23 14:19:41
+#include <stdio.h>
+#include <string.h>
+
+// 鍒ゆ柇瀛楃涓叉槸鍚︿负鍥炴枃
+int HuiWen(char s[]) {
+    int len = strlen(s);
+    for (int i = 0; i < len / 2; i++) {
+        if (s[i] != s[len - 1 - i]) {
+            return 0; // 涓嶆槸鍥炴枃
+        }
+    }
+    return 1; // 鏄洖鏂�
+}
+
+int main() {
+    char s1[100], s2[100];
+    int n1, n2;
+
+    // 杈撳叆涓や釜瀛楃涓�
+    gets(s1);
+    gets(s2);
+
+    // 璁＄畻瀛楃涓查暱搴︼紙杩欓噷涔熷彲浠ョ敤strlen锛屼唬鐮佷腑鍐欐硶鍙紭鍖栵紝姝ゅ鎸夐�昏緫瀹炵幇锛�
+    n1 = strlen(s1);
+    n2 = strlen(s2);
+
+    // 鍒ゆ柇骞惰緭鍑虹粨鏋�
+    if (HuiWen(s1)) {
+        printf("%s鏄洖鏂囷紒\n", s1);
+    } else {
+        printf("%s涓嶆槸鍥炴枃锛乗n", s1);
+    }
+
+    if (HuiWen(s2)) {
+        printf("%s鏄洖鏂囷紒\n", s2);
+    } else {
+        printf("%s涓嶆槸鍥炴枃锛乗n", s2);
+    }
+
+    return 0;
+}
\ No newline at end of file