C语言程序设计实训：基于二叉树的学生信息管理系统

最新推荐文章于 2024-10-07 11:28:33 发布
最新推荐文章于 2024-10-07 11:28:33 发布
阅读量163 收藏
点赞数 1
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ichont/article/details/140908666
版权

 

    1. main函数：以菜单形式将各项功能提供给用户，根据用户的

选择，调用相应的函数。

    1. 建立TreeNode* readStudentsFromFile函数，返回二叉树的根节点，从文件中输入学生信息,中序遍历输出学生信息。
    2. 建立compareStudent函数，按照平均成绩升序排序。
    3. 按照某门课成绩升序排序。
    4. 查找平均分最大最小。
    5. 查找某门课成绩最大最小。
    6. 建立TreeNode* modifyStudentScore函数，返回二叉树的根节点，实现修改学生成绩的操作。
    7. 建立exportStudentInfoToFile函数，保存学生数据到文件。
    8. 建立TreeNode* deleteNode函数，返回二叉树的根节点，删除学生数据。

 

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

// 学生信息结构体
struct Student {
    char num[15];     // 学号
    char name[15];    // 姓名
    char major[10];   // 专业（computer, software, network）
    int classNo;      // 班级（1-2）
    int score[3];     // 3门课的成绩（0-2）
};

// 二叉树结构体节点定义
struct TreeNode {
    struct Student data;      // 数据域，存储学生信息
    struct TreeNode *left;    // 左子树指针
    struct TreeNode *right;   // 右子树指针
};

// 插入学生信息到二叉树
struct TreeNode* insertStudent(struct TreeNode* root, struct Student student) {
    // 如果根为空，创建新节点作为根
    if (root == NULL) {
        struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
        newNode->data = student;
        newNode->left = NULL;
        newNode->right = NULL;
        return newNode;
    }

    // 根据学号比较决定插入左子树或右子树
    if (strcmp(student.num, root->data.num) < 0) {
        root->left = insertStudent(root->left, student);
    } else {
        root->right = insertStudent(root->right, student);
    }

    return root;
}

// 从文件读取学生信息并插入到二叉树
struct TreeNode* readStudentsFromFile(struct TreeNode* root, const char* filename) {
    FILE *fp;
    fp = fopen(filename, "r");
    if (fp == NULL) {
        perror("Error opening file");
        return root;
    }

    // 读取文件中的每一行，解析学生信息并插入二叉树
    char line[100];
    while (fgets(line, sizeof(line), fp)) {
        struct Student student;
        sscanf(line, "%s %s %s %d %d %d %d", student.num, student.name, student.major,
               &student.classNo, &student.score[0], &student.score[1], &student.score[2]);
        root = insertStudent(root, student);
    }

    fclose(fp);
    return root;
}

// 中序遍历二叉树（用于测试）,二叉树是一条线
void inorderTraversal(struct TreeNode* root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("学号：%s, 姓名：%s, 专业：%s, 班级：%d, 成绩：%d, %d, %d\n",
               root->data.num, root->data.name, root->data.major,
               root->data.classNo, root->data.score[0], root->data.score[1], root->data.score[2]);
        inorderTraversal(root->right);
    }
}

// 计算学生的平均成绩
double calculateAverageScore(struct Student student) {
    double sum = 0.0;
    for (int i = 0; i < 3; ++i) {
        sum += student.score[i];
    }
    return sum / 3.0;
}

// 中序遍历二叉树，将学生信息节点按照平均成绩存入数组
void inorderTraversal(struct TreeNode *root, struct Student *sortedStudents, int *index) {
    if (root != NULL) {
        inorderTraversal(root->left, sortedStudents, index);
        sortedStudents[*index] = root->data;
        (*index)++;
        inorderTraversal(root->right, sortedStudents, index);
    }
}

// 比较函数，用于qsort排序
int compareStudents(const void *a, const void *b) {
    struct Student *studentA = (struct Student *)a;
    struct Student *studentB = (struct Student *)b;
    double avgA = calculateAverageScore(*studentA);
    double avgB = calculateAverageScore(*studentB);

    if (avgA < avgB) return -1;
    else if (avgA > avgB) return 1;
    else return 0;
}

