婚姻管理系统-使用bbst数据结构

使用到希尔排序和归并排序，文件存储

#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> #include <string.h>

//名字的最大长度 #define NameMax 30

//全局的文件指针变量 FILE* file, * file_admin, * file_divorce;

//结婚人数 int nums = 0;

//定义普通用户的结构体 typedef struct user {     char name[NameMax];     char ID[20];    //身份证位18位     int age;            //年龄     char sex;       //性别，F位女，M为男     char partner[NameMax];  //配偶的名字     char partner_ID[20];    //配偶的身份证     struct user* next; } User;

//定义管理员的结构体 typedef struct admin {     char name[NameMax]; //管理员的名字     char password[20];      //密码 }Admin;

//定义树结点信息 typedef struct node {     int height;     int balance;     User* info;     struct node* left;     struct node* right; }Node;

//离婚人数链表，用来存储离婚人的信息 User* divorce;

//判断是否操作确认,确认是返回1，不确认返回0 int GetConfirm() {     char yes_no[5];     memset(yes_no, 0, sizeof(yes_no));     printf("\n\t\t=======================================\n");     printf(" \n\t\t\t是否执行该操作 ? 此操作不可逆！ \n");     printf("\n\t\t=======================================\n");     printf("\n\t\t\t确认？ [Y/N]：");     scanf("%s", yes_no);     if (strcmp(yes_no, "y") == 0 || strcmp(yes_no, "Y") == 0)         return 1;     else         return 0; }

//获得树的高度 int getHeight(Node* node) {     if (node == NULL) {         return 0;     }     int leftHeight = getHeight(node->left);     int rightHeight = getHeight(node->right);     return max(leftHeight, rightHeight) + 1; }

//获得当前结点的平衡因子 int getBalanceFactor(Node* tree) {     //如果不为空，当前结点平衡因子为左子树高度-右子树高度     if (tree) {         return getHeight(tree->left) - getHeight(tree->right);     }     return 0; }

//左转 Node* RR(Node* parent) {     //左旋     Node* son = parent->left;     parent->left = son->right;     son->right = parent;     //更新结点的高度     son->height = max(getHeight(son->left), getHeight(son->right)) + 1;     parent->height = max(getHeight(parent->left), getHeight(parent->right)) + 1;     //返回当前在最顶上的结点     return son; }

//左旋 Node* LL(Node* parent) {     //左旋变换     Node* son = parent->right;     parent->right = son->left;     son->left = parent;     //更新结点高度     son->height = max(getHeight(son->left), getHeight(son->right)) + 1;     parent->height = max(getHeight(parent->left), getHeight(parent->right)) + 1;     //返回当前在最顶上的结点     return son; }

//更新树的平衡 Node* balance(Node* node) {

    //获取当前节点的平衡因子     int bf = getBalanceFactor(node);

    //不需要平衡     if (bf == 0)         return node;

    if (bf > 1) {         //左子树比右子树高         if (getBalanceFactor(node->left) < 0) {             //LR型，先对左节点进行LL旋转再对当前结点进行RR旋转             node->left = LL(node->left);         }         node = RR(node);     }     else if (bf < -1) {         //右子树比左子树高         if (getBalanceFactor(node->right) > 0) {             //RL型，先对右节点进行RR旋转再对当前结点进行LL旋转             node->right = RR(node->right);         }         node = LL(node);     }

    // 更新节点高度     node->height = max(getHeight(node->left), getHeight(node->right)) + 1;

    return node; }

//返回一个正确的身份证号 char* correct_ID() {     char* str = (char*)malloc(sizeof(char) * 19);     memset(str, 0, sizeof(str));     scanf("%s", str);     while (strlen(str) != 18) {         printf("\t\t身份证出错，请输入身份证：");         scanf("%s", str);         putchar('\n');     }     return str; }

