循环链表的插入，删除，修改，遍历，查找。
    strcmp（）
    strcpy_s( A , sizeof( B ) , B )
    scanf(“%s”,char A, sizeof(A))
    fflush(stdin)

    1. #include <stdio.h>
    2. #include<string.h>
    3. #include<malloc.h>
    4. #include<stdlib.h>
    5. #include<stdbool.h>
    6. #define NO_LENGTH  20
    7. #define NAME_LENGTH 11
    8. /* 定义学生结构体的数据结构 */
    9. typedef struct Student {
    10.     char studentNo[NO_LENGTH];
    11.     char studentName[NAME_LENGTH];
    12. }st;
    13. /* 定义每条记录或节点的数据结构 */
    14. typedef struct node
    15. {
    16.     struct Student data; //数据域
    17.     struct node* next; //指针域
    18. }Node, * Link;  //Node为node类型的别名,Link为node类型的指针别名
    19. //定义提示菜单
    20. void myMenu() {
    21.     printf(" * * * * * * * * * 菜     单 * * * * * * * * * *\n");
    22.     printf("     1 增加学生记录            2 删除学生记录                     \n");
    23.     printf("     3 查找学生记录            4 修改学生记录                     \n");
    24.     printf("     5 统计学生人数            6 显示学生记录                     \n");
    25.     printf("     7 退出系统                                     \n");
    26.     printf(" * * * * * * * * * * * * * * * * * * * * * * * *\n");
    27. }
    29. void inputStudent(Link l) {
    30.     printf("请输入学生学号:");
    31.     scanf_s("%s", l->data.studentNo, sizeof(l->data.studentNo));
    32.     printf("请输入学生的姓名:");
    33.     scanf_s("%s", l->data.studentName, sizeof(l->data.studentName));
    35.     //每个新创建的节点的next域都初始化为NULL
    36.     l->next = NULL;
    37. }
    39. void displayNode(Link head) {
    40.     // 填写代码，根据传入的链表head头指针，扫描链表显示所有节点的信息
    41.     Link p;
    42.     p = head->next;
    43.     printf("有以下学生在管理系统中：\n");
    44.     while (p != NULL) {
    45.         printf("学生学号:%s\t学生的姓名:%s\n", p->data.studentNo, p->data.studentName);
    46.         p = p->next;
    47.     }
    48. }
    49. /* 增加学生记录 */
    50. bool addNode(Link head) {
    51.     Link p, q;   //p,q两个节点一前一后
    52.     Link node;  //node指针指向新创建的节点
    53.     node = (Link)malloc(sizeof(Node));
    54.     inputStudent(node);
    55.     q = head;
    56.     p = head->next;  //q指向head后面的第一个有效节点
    57.     if (head->next == NULL)
    58.         head->next = node;
    59.     else {
    60.         //循环访问链表中的所有节点
    61.         while (p != NULL) {
    62.             if (strcmp(node->data.studentNo, p->data.studentNo) <= 0) {
    63.                 //如果node节点的学号比p节点的学号小，则插在p的前面，完成插入后，提前退出子程序
    64.                 node->next = p;
    65.                 q->next = node;
    66.                 return true;
    67.             }
    68.             else {
    69.                 //如果node节点的学号比p节点的学号大，继续向后移动指针（依然保持pq一前一后）
    70.                 q = p;
    71.                 p = q->next;
    73.             }
    74.         }
    75.         //如果没能提前退出循环，则说明之前没有插入，那么当前node节点的学号是最大值，此时插在链表的最后面
    76.         q->next = node;
    77.     }
    78.     return true;
    79. }
    81. bool deleteNode(Link head) {
    83.     // 按照给定的学号删除学生记录，如果删除成功返回true，如果没找到学号返回false
    84.     Link q = head;
    85.     Link p = head->next;
    86.     char de[NO_LENGTH];
    87.     printf("请输入要删除的学生学号:");
    88.     scanf_s("%s", de, sizeof(de));
    89.     //输入要处理的学号
    90.     while (p != NULL) {
    91.         if (strcmp(p->data.studentNo,de) == 0) {
    92.             printf("该学生的姓名：%s", p->data.studentName);
    93.             q->next = p->next;
    94.             free(p);
    95.             return 1;
    96.         }
    97.         q = p;
    98.         p = q->next;
    99.     }
    100.     return 0;
    101. }
    103. bool queryNode(Link head) {
    104.     // 按照给定的学号查询学生记录，如果删除成功返回true，如果没找到学号返回false
    105.     Link p = head->next;
    106.     //输入要处理的学号
    107.     char qu[NO_LENGTH];
    108.     printf("请输入要查找的学生学号:");
    109.     scanf_s("%s", qu, sizeof(qu));
    110.     while (p != NULL) {
    111.         if (strcmp(p->data.studentNo,qu) == 0) {
    112.             printf("该学生的姓名为：%s", p->data.studentName);
    113.             return 1;
    114.         }
    115.         p = p->next;
    116.     }
    117.     return 0;
    118. }
    120. bool modifyNode(Link head) {
    121.     // 按照给定的学号找到学生记录节点，如果修改成功返回true，如果没找到学号返回false
    122.     Link p = head->next;
    123.     //输入要处理的学号
    124.     char mo[NO_LENGTH];
    125.     printf("请输入要修改的学生学号:");
    126.     scanf_s("%s", mo, sizeof(mo));
    127.     fflush(stdin);
    128.     while (p != NULL) {
    129.         if (strcmp(p->data.studentNo, mo) == 0) {
    130.             int flag;
    131.             flag = 1;
    132.             fflush(stdin);
    133.             while (flag) {
    134.                 int moSelect;
    135.                 printf("修改学号输入：1 修改姓名输入: 2");
    136.                 printf("\n");
    137.                 scanf_s("%d", &moSelect);
    138.                 if (moSelect == 1) {
    139.                     char moN[NO_LENGTH];
    140.                     printf("学号修改为：");
    141.                     scanf_s("%s", moN, sizeof(moN));
    142.                     fflush(stdin);
    143.                     strcpy_s((p->data.studentNo), sizeof(moN), moN);
    144.                     flag = 0;
    146.                 }
    147.                 else if (moSelect == 2) {
    148.                     char moNa[NAME_LENGTH];
    149.                     printf("名字修改为：");
    150.                     scanf_s("%s", moNa, sizeof(moNa));
    151.                     fflush(stdin);
    152.                     strcpy_s(p->data.studentName, sizeof(moNa), moNa);
    153.                     flag = 0;
    154.                 }
    155.                 else {
    156.                     printf("请输入正确数字范围（1-2）\n");
    157.                     continue;
    158.                 }
    159.                 return 1;
    160.             }
    161.         }
    162.         p = p->next;
    163.     }
    164.     return false;
    165. }
    167. int countNode(Link head) {
    168.     //统计学生人数，扫描链表统计节点个数，返回节点数
    169.     Link p;
    170.     p = head->next;
    171.     int count = 0;
    172.     //填充代码
    173.     while (p) {
    174.         ++count;
    175.         p = p->next;
    176.     }
    177.     return count;
    178. }
    180. void clearLink(Link head) {
    181.     Link q, p;
    182.     q = head;
    183.     p = head->next;
    184.     //遍历链表，用free语句删除链表中用malloc建立起的所有的节点
    185.     while (p) {
    186.         q = p->next;
    187.         free(p);
    188.         p = q->next;
    189.     }
    190. }
    192. int main() {
    193.     int count;
    194.     Link head;  // 定义链表
    195.     //建立head头结点，在这个程序中head指向头结点，头结点data部分没有内容，其后续节点才有真正的数据
    196.     head = (Link)malloc(sizeof(Node));
    197.     head->next = NULL;
    198.     myMenu();
    199.     while (1)
    200.     {
    201.         int select;
    202.         printf("\n请输入你的选择(0-7):");  //显示提示信息
    203.         scanf_s("%d", &select);
    204.         fflush(stdin);
    205.         switch (select)
    206.         {
    207.         case 1:
    208.             //增加学生记录
    209.             if (addNode(head))
    210.                 printf("成功插入一个学生记录。\n\n");
    211.             break;
    212.         case 2:
    213.             //删除学生记录
    214.             if (deleteNode(head))
    215.                 printf("（成功删除一个学生记录）。\n\n");
    216.             else
    217.                 printf("没有找到删除的学生节点。\n\n");
    218.             break;
    219.         case 3:
    220.             //查询学生记录
    221.             if (queryNode(head))
    222.                 printf("（成功查询一个学生记录）。\n\n");
    223.             else
    224.                 printf("没有找到要查询的学生节点。\n\n");
    225.             break;
    226.         case 4:
    227.             //修改学生记录
    228.             if (modifyNode(head))
    229.                 printf("成功修改一个学生记录。\n\n");
    230.             else
    231.                 printf("没有找到要修改的学生节点。\n\n");
    232.             break;
    233.         case 5:
    234.             //统计学生人数
    235.             count = countNode(head);
    236.             printf("学生人数为：%d\n\n", count);
    237.             break;
    238.         case 6:
    239.             //显示学生记录
    240.             displayNode(head);
    241.             break;
    242.         case 7:
    243.             //退出前清除链表中的所有结点
    244.             clearLink(head);
    245.             return 0;
    246.         default:
    247.             printf("输入不正确，应该输入0-7之间的数。\n\n");
    248.             break;
    249.         }
    250.     }
    251.     return 0;
    252. }