// 比较函数，用于qsort排序
int compareStudents0(const void *a, const void *b) {
    struct Student *studentA = (struct Student *)a;
    struct Student *studentB = (struct Student *)b;

    // 按第一门课程成绩升序排序
    return studentA->score[0] - studentB->score[0];
}

// 比较函数，用于qsort排序
int compareStudents1(const void *a, const void *b) {
    struct Student *studentA = (struct Student *)a;
    struct Student *studentB = (struct Student *)b;

    // 按第一门课程成绩升序排序
    return studentA->score[1] - studentB->score[1];
}

// 比较函数，用于qsort排序
int compareStudents2(const void *a, const void *b) {
    struct Student *studentA = (struct Student *)a;
    struct Student *studentB = (struct Student *)b;

    // 按第一门课程成绩升序排序
    return studentA->score[2] - studentB->score[2];
}

// 函数声明：修改二叉树上某个学生的特定一门课程的成绩
struct TreeNode* modifyStudentScore(struct TreeNode *root, const char* targetNum, int courseIndex, int newScore) {
    // 如果根节点为空，直接返回
    if (root == NULL) {
        return NULL;
    }

    // 在左子树中查找目标学生
    root->left = modifyStudentScore(root->left, targetNum, courseIndex, newScore);

    // 如果当前节点的学号与目标学号匹配，则更新特定课程的成绩
    if (strcmp(root->data.num, targetNum) == 0) {
        // 更新特定课程的成绩
        if (courseIndex >= 0 && courseIndex < 3) {
            root->data.score[courseIndex] = newScore;
        } else {
            printf("错误：课程索引超出范围！\n");
        }
    }

    // 在右子树中查找目标学生
    root->right = modifyStudentScore(root->right, targetNum, courseIndex, newScore);

    return root;
}

// 中序遍历二叉树并将学生信息输出到文件
void inorderTraversalToFile(struct TreeNode *root, FILE *fp) {
    if (root != NULL) {
        inorderTraversalToFile(root->left, fp);
        fprintf(fp, "学号：%s，姓名：%s，专业：%s，班级：%d，成绩：%d %d %d\n",
                root->data.num, root->data.name, root->data.major, root->data.classNo,
                root->data.score[0], root->data.score[1], root->data.score[2]);
        inorderTraversalToFile(root->right, fp);
    }
}

// 将学生信息输出到文件
void exportStudentInfoToFile(struct TreeNode *root, const char *filename) {
    FILE *fp = fopen(filename, "w"); // 打开文件以写入模式

    if (fp == NULL) {
        perror("无法打开文件");
        return;
    }

    // 写入学生信息到文件
    inorderTraversalToFile(root, fp);

    // 关闭文件
    fclose(fp);
}

// 查找并删除指定学号的节点
struct TreeNode* deleteNode(struct TreeNode* root, const char* num) {
    if (root == NULL) {
        printf("未找到要删除的学号为 %s 的学生信息。\n", num);
        return root;
    }

    // 寻找要删除的节点
    if (strcmp(num, root->data.num) < 0) {
        root->left = deleteNode(root->left, num);
    } else if (strcmp(num, root->data.num) > 0) {
        root->right = deleteNode(root->right, num);
    } else { // 找到了要删除的节点
        // 情况1: 节点没有子节点或者只有一个子节点
        if (root->left == NULL) {
            struct TreeNode* temp = root->right;
            free(root);
            return temp;
        } else if (root->right == NULL) {
            struct TreeNode* temp = root->left;
            free(root);
            return temp;
        }

        // 情况2: 节点有两个子节点，找到右子树中最小的节点来替换当前节点
        struct TreeNode* temp = root->right;
        while (temp->left != NULL) {
            temp = temp->left;
        }

        // 用右子树中最小节点的值替换当前节点的值
        root->data = temp->data;

        // 删除右子树中最小节点
        root->right = deleteNode(root->right, temp->data.num);
    }