//插入一个节点数据 Node* insert(Node* tree, User* info) {     // 判断插入节点是否为空     if (info == NULL) {         return tree;     }

    // 创建插入节点并赋值     if (tree == NULL) {         //判断是否离婚         User* p, * temp;         temp = p = divorce;         while (temp) {             if (!strcmp(temp->ID, info->ID)) {                 printf("\n\t          此人已离婚！！！是否继续？\n");                 if (GetConfirm()) {                     p->next = temp->next;                 }                 else                     return tree;             }             p = temp;             temp = temp->next;         }

        nums++;         tree = (Node*)malloc(sizeof(Node));         tree->info = (User*)malloc(sizeof(User));         *(tree->info) = *info;         tree->info->next = NULL;         tree->height = 0;         tree->left = tree->right = NULL;         return tree;     }

    // 存在相同身份证号的情况     if (strcmp(info->ID, tree->info->ID) == 0) {         printf("\t          身份证重复或已存在该人的信息，添加失败！\n");         return NULL;     }     else if (strcmp(info->ID, tree->info->ID) < 0) {         tree->left = insert(tree->left, info);     }     else {         tree->right = insert(tree->right, info);     }

    // 更新节点高度并进行平衡操作     tree->height = max(getHeight(tree->left), getHeight(tree->right)) + 1;     tree = balance(tree);

    return tree; }