    return root;
}




int main() {
    struct TreeNode* root = NULL;
    int count=10;
    int zaijian;
    int cishu=5;
    char r[20];
    while (1) {
        printf("请输入用户swh的密码：\n");
        scanf("%s", r);
        while (cishu != 0) {
            if (strcmp(r, "swh040527") == 0) {
                printf("登陆成功！\n");
                cishu=1;
                break;
            } else {
                if (cishu == 0) {
                    printf("登录失败，请等待30s后重新登陆！\n");
                    break;
                }
                cishu--;
                printf("密码错误，请重新登录\n");
                printf("您还有%d次机会\n", cishu);
                printf("请输入用户swh的密码：\n");
                scanf("%s", r);

            }
        }
        if (cishu == 0) {
            printf("登录失败，请等待30s后重新登陆！\n");
            break;
        }
        break;
    }
    while(1){
        int a;
        printf("-----------------------------------------------------------\n");
        printf("欢迎来到******大学学生信息管理系统\n");
        printf("请输入数字选择相应功能\n");
        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("9：退出系统\n");
        printf("请输入序号：\n");
        scanf("%d",&a);
        if ((a < 1) || (a > 17))
            printf("你的输入有误，请重新输入\n");
        switch (a){
            case 1:{
                // 从文件中读取学生信息并插入二叉树
                root = readStudentsFromFile(root, "studentInit.txt");
                // 中序遍历打印二叉树
                printf("中序遍历二叉树结果：\n");
                inorderTraversal(root);
                break;
            }

            case 2:{
                int n=count;
                struct Student sortedStudents[n];
                int index = 0;

                // 中序遍历二叉树，将学生信息按照平均成绩存入sortedStudents数组
                inorderTraversal(root, sortedStudents, &index);

                // 使用qsort函数对sortedStudents数组按照平均成绩进行排序
                qsort(sortedStudents, n, sizeof(struct Student), compareStudents);

                // 输出排序后的学生信息
                printf("按照平均成绩排序后的学生信息：\n");
                for (int i = 0; i < n; ++i) {
                    printf("姓名：%s，学号：%s，专业：%s，班级：%d，平均成绩：%.2f\n",
                           sortedStudents[i].name, sortedStudents[i].num,
                           sortedStudents[i].major, sortedStudents[i].classNo,
                           calculateAverageScore(sortedStudents[i]));
                }
                break;
            }
            case 3:{
                // 假设有足够大的数组存储学生信息
                struct Student students[100]; // 假设最多存储100个学生信息
                int index = 0;
                int xuanze=0;
                printf("选择你要排序的课程序号012：\n");
                scanf("%d",&xuanze);
                // 中序遍历二叉树，将学生信息存储到数组中
                inorderTraversal(root, students, &index);

                // 计算实际存储的学生数量
                int n = index;
                if(xuanze==0){
                    // 使用qsort函数对学生数组按第0门课程成绩排序
                    qsort(students, n, sizeof(struct Student), compareStudents0);

                }
                if(xuanze==1){
                    // 使用qsort函数对学生数组按第1门课程成绩排序
                    qsort(students, n, sizeof(struct Student), compareStudents1);
                }
                if(xuanze==2){
                    // 使用qsort函数对学生数组按第2门课程成绩排序
                    qsort(students, n, sizeof(struct Student), compareStudents2);
                }
                // 使用qsort函数对学生数组按第0门课程成绩排序
                //qsort(students, n, sizeof(struct Student), compareStudents0);

                // 输出排序后的学生信息
                printf("按第一门课程成绩升序排序后的学生信息：\n");
                for (int i = 0; i < n; ++i) {
                    printf("姓名：%s，学号：%s，专业：%s，班级：%d，第一门课成绩：%d\n",
                           students[i].name, students[i].num,
                           students[i].major, students[i].classNo,
                           students[i].score[xuanze]);
                }

                break;
            }

            case 4:{
                // 假设有足够大的数组存储学生信息
                struct Student students[100]; // 假设最多存储100个学生信息
                int index = 0;

                // 中序遍历二叉树，将学生信息存储到数组中
                inorderTraversal(root, students, &index);

                // 计算实际存储的学生数量
                int n = index;
                int xuanze=0;
                printf("输出最大成绩0还是最小成绩1：\n");
                scanf("%d",&xuanze);
                // 找到平均分最大的学生
                if(xuanze==0) {
                    float maxAverage = -1.0; // 初始化一个负数，确保能找到比所有平均分都低的分数
                    struct Student *maxStudent = NULL;

                    for (int i = 0; i < n; ++i) {
                        float avg = calculateAverageScore(students[i]);
                        if (avg > maxAverage) {
                            maxAverage = avg;
                            maxStudent = &students[i];
                        }
                    }

                    // 输出平均分最大的学生信息
                    printf("平均分最大的学生信息：\n");
                    printf("姓名：%s，学号：%s，专业：%s，班级：%d\n",
                           maxStudent->name, maxStudent->num,
                           maxStudent->major, maxStudent->classNo);
                    printf("平均分：%.2f\n", maxAverage);
                }
                if(xuanze==1){
                    float maxAverage = 101; // 初始化一个负数，确保能找到比所有平均分都低的分数
                    struct Student *maxStudent = NULL;

                    for (int i = 0; i < n; ++i) {
                        float avg = calculateAverageScore(students[i]);
                        if (avg < maxAverage) {
                            maxAverage = avg;
                            maxStudent = &students[i];
                        }
                    }

                    // 输出平均分最大的学生信息
                    printf("平均分最小的学生信息：\n");
                    printf("姓名：%s，学号：%s，专业：%s，班级：%d\n",
                           maxStudent->name, maxStudent->num,
                           maxStudent->major, maxStudent->classNo);
                    printf("平均分：%.2f\n", maxAverage);
                }
                break;
            }

            case 5:{
                int xuanze1,xuanze2;
                printf("最高成绩0还是最低成绩1：\n");
                scanf("%d",&xuanze1);
                printf("第几门012：\n");
                scanf("%d",&xuanze2);
                // 假设有足够大的数组存储学生信息
                struct Student students[100]; // 假设最多存储100个学生信息
                int index = 0;

                // 中序遍历二叉树，将学生信息存储到数组中
                inorderTraversal(root, students, &index);

                // 计算实际存储的学生数量
                int n = index;
                if(xuanze1==0) {
                    // 找到某门课成绩最高的学生
                    int maxScoreIndex = -1;
                    int maxScore = -1; // 假设成绩不会低于0

                    // 假设要找第一门课的最高成绩
                    for (int i = 0; i < n; ++i) {
                        if (students[i].score[xuanze2] > maxScore) {
                            maxScore = students[i].score[xuanze2];
                            maxScoreIndex = i;
                        }
                    }

                    // 输出某门课成绩最高的学生信息
                    printf("第%d门课成绩最高的学生信息：\n",xuanze2);
                    printf("姓名：%s，学号：%s，专业：%s，班级：%d\n",
                           students[maxScoreIndex].name, students[maxScoreIndex].num,
                           students[maxScoreIndex].major, students[maxScoreIndex].classNo);
                    printf("第%d门课最高成绩：%d\n",xuanze2, maxScore);
                }
                if(xuanze1==1) {
                    // 找到某门课成绩最高的学生
                    int maxScoreIndex = 101;
                    int maxScore = 101; // 假设成绩不会低于0

                    // 假设要找第一门课的最高成绩
                    for (int i = 0; i < n; ++i) {
                        if (students[i].score[xuanze2] < maxScore) {
                            maxScore = students[i].score[xuanze2];
                            maxScoreIndex = i;
                        }
                    }

                    // 输出某门课成绩最高的学生信息
                    printf("第%d门课成绩最低的学生信息：\n",xuanze2);
                    printf("姓名：%s，学号：%s，专业：%s，班级：%d\n",
                           students[maxScoreIndex].name, students[maxScoreIndex].num,
                           students[maxScoreIndex].major, students[maxScoreIndex].classNo);
                    printf("第%d门课最低成绩：%d\n",xuanze2, maxScore);
                }
                break;
            }

            case 6:{
                int xuanze,fenshu;
                char targetNum[20];
                // 假设有一个已经构建好的二叉树，根节点为 root

                // 新的成绩
                //int newScore = 100; // 假设新的成绩
                //int courseIndex = 1; // 假设要修改第二门课程的成绩
                printf("请输入要修改成绩的学生学号：\n");
                scanf("%s",targetNum);
                printf("修改第几门成绩012：\n");
                scanf("%d",&xuanze);
                printf("修改为多少分：\n");
                scanf("%d",&fenshu);
                // 要修改的学号
                //const char* targetNum = "2220221235"; // 假设目标学号

                // 修改学生信息
                root = modifyStudentScore(root, targetNum, xuanze, fenshu);

                // 输出修改后的二叉树信息
                printf("修改后的学生信息：\n");
                inorderTraversal(root);

                break;
            }
            case 7:{

                exportStudentInfoToFile(root, "studentx.txt");

                printf("学生信息已成功导出到 studentx.txt 文件中。\n");
                break;
            }

            case 8:{
                char shan[20];
                printf("请输入你要删除学生数据的学号：\n");
                // 删除学号为 "1002" 的学生信息
                scanf("%s",shan);
                root = deleteNode(root, shan);

                printf("删除后的二叉树中的学生信息：\n");
                inorderTraversal(root);
                break;
            }
            case 9:{
                zaijian=886;
                printf("欢迎下次使用!\n");
            }
        }
        if(zaijian==886){
            break;
        }
    }

    return 0;
}

ichont
关注
使用c语言建立一个学生管理系统（使用结构体）
weixin_44382383的博客
04-03 2万+
一.题目分析(学生信息管理系统) 做一个学生信息管理系统，首先定义一个结构体。结构体成员分别有:学号，姓名，年龄，性别等。然后分别实现帮助、查询学生信息、增加学生信息、显示当前学生信息等若干功能。整个程序中使用n这个全局变量来控制学生信息管理系统中的人数。在menu()方法中，用一个循环来一直输出这个学生管理系统的界面，直到输入8才结束 二.关键算法构造 N-S盒图： 流程图： 在这里插入图片描...
家谱管理系统设计报告c语言,家谱管理系统设计报告.doc
weixin_35368877的博客
05-19 2729
家谱管理系统设计报告目 录第一章 绪论2第二章需求分析32.1题目32.2设计任务32.3数据测试3第三章 概要设计33.1 设计思想33.2 实现方法4第四章 详细设计44.1功能构想44.2界面设计44.3增加成员54.3.1 添加子女54.3.2 添加配偶54.4修改成员64.4.1修改个人信息64.4.2修改父母信息64.4.3修改兄弟姐妹的信息64.4....
C++学生管理系统(二叉树)
02-06
老师，学生，选课 用二叉树查找，百万信息秒查 老师，学生，选课 用二叉树查找，百万信息秒查 老师，学生，选课 用二叉树查找，百万信息秒查 老师，学生，选课 用二叉树查找，百万信息秒查
数据结构学生信息管理系统
01-24
1、 学生信息录入：主要是录入学生班级信息和学生基本情况； 2、 学生信息查询：按指定系检索该系的学生信息，其中包括所有的学生信息； 3、 学生信息维护：维护学生、系别、课程、学生选课及成绩等方面的基本信息，包括增加、删除和修改； 4、 学生选课：为学生提供选课界面，包括所有课程信息。进入该界面前学生要输入正确的学号和姓名。
基于二叉树实现一个学生成绩信息管理系统
热门推荐
m0_48298397的博客
08-15 1万+
众所周知，二叉树在数据结构领域属于一个较难的课题，本文针对二叉树的基本操作逻辑，实现了一个基于二叉树的学生成绩管理系统，包含初始化增加删除打印等各大基本功能，和大家一起分享，小编也是个初学者，有什么不正确的地方望指正。 本代码用了大量的递归函数，小白慎进，毕竟这是个很掉头发的东西，可真让人头秃！！！ 本代码实现五大功能，分别是： 1、添加学生编号、姓名和成绩，将数据插入二叉树中 2、输入编号，找到相应的二叉树节点，可查询学生成绩信息 3、打印出二叉树所有节点的信息 4、按编号删除相应的节点.
C语言二叉树的应用（家谱）
程序设计
11-29 1754
实验五 二叉树的应用(难度系数:☆☆☆☆☆)[问描述]假定在当今家庭中，每个人最多可以养育两个孩子，请建立一个从曾祖父开始的家谱，用二叉树的数据结构表示(二叉树的层数可以为 3-4 层)。[基本要求]1.实现整个家谱成员的输出。2.实现家谱中成员的查找与定位，比如该成员位于家谱的第几代。3.实现家谱中某个成员的双亲结点、子女结点的输出。
c语言程序设计实例220,C语言程序设计实例大全(220个例子)
weixin_34382015的博客
05-18 1506
C语言程序设计实例大全,C语言是世界上最流行、使用最广泛的高级程序设计语言之一,这里c语言 程序设计 实例 大全有220个例子供大家参考c语言开发实例目录：第一部分 基础篇001 第一个C程序002 运行多个源文件003 求整数之积004 比较实数大小005 字符的输出006 显示变量所占字节数007 自增/自减运算008 数列求和009 乘法口诀表010 猜数字游戏011 模拟ATM(自动柜员机...
C++程序设计案例实训教程第6章
hxcinfo的博客
10-29 1567
第6章  结构、共用体与链表 程序设计高级语言允许程序员利用已经存在的数据类型，包括基本数据类型和其他构造数据类型，自行构造新的数据类型。在程序设计过程中程序要处理的对象，往往不是用一种简单的数据类型就可描述的，为了对关系密切但类型不同的数据进行有效的管理，C语言引进了 结构、共用体的概念。结构体后共用体的类型的定义掌握结构体和共用体变量的定义初始化合影用掌握结构体数组和结构体指针的定义及应用，
基于C语言的数据结构课程设计（学生管理系统、停车场管理、家谱管理、校园导航系统）
JChan.的博客
01-18 1万+
大学C语言、数据结构小学期课程设计源码
数据结构实训 图书馆管理系统
12-19
《数据结构实训：图书馆管理系统》 在这个项目中，我们探讨的是如何运用数据结构知识来设计并实现一个功能完善的图书馆管理系统。这个系统包含了基础的增、删、查等操作，能够有效地管理和检索图书信息，确保系统...
C语言实训电子地图
12-23
"C语言实训电子地图"项目是基于C语言实现的一种图形化管理工具，它可能涉及到数据结构、算法以及文件操作等多个核心知识点。下面我们将深入探讨这些关键概念。 1. 数据结构：在构建电子地图时，数据结构的选择至关...
报告汇总之c语言数据结构报告篇(三)基于二叉树的家谱系统
qq_45621040的博客
01-30 7190
报告汇总之c语言数据结构报告篇(三) 家谱的查找 代码区 #include <stdio.h> #include <stdlib.h> //创建一个二叉链 typedef struct node { char data; struct node* lchild; struct node* rchild; }tn; //获取二叉树结构 void ge...
单片机C语言程序设计实训：100个案例中的数据结构与算法
[单片机C语言程序设计实训：100个案例中的数据结构与算法](https://img-blog.csdnimg.cn/8d82d88cdf6f407fb88a96eca72f7f9d.png) # 1. 单片机C语言程序设计基础 单片机是一种集成了CPU、存储器和I/O接口等功能的...
【笔记】数据结构12
m0_52024881的博客
09-29 601
看到的社区的一个知识总结，这里记录一下。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 410
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1188
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
【数据结构】【栈】算法汇总
最新发布
Indigo____的博客
10-07 93
【代码】【数据结构】【栈】算法汇总。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值