//按身份证来查找某个结点 User* searchByID(Node* tree, char* ID) {     if (ID == NULL) {         printf("身份证出错");         return NULL;     }

    if (!tree) {         User* p = divorce->next;         int flag = 0;         while (p) {             if (!(strcmp(p->ID, ID))) {                 printf("\t          姓名：%s,\t\t年龄：%d,\t身份证：%s，\t性别：%c，\t前配偶：%s\n",                     p->name, p->age, p->ID, p->sex, p->partner);                 flag = 1;             }             p = p->next;         }         if (flag == 0)             printf("\n\t          未找到该人的信息！\n");         return NULL;     }     else if (strcmp(ID, tree->info->ID) < 0) {         return searchByID(tree->left, ID);     }     else if (strcmp(ID, tree->info->ID) > 0) {         return searchByID(tree->right, ID);     }     else {         //找到了，输出信息         printf("\t          姓名：%s,\t\t年龄：%d,\t身份证：%s，\t性别：%c，\t配偶：%s\n",             tree->info->name, tree->info->age, tree->info->ID, tree->info->sex, tree->info->partner);         return tree->info;     } }

//通过姓名来查找，通过前序遍历一遍树 int  searchByName(Node* tree, char* name, int type) {     //结婚的中选取     if (type == 1) {         if (name == NULL) {             printf("名称输入有误");             return 0;         }

        if (tree) {             if (!strcmp(tree->info->name, name)) {                 //找到了，输出信息                 printf("\t          姓名：%s,\t\t年龄：%d,\t身份证：%s，\t性别：%c，\t配偶：%s\n",                     tree->info->name, tree->info->age, tree->info->ID, tree->info->sex, tree->info->partner);                 return 1;             }             return searchByName(tree->left, name, type) + searchByName(tree->right, name, type);         }     }     else {         //离婚的中查询         if (divorce == NULL)             return 0;

        User* q = divorce->next;         int times = 0;         while (q) {             if (!strcmp(q->name, name))             {                 //找到了相同名字的人                 times++;                 printf("\t          姓名：%s,\t\t年龄：%d,\t身份证：%s，\t性别：%c，\t配偶：%s\n",                     q->name, q->age, q->ID, q->sex, q->partner);             }             q = q->next;         }         if (times > 0)             return 1;     }     return 0; }

//查找替换节点 Node* findrepalceNode(Node* node) {     //找到右子树上最小节点或左子树上的最大节点

    if (node->left != NULL) {         //左子树的最大节点         Node* max = node->left;         while (max->right != NULL) {             max = max->right;         }         return max;     }     else if (node->right != NULL) {         //右子树的最小节点         Node* min = node->right;         while (min->left != NULL) {             min = min->left;         }         return min;     }     else {         //两种都不是         return NULL;     }

}

//是否确认输入 int yes_no_divorce() {     char yes_no[5];     memset(yes_no, 0, sizeof(yes_no));     printf("\n\t\t=======================================\n");     printf(" \n\t\t\t是否为离婚？ \n");     printf("\n\t\t=======================================\n");     printf("\n\t\t\t y 是离婚   n 是删除 [Y/N]：");     scanf("%s", yes_no);     //清空缓存区     fflush(stdin);     if (strcmp(yes_no, "y") == 0 || strcmp(yes_no, "Y") == 0)         return 1;     else         return 0; }

//删除一个结点 Node* del(Node* tree, User* info) {     // 判断传入的 info 是否为空     if (info == NULL || tree == NULL || ((tree->right == NULL) && (tree->left == NULL) && strcmp(tree->info->ID, info->ID)==0)) {         return NULL;     }

    if (strcmp(info->ID, tree->info->ID) > 0) {         // 递归删除右子树中的节点         tree->right = del(tree->right, info);     }     else if (strcmp(info->ID, tree->info->ID) < 0) {         // 递归删除左子树中的节点         tree->left = del(tree->left, info);     }     else {         // 找到了要删除的节点         nums--;

        if (tree->left == NULL || tree->right == NULL) {             // 被删除的节点有一个子节点或者没有子节点

            // 用子节点来代替当前节点             Node* child;             if (tree->left == NULL) {                 child = tree->right;             }             else {                 child = tree->left;             }             free(tree->info);             free(tree);             return child;         }         else {             // 被删除的节点有两个子节点             Node* replacenode = findrepalceNode(tree);             tree->info = replacenode->info;             tree->right = del(tree->right, replacenode->info);         }     }

    // 更新节点高度并进行平衡操作     tree->height = max(getHeight(tree->left), getHeight(tree->right)) + 1;     tree = balance(tree);     return tree; }

//显示已结婚所有数据，通过前序遍历实现 void display_tree(Node* tree) {     if (tree) {         printf("\t          姓名：%s,\t\t年龄：%d,\t身份证：%s，\t性别：%c，\t配偶：%s\n",             tree->info->name, tree->info->age, tree->info->ID, tree->info->sex, tree->info->partner);         display_tree(tree->left);         display_tree(tree->right);     } }

//添加一个双方的婚姻信息（添加婚姻信息） Node* add_both(Node* tree) {     //定义好变量     char name[NameMax];     char partner_name[NameMax];     char* ID;     char* partner_ID;     int age;     int partner_age;     char sex;     int partner_sex;

    //输入一方的结婚信息     printf("\t\t          请输入姓名：");     scanf("%s", name);     printf("\t\t          请输入身份证：");     ID = correct_ID();     printf("\t\t          请输入年龄：");     getchar();     scanf("%d", &age);     printf("\t\t          请输入性别（M/F）：");     getchar();     scanf(" %c", &sex);     printf("\t\t          请输入配偶姓名：");     scanf("%s", partner_name);     printf("\t\t          请输入配偶身份证：");     partner_ID = correct_ID();     printf("\t\t          请输入配偶年龄：");     getchar();     scanf("%d", &partner_age);     printf("\t\t          请输入配偶性别（M/F）：");     getchar();     scanf(" %c", &partner_sex);     getchar();

    User* info = (User*)malloc(sizeof(User));     (info->next) = NULL;     User* info2 = (User*)malloc(sizeof(User));     (info2->next) = NULL;

    if (GetConfirm()) {         info->age = age;         info->sex = sex;         strcpy(info->name, name);         strcpy(info->ID, ID);         strcpy(info->partner, partner_name);         strcpy(info->partner_ID, partner_ID);         //先插入本人的身份信息到树中         printf("\t          姓名：%s，年龄：%d，身份证：%s，性别：%c，配偶：%s\n",             info->name, info->age, info->ID, info->sex, info->partner);         tree = insert(tree, info);

        //复制配偶的信息

        info2->age = partner_age;         info2->sex = partner_sex;         strcpy(info2->name, partner_name);         strcpy(info2->ID, partner_ID);         strcpy(info2->partner, name);         strcpy(info2->partner_ID, ID);         printf("\t         姓名：%s，年龄：%d，身份证：%s，性别：%c，配偶：%s\n",             info2->name, info2->age, info2->ID, info2->sex, info2->partner);         //先插入配偶的身份信息到树中         tree = insert(tree, info2);

    }

    return tree; }

//删除一个双方婚姻信息 Node* del_node(Node* tree) {     if (nums <= 2) {         printf("\t          节点必须多于两个\n");         return tree;     }     char* del_ID;     char del_partnerID[20];     //输入信息     printf("\t\t          请输入要删除人的身份证：");     del_ID = correct_ID();     //查找节点     User* user1, * user2;     user1 = searchByID(tree, del_ID);     if (user1 == NULL)         return tree;     strcpy(del_partnerID, user1->partner_ID);     user2 = searchByID(tree, del_partnerID);

    if (GetConfirm()) {         if (yes_no_divorce()) {             //返回值为1，代表离婚             User* p, * q;             p = q = divorce;             if (divorce->next != NULL) {                 //遍历到链表的最后一个节点                 while (q) {                     p = q;                     q = q->next;                 }             }             //插入离婚两人的信息在链表中             q = (User*)malloc(sizeof(User));             q->next = NULL;             (*q) = (*user1);             (p->next) = q;             p = (p->next);             q = (User*)malloc(sizeof(User));             q->next = NULL;             (*q) = (*user2);             p->next = q;             q->next = NULL;         }         //删除节点         tree = del(tree, user1);         tree = del(tree, user2);

    }     return tree;

}

//登入 Admin* login(Admin* admin) {     if (admin == NULL)     {         printf("admin.txt文件出错");         exit(0);     }

    char admin_name[NameMax];     char admin_password[20];     int times = 0;     while (1) {         //输入管理信息         printf("\t          请输入管理员账号:");         scanf("%s", admin_name);         printf("\n");         printf("\t          请输入管理员密码:");         scanf("%s", admin_password);

        //判断管理员信息是否相等         if (!strcmp(admin->name, admin_name)) {             if (!strcmp(admin->password, admin_password))                 break;             else             {                 printf("\t          密码错误，请重新输入:\n\n");             }         }         else         {             printf("\t          管理员账号错误，请重新输入:\n\n");         }

        times++;         //如果密码多次出错         if (times > 4) {             printf("\t\t是否需要修改密码:\n");             if (GetConfirm()) {                 printf("请输入修改的用户名:\n");                 scanf("%s", admin->name);                 printf("请输入修改的密码:\n");                 scanf("%s", admin->password);             }         }     }     return admin; }

//调用文件初始化一颗二叉树 Node* readFile(FILE* f) {     Node* tree = (Node*)malloc(sizeof(Node));     tree->info = (User*)malloc(sizeof(User));     tree->info = NULL;     tree = NULL;     User* temp = (User*)malloc(sizeof(User));     temp->next = NULL;     //判断文件是否为空     fseek(f, 0, SEEK_END);     long position = ftell(f);     if (position == 0) {         //printf("文件为空\n");         return NULL;     }     //文件移到开头     fseek(f, 0, SEEK_SET);     while (fscanf(f, "%s %s %d %c %s %s\n", temp->name, temp->ID, &temp->age, &temp->sex, temp->partner, temp->partner_ID) != EOF) {         tree = insert(tree, temp);

        //注意指针一次只能指向一个地址，新建一棵树的时候要不断的来创建一个地址空间         temp = (User*)malloc(sizeof(User));         temp->next = NULL;     }     return tree; }

//磁盘上读取一个admin文件出来 Admin* readAdmin(FILE* f) {     Admin* temp = (Admin*)malloc(sizeof(Admin));

    fseek(f, 0, SEEK_SET);     fscanf(f, "%s\n%s", temp->name, temp->password);     return temp; }

//磁盘上读取一个divorve文件出来 User* readDivorce(FILE* f) {     User* p, * q, * divorce;     p = q = divorce = (User*)malloc(sizeof(User));     p->next = NULL;     q = (User*)malloc(sizeof(User));     q->next = NULL;     //判断文件是否为空     fseek(f, 0, SEEK_END);     long position = ftell(f);     if (position == 0) {         //printf("文件为空\n");         User* temp = (User*)malloc(sizeof(User));         (temp->next) = NULL;         return temp;     }     //文件移到开头     fseek(f, 0, SEEK_SET);     while ((fscanf(f, "%s %s %d %c %s %s\n", q->name, q->ID, &q->age, &q->sex, q->partner, q->partner_ID)) != EOF)     {         p->next = q;         p = p->next;         q = (User*)malloc(sizeof(User));     }     free(q);     p->next = NULL;     return divorce; }

//前序遍历存储树到文件中 void travel_creatfile(Node* root) {     if (root == NULL || file == NULL) {         return;     }

    fprintf(file, "%s %s %d %c %s %s\n",         root->info->name, root->info->ID, root->info->age, root->info->sex,         root->info->partner, root->info->partner_ID);     //遍历树     travel_creatfile(root->left);     travel_creatfile(root->right); }

User* h, * p;

//树转换成链表 void User_to_list(Node* root) {     if (root == NULL)         return;     p->next = root->info;     p = p->next;     p->next = NULL;     User_to_list(root->left);     User_to_list(root->right); }

//保存文件 void saveTreeToFile(Node* temp) {     fclose(file);     if ((file = fopen("marriage.txt", "w+")) != NULL) {         //打开成功         ;     }     else {         //打开失败         printf("文件打开出错:\n");         exit(0);     }     travel_creatfile(temp); }

//保存离婚信息文件 void saveDivorceToFile(User* divorce_temp) {     fclose(file_divorce);     if ((file_divorce = fopen("divorce.txt", "w+")) != NULL) {         //打开成功         ;     }     else {         //打开失败         printf("文件打开出错:\n");         exit(0);     }     if (divorce_temp == NULL)         return;     User* divorce = divorce_temp->next;     //循环遍历链表，将链表数据存储到文件中     while (divorce) {         fprintf(file_divorce, "%s %s %d %c %s %s\n",             divorce->name, divorce->ID, divorce->age, divorce->sex, divorce->partner, divorce->partner_ID);         divorce = divorce->next;     } }

//保存管理员信息文件 void saveAdminToFile(Admin* admin) {

    fclose(file_admin);

    if ((file_admin = fopen("admin.txt", "w+")) != NULL) {         //打开成功         ;     }     else {         //打开失败         printf("\t          管理员信息文件打开出错:\n");         exit(0);     }     if (fprintf(file_admin, "%s\n%s", admin->name, admin->password) == EOF) {         printf("\t          管理员信息文件保存出错:\n");     } }

//统计结婚信息 void Statistical(User a[]) {     //定义并初始化数组     int aa[11] = { 0 };

    for (int i = 0; i < nums; i++) {         aa[a[i].age / 10]++;     }     printf("\n\t\t不同年龄阶段登记结婚统计：\n");     for (int i = 1; i < nums; i++)         printf("\n\t\t%d岁到%d岁之间有：%d人", i * 10, (i + 1) * 10 - 1, aa[i]);     putchar('\n'); }

//希尔排序，升序排序 void shell_sort(User arr[], int type) {     // 初始步长     int gap = nums / 2;     while (gap > 0) {         for (int i = gap; i < nums; i++) {             User temp = arr[i];             int j = i - gap;             //进行比较             if (type == 0) {                 //升序                 while (j >= 0 && arr[j].age > temp.age) {                     arr[j + gap] = arr[j];                     j -= gap;                 }             }             else {                 while (j >= 0 && arr[j].age < temp.age) {                     arr[j + gap] = arr[j];                     j -= gap;                 }             }             //交换             arr[j + gap] = temp;         }         gap /= 2; // 缩短步长     } }

//年龄排序 void sort_age(Node* tree) {     if (tree == NULL) {         printf("\t\t无数据\n");         return;     }     p = h = (User*)malloc(sizeof(User));     h->next = NULL;     User_to_list(tree);     p->next = NULL;

    User* pp, * head = h->next;     if (head == NULL)     {         printf("\t\t无信息\n");         return;     }     User* a = (User*)malloc(sizeof(User) * nums);     int i = 0;     while (head) {         pp = head;         *(a + i) = *head;         i++;         head = head->next;         pp->next = NULL;     }     //进行排序     printf("\t\t升序排序请输入0，降序则输入其他\n");     int type;     printf("\t\t请输入你要输入的：");     scanf("%d", &type);     shell_sort(a, type);     putchar('\n');     for (i = 0; i < nums; i++) {         printf("\t         姓名：%s，\t\t年龄：%d，\t身份证：%s，\t性别：%c，\t配偶：%s\n",             a[i].name, a[i].age, a[i].ID, a[i].sex, a[i].partner);     }     getchar();     Statistical(a);

    free(a); }

//查看离婚人数列表 void display_divorce() {     int divorce_num = 0;     if (divorce == NULL)     {         printf("\t        无\n");         return;     }     User* p = divorce->next;     while (p) {         printf("\t         姓名：%s，年龄：%d，身份证：%s，性别：%c，前配偶：%s\n",             p->name, p->age, p->ID, p->sex, p->partner);         divorce_num++;         p = p->next;     }     printf("\t\t\t离婚人数有:   %d", divorce_num); }

//显示所有信息 void display_all(Node* tree) {     printf("\t\t已结婚:\n");     display_tree(tree);     printf("\t\t已离婚:\n");     display_divorce(); }

//查找并改写该结婚信息 Node* searchcorrect_mar(Node** tree, char* ID) {     if (((*tree) == NULL) || ID == NULL)         return *tree;     if (strcmp(ID, (*tree)->info->ID) > 0) {         //在右子树中         searchcorrect_mar(&((*tree)->right), ID);     }     else if (strcmp(ID, (*tree)->info->ID) < 0) {         searchcorrect_mar(&((*tree)->left), ID);     }     else {         //找到节点了         printf("\t\t          请输入要更改的姓名：");         char name[NameMax];         scanf("%s", name);         putchar('\n');         strcpy((*tree)->info->name, name);         printf("\t\t          请输入要更改的性别：");         char sex;         //抵消多余的回车         getchar();         scanf(" %c", &sex);         putchar('\n');         printf("\t\t          请输入要更改的年龄：");

        getchar();         int age;         scanf("%d", &age);         (*tree)->info->sex = sex;         (*tree)->info->age = age;         return (*tree);     } }

void searchcorrect_mar2(Node** tree, User* info) {     if (((*tree) == NULL) || info->ID == NULL)         return;     if (strcmp(info->ID, (*tree)->info->ID) > 0) {         //在右子树中         searchcorrect_mar2(&((*tree)->right), info);     }     else if (strcmp(info->ID, (*tree)->info->ID) < 0) {         searchcorrect_mar(&((*tree)->left), info);     }     else {         //找到节点了         strcpy((*tree)->info->partner, info->name);     } }

//更改婚姻信息 Node* correct_marriage(Node* tree) {     User* newnode = (User*)malloc(sizeof(User));     char* ID;     printf("\t\t输入你要更改人的身份证：  ");     ID = correct_ID();     if (ID == NULL) {         printf("输入出错");         exit(0);     }     Node* temp = searchcorrect_mar(&tree, ID);     if (temp != temp)         searchcorrect_mar2(&tree, temp->info);   //在结婚信息中找到节点了     else {         User* p = divorce->next;         printf("\t\t          请输入要更改的姓名：");         char name[NameMax];         scanf("%s", name);         putchar('\n');         printf("\t\t          请输入要更改的性别：");         char sex;         //抵消多余的回车         getchar();         scanf(" %c", &sex);         putchar('\n');         printf("\t\t          请输入要更改的年龄：");         getchar();         int age;         scanf("%d", &age);         while (p) {             if (!strcmp(p->ID, ID)) {                 //在离婚信息中找到节点了                 strcpy(p->name, name);                 p->sex = sex;                 p->age = age;             }             p = p->next;         }     }     return tree; }

//更改管理员信息 Admin* correct_admin() {     if (file_admin == NULL) {         printf("Admin信息文件出错");         exit(0);     }     else         fclose(file_admin);

    Admin* new = (Admin*)malloc(sizeof(Admin));     printf("\t\t输入你要更改人的管理员账号：  ");     scanf("%s", new->name);     printf("\t\t输入你要更改人的管理员密码：  ");     scanf("%s", new->password);     //判断存储管理员信息的文件是否存在，是否能打开     if ((file_admin = fopen("admin.txt", "w+")) != NULL) {         //打开成功         ;     }     else {         //打开失败         printf("\t          管理员信息文件打开出错:\n");         exit(0);     }     if (fprintf(file_admin, "%s\n%s", new->name, new->password) == EOF) {         printf("\t          管理员信息文件保存出错:\n");     }     fclose(file_admin);     return new; }

//打印菜单 void memu() {

    printf("\n\t\t***************************************\n");     printf("\t\t*          请选择要进行的操作：       *\n");     printf("\t\t*          1. 添加婚姻信息            *\n");     printf("\t\t*          2. 删除婚姻信息            *\n");     printf("\t\t*          3. 按身份证查询            *\n");     printf("\t\t*          4. 显示信息                *\n");     printf("\t\t*          5. 修改婚姻信息            *\n");     printf("\t\t*          6. 按姓名查询              *\n");     printf("\t\t*          7. 按年龄进行排序          *\n");     printf("\t\t*          8. 清屏                    *\n");     printf("\t\t*          9. 显示菜单                *\n");     printf("\t\t*          a. 修改管理员信息          *\n");     printf("\t\t*          b. 保存并退出              *\n");     printf("\t\t*          c. 保存文件                *\n");     printf("\t\t***************************************\n\n"); }

//打开所有的文本文件 void open_allfile() {     //open_file(file, file_admin);    //判断存储婚姻信息的文件是否存在，是否能打开     if ((file = fopen("marriage.txt", "r+")) != NULL) {         //打开成功         ;     }     else {         //打开失败         printf("\t\t          婚姻信息文件打开出错:\n");         exit(0);     }

    //判断存储管理员信息的文件是否存在，是否能打开     if ((file_admin = fopen("admin.txt", "r+")) != NULL) {         //打开成功         ;     }     else {         //打开失败         printf("\t          管理员信息文件打开出错:\n");         exit(0);     }

    //判断存储离婚信息的文件是否存在，是否能打开     if ((file_divorce = fopen("divorce.txt", "r+")) != NULL) {         //打开成功         ;     }     else {         //打开失败         printf("\t          离婚信息文件打开出错:\n");         exit(0);     } }

//后序释放空间 void free_tree(Node** root) {     if (*root == NULL)         return;     free_tree(&((*root)->left));     free_tree(&((*root)->right));     free((*root)->info);     free(*root); }

void free_other(User** h, Admin** admin) {     free(*admin);

    User* p = (*h)->next;     while (p) {         free(*h);         *h = p;         p = p->next;     } }

//运行程序操作 void running() {     //打开所有文件     open_allfile();

    Admin* admin = readAdmin(file_admin);     Node* tree = readFile(file);     divorce = readDivorce(file_divorce);

    admin = login(admin);     char option[10];     memu();     while (1) {         printf("\n\t\t请输入您的选项：");         scanf("%s", option);         printf("\n");         switch (option[0]) {             //添加         case '1':             tree = add_both(tree);             break;         case '2':             //删除             tree = del_node(tree);             break;         case '3':             //身份证查询             printf("\t\t          请输入要查询的身份证号： ");             char* ID;             ID = correct_ID();             searchByID(tree, ID);             break;         case '4':             //查看信息         {             int type;             printf("\t\t          请输入要查看的信息：\n ");             printf("\t\t          1、已结婚人的信息 \n");             printf("\t\t          2、已离婚人的信息\n ");             printf("\t\t          3、所有人的信息 \n");             printf("\t\t          请输入要查询选项（1-3）： ");             //判断输入的类型             scanf("%d", &type);             switch (type)             {             case 1:                 display_tree(tree); break;             case 2:                 display_divorce(); break;             case 3:                 display_all(tree);                 break;             default:                 break;             }             putchar('\n');             break;         }         case '5':             //修改婚姻信息             tree = correct_marriage(tree);             break;         case '6':         {             printf("\t\t          请输入查询类别：\n");             printf("\t\t          1、查询结婚人信息：\n");             printf("\t\t          2、查询离婚人的姓名：\n");             int type;             printf("\t\t          请输入要查询的选项（1-2）：");             scanf("%d", &type);             printf("\t\t          请输入要查询的姓名：");             char nameToSearch[NameMax];             scanf("%s", nameToSearch);             int judge = searchByName(tree, nameToSearch, type);             if (judge != 1) {                 printf("\t\t查无此人，请检查后再试！\n");             }         }         break;         case '7':             //按年龄进行排序             sort_age(tree);             break;         default:             printf("\t\t无效的选项！\n");             break;             break;         case '9':             memu();             break;         case '8':             system("cls");             break;         case 'a':             //修改管理员信息             admin = correct_admin();             break;         case 'b':             system("cls");             printf("\n\n\t\t\t\t           程序已退出！\n");             printf("\n\t\t\t\t          欢迎下次使用！\n");             saveTreeToFile(tree);             saveDivorceToFile(divorce);             saveAdminToFile(admin);

            fclose(file);             fclose(file_divorce);             fclose(file_admin);

            free_tree(&tree);             free_other(&divorce, &admin);             exit(0);         case 'c':             saveTreeToFile(tree);             saveDivorceToFile(divorce);             saveAdminToFile(admin);             printf("\t\t          保存成功！\n");             break;         }     }

}

int main() {     running();     return 0; }