• 常用数据结构和算法

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

    前言

    提示：这里可以添加本文要记录的大概内容：

    这里面有10个数据结构：数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Trie树；10个算法：递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。。

    一、复杂度

    1、时间复杂度（最好情况时间复杂度、最坏情况时间复杂度、平均时间复杂度）

    2、空间复杂度

    二、数据结构知识

    2.1 数据结构的逻辑结构

    数据结构中的逻辑结构（附上c++中的常见数据结构的逻辑结构）_数据结构的逻辑结构有哪些-CSDN博客

    数据结构的逻辑结构包括四种逻辑结构

    1、集合结构

    2、线性结构：一一对应

    3、树形结构

    4、图形结构

    三、数据结构分析

    3.1、链表

    3.1.1 静态链表

    3.2.2动态链表

    3.2.2.1、回顾代码

    看了一个抖音，里面讲了静态链表和动态链表。之前看的静态链表讲的蛮好的。觉得还挺简单的。今天又看到了讲动态链表的。当时就有个疑问。new出来的stu_new的next指针不需要值NULL吗？一直带着这个疑问。还评论了一下，想看看别人是怎么说的。然后回工位还在想这件事情。然后就觉得写一下吧，感觉不是很难，然后就写下了下面的代码。

    下面的代码基本实现了视频里的效果。后面还要跟视频的作下对比。

    1. #include 
    2. #include 
    3. #include "string.h"
    4.  
    5. //动态指针
    6. //①枚举类型不会写(成员不会写)
    7. //②结构体指针写法不会写
    8. //scanf循环
    9.  
    10.  
    11. //性别
    12. typedef enum Gender
    13. {
    14.     male,
    15.     female,
    16.     middle
    17. }Gend;
    18.  
    19. //结构体
    20. typedef struct stu
    21. {
    22.     char name[10];
    23.     int age;
    24.     Gend gender;
    25.     int score;
    26.     struct stu* next;
    27. }Stu;
    28.  
    29. Stu stuDynamic;
    30.  
    31. int stuAdd(Stu* stu)
    32. {
    33.     if(NULL == stu)
    34.     {
    35.         return -1;
    36.     }
    37.  
    38.     Stu *stuTemp = &stuDynamic;
    39.  
    40.     while(stuTemp->next)
    41.     {
    42.         stuTemp = stuTemp->next;
    43.     }
    44.  
    45.     stuTemp->next = stu;
    46.  
    47.     return 1;
    48. }
    49.  
    50. void printStu(Stu* stu)
    51. {
    52.     Stu* temp = stu->next;
    53.     printf("打印学生信息\n");
    54.     while(temp)
    55.     {
    56.         printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    57.         temp = temp->next;
    58.     }
    59. }
    60.  
    61. int main()
    62. {
    63.     char name[10] = {'\0'};
    64.     int age = -1;
    65.     int score;
    66.     Gend gender;
    67.     printf("输入姓名, 年龄, 性别, 分数\n");
    68. //    gets("%s", name);
    69. //    scanf("%d", &age);
    70. //    scanf("%d", &score);
    71. //    scanf("%d", &gender);
    72.  
    73.     while(age != 0)
    74.     {
    75.         scanf("%s %d %d %d", name, &age, &gender, &score);
    76.         Stu *stu_new = (Stu*)malloc(sizeof(Stu));
    77.         if(NULL == stu_new)
    78.         {
    79.             printf("malloc fail");
    80.             continue;
    81.         }
    82.  
    83.         memcpy(stu_new->name, name, 10);
    84.         stu_new->age = age;
    85.         stu_new->score = score;
    86.         stu_new->gender = gender;
    87.         stu_new->next = NULL;
    88.  
    89.  
    90.         stuAdd(stu_new);
    91.  
    92.         printStu(&stuDynamic);
    93.     }
    94.  
    95.     return 0;
    96. }

    但是其中还是有一个问题。就是我一开始写的代码是没有将stu_new的next指针置空的。那个代码就异常了。体现在没有让我继续输入数据，然后也打印了，打印后就退出了。 然后调试的时候发现程序在print里面会异常退出。

    现在来看就是因为stu_new没有置为NULL。所以我之前的考虑是对的。那么视频里的程序是怎么写的呢，需要在会看一下视频代码。下面就把之前写的代码贴出来。

    1. #include 
    2. #include 
    3. #include "string.h"
    4.  
    5. //动态指针
    6. //①枚举类型不会写(成员不会写)
    7. //②结构体指针写法不会写
    8. //scanf循环
    9.  
    10.  
    11. //性别
    12. typedef enum Gender
    13. {
    14.     male,
    15.     female,
    16.     middle
    17. }Gend;
    18.  
    19. //结构体
    20. typedef struct stu
    21. {
    22.     char name[10];
    23.     int age;
    24.     Gend gender;
    25.     int score;
    26.     struct stu* next;
    27. }Stu;
    28.  
    29. Stu stuDynamic;
    30.  
    31. int stuAdd(Stu* stu)
    32. {
    33.     if(NULL == stu)
    34.     {
    35.         return -1;
    36.     }
    37.  
    38.     Stu *stuTemp = &stuDynamic;
    39.  
    40.     while(stuTemp->next)
    41.     {
    42.         stuTemp = stuTemp->next;
    43.     }
    44.  
    45.     stuTemp->next = stu;
    46.  
    47.     return 1;
    48. }
    49.  
    50. void printStu(Stu* stu)
    51. {
    52.     Stu* temp = stu;
    53.     printf("打印学生信息\n");
    54.     while(temp)
    55.     {
    56.         printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    57.         temp = temp->next;
    58.     }
    59. }
    60.  
    61. int main()
    62. {
    63.     char name[10] = {'\0'};
    64.     int age = -1;
    65.     int score;
    66.     Gend gender;
    67.     printf("输入姓名, 年龄, 性别, 分数\n");
    68. //    gets("%s", name);
    69. //    scanf("%d", &age);
    70. //    scanf("%d", &score);
    71. //    scanf("%d", &gender);
    72.  
    73.     while(age != 0)
    74.     {
    75.         scanf("%s %d %d %d", name, &age, &gender, &score);
    76.         Stu *stu_new = (Stu*)malloc(sizeof(Stu));
    77.         if(NULL == stu_new)
    78.         {
    79.             printf("malloc fail");
    80.             continue;
    81.         }
    82.  
    83.         memcpy(stu_new->name, name, 10);
    84.         stu_new->age = age;
    85.         stu_new->score = score;
    86.         stu_new->gender = gender;
    87.  
    88.         stuAdd(stu_new);
    89.  
    90.         printStu(&stuDynamic);
    91.     }
    92.  
    93.     return 0;
    94. }

    所以当stu_new的next指针没有置为NULL的时候，程序会越界访问。导致程序崩溃结束。看起来的效果就像是程序执行完了一样。

    随后还有个问题，就是全局变量stuDynamic的next指针时NULL吗？

    自己写了代码验证

    1. #include 
    2. #include 
    3. #include "string.h"
    4.  
    5. Stu stuDynamic;
    6.  
    7. int main()
    8. {
    9.     if(NULL == stuDynamic.next)
    10.     {
    11.         printf("stuDynamic->next:%p\n", stuDynamic.next);
    12.         printf("stuDynamic->next is NULL\n");
    13.     }
    14. }
    15.  
    16. //stuDynamic->next:00000000
    17. //stuDynamic->next is NULL

    查了一个帖子：全局变量和局部变量初始化问题_全局变量需要初始化吗-CSDN博客

    里面这么表述：这里需要分清一个事实，是变量系统都会默认给初始化，只不过全局变量默认初始化为0，而局部变量被初始化为随机数，这个随机数用不了，后面会验证

    3.2.2.2、阶段总结

    看了视频代码，有以下几点需要说明下

    ①全局变量没有写成g_xxx

    ②视频代码重复输入是因为用了while(1)

    ③视频的打印也是从g_stu开始打印，所以有全是0的输出，name是空

    后面可以优化代码。

    下面是优化代码，下面的代码实现了修改和查询

    1. #include 
    2. #include 
    3. #include "string.h"
    4. #include "stdbool.h"
    5.  
    6. //动态指针
    7. //①枚举类型不会写(成员不会写)
    8. //②结构体指针写法不会写
    9. //③scanf循环
    10. //④scanf用法
    11. //⑤switch-case写法
    12. //⑥strcpy == 0,没有判断是否==0,导致直接打印0
    13. //⑦解决scanf读单个字符会把换行符\n读取，且字符变量中只存了\n
    14. //⑧将strcmp用错成strcpy,导致出现修改时所有数据都被改了
    15.  
    16.  
    17. //性别
    18. typedef enum Gender
    19. {
    20.     male,
    21.     female,
    22.     middle
    23. }Gend;
    24.  
    25. //结构体
    26. typedef struct stu
    27. {
    28.     char name[10];
    29.     int age;
    30.     Gend gender;
    31.     int score;
    32.     struct stu* next;
    33. }Stu;
    34.  
    35. Stu g_stuDaynamic;
    36.  
    37. //增加
    38. int stu_add(Stu* stu)
    39. {
    40.     if(NULL == stu)
    41.     {
    42.         return -1;
    43.     }
    44.  
    45.     Stu *stuTemp = &g_stuDaynamic;
    46.  
    47.     while(stuTemp->next)
    48.     {
    49.         stuTemp = stuTemp->next;
    50.     }
    51.  
    52.     stuTemp->next = stu;
    53.  
    54.     return 1;
    55. }
    56.  
    57. //查询
    58. int stu_find(Stu* stu, char* name)
    59. {
    60.     Stu *temp = stu;
    61.     while(NULL == temp)
    62.     {
    63.         return -1;
    64.     }
    65.  
    66.     while(temp)
    67.     {
    68.         if( strcmp(temp->name, name) == 0)
    69.         {
    70.             printf("find the record");
    71.             printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    72.  
    73.             return 1;
    74.         }
    75.         temp = temp->next;
    76.     }
    77.  
    78.     printf("find the record Empty!");
    79. }
    80.  
    81. //修改
    82. int stu_modify(const Stu* stu, Stu* stu_modify)
    83. {
    84.     if(NULL == stu)
    85.     {
    86.         return -1;
    87.     }
    88.  
    89.     Stu* temp = stu;
    90.     while(temp)
    91.     {
    92.         if(strcmp(temp->name, stu_modify->name) == 0)
    93.         {
    94.             (*temp).age = stu_modify->age;
    95.             (*temp).gender = stu_modify->gender;
    96.             (*temp).score = stu_modify->score;
    97.  
    98.             return 1;
    99.         }
    100.         temp = temp->next;
    101.     }
    102. }
    103.  
    104. void printStu(Stu* stu)
    105. {
    106.     Stu* temp = stu->next;
    107.     printf("打印学生信息\n");
    108.     while(temp)
    109.     {
    110.         printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    111.         temp = temp->next;
    112.     }
    113. }
    114.  
    115. int action_add()
    116. {
    117.     char name[10] = {'\0'};
    118.     int age;
    119.     int score;
    120.     Gend gender;
    121.  
    122.     printf("输入姓名, 年龄, 性别, 分数\n");
    123.     scanf("%s %d %d %d", name, &age, &gender, &score);
    124.     Stu* stu_new = (Stu*)malloc(sizeof(Stu));
    125.     if(NULL == stu_new)
    126.     {
    127.         printf("malloc fail");
    128.         return -1;
    129.     }
    130.  
    131.     memcpy(stu_new->name, name, 10);
    132.     stu_new->age = age;
    133.     stu_new->score = score;
    134.     stu_new->gender = gender;
    135.     stu_new->next = NULL;
    136.  
    137.     stu_add(stu_new);
    138.  
    139.     printStu(&g_stuDaynamic);
    140. }
    141.  
    142. int action_find(char* name)
    143. {
    144.     stu_find(&g_stuDaynamic, name);
    145.     return 0;
    146. }
    147.  
    148. int action_modify()
    149. {
    150.     char name[10] = {'\0'};
    151.     int age;
    152.     int score;
    153.     Gend gender;
    154.  
    155.     Stu *stu_modify_new = (Stu*)malloc(sizeof(Stu));
    156.     if(NULL == stu_modify_new)
    157.     {
    158.         printf("malloc fail");
    159.         return -1;
    160.     }
    161.  
    162.     printf("输入修改的姓名, 年龄, 性别, 分数\n");
    163.     scanf("%s %d %d %d", name, &age, &gender, &score);
    164.  
    165.     memcpy(stu_modify_new->name, name, 10);
    166.     stu_modify_new->age = age;
    167.     stu_modify_new->score = score;
    168.     stu_modify_new->gender = gender;
    169.  
    170.     stu_modify(&g_stuDaynamic, stu_modify_new);
    171.  
    172.     free(stu_modify_new);
    173.  
    174.     printStu(&g_stuDaynamic);
    175.  
    176.     return 1;
    177. }
    178.  
    179. int main()
    180. {
    181.     bool m_flag = true;
    182.     if(NULL == g_stuDaynamic.next)
    183.     {
    184.         printf("g_stuDaynamic->next:%p\n", g_stuDaynamic.next);
    185.         printf("g_stuDaynamic->next is NULL\n");
    186.     }
    187.  
    188.     while(m_flag)
    189.     {
    190.         printf("选择操作(A:增加、D:删除、C:更改、F:查找、其他:退出):\n");
    191.         char action[2];
    192.         scanf("%s", action);
    193.         switch(action[0])
    194.         {
    195.             case 'A':
    196.             {
    197.                 action_add();
    198.                 break;
    199.             }
    200.  
    201.             case 'F':
    202.             {
    203.                 printf("输入查询的姓名：\n");
    204.                 char name[100];
    205.                 scanf("%s", name);
    206.                 action_find(name);
    207.                 break;
    208.             }
    209.  
    210.             case 'C':
    211.             {
    212.                 action_modify();
    213.                 break;
    214.             }
    215.  
    216.             default:
    217.             {
    218.                 m_flag = false;
    219.                 break;
    220.             }
    221.         }
    222.     }
    223.  
    224.     return 0;
    225. }
    226.  
    227.  
    228.

    这个代码还在编译时出现一个警告：

    warning：initialization discards ‘const’ qualifier from pointer target type

    这个帖子就是解释这个告警：warning：initialization discards ‘const’ qualifier from pointer target type 解决方法_initialization discards 'const' qualifier from poi-CSDN博客

    那么就存在一个问题，就是我不想函数更改g_stuDaynamic变量。所以用const限定为只读变量。但是在函数中还要遍历链表，temp又不能增加const修饰。但是赋值时就出现这个告警。下次看看教科书别人是怎么处理的。

    还有一个删除的功能没有实现，这个会涉及到链表头、尾的问题，先阶段性提交一次。

    下面是增加删除的代码

    1. #include 
    2. #include 
    3. #include "string.h"
    4. #include "stdbool.h"
    5. #include "ctype.h"
    6.  
    7. //动态指针
    8. //①枚举类型不会写(成员不会写)
    9. //②结构体指针写法不会写
    10. //③scanf循环
    11. //④scanf用法
    12. //⑤switch-case写法
    13. //⑥strcpy == 0,没有判断是否==0,导致直接打印0
    14. //⑦解决scanf读单个字符会把换行符\n读取，且字符变量中只存了\n
    15.  
    16.  
    17. //性别
    18. typedef enum Gender
    19. {
    20.     male,
    21.     female,
    22.     middle
    23. }Gend;
    24.  
    25. //结构体
    26. typedef struct stu
    27. {
    28.     char name[10];
    29.     int age;
    30.     Gend gender;
    31.     int score;
    32.     struct stu* next;
    33. }Stu;
    34.  
    35. Stu g_stuDaynamic;
    36.  
    37. int stu_add(Stu* stu)
    38. {
    39.     if(NULL == stu)
    40.     {
    41.         return -1;
    42.     }
    43.  
    44.     Stu *stuTemp = &g_stuDaynamic;
    45.  
    46.     while(stuTemp->next)
    47.     {
    48.         stuTemp = stuTemp->next;
    49.     }
    50.  
    51.     stuTemp->next = stu;
    52.  
    53.     return 1;
    54. }
    55.  
    56. int stu_find(Stu* stu, char* name)
    57. {
    58.     Stu *temp = stu;
    59.     while(NULL == temp)
    60.     {
    61.         return -1;
    62.     }
    63.  
    64.     while(temp)
    65.     {
    66.         if( strcmp(temp->name, name) == 0)
    67.         {
    68.             printf("find the record");
    69.             printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    70.  
    71.             return 1;
    72.         }
    73.         temp = temp->next;
    74.     }
    75.  
    76.     printf("find the record Empty!");
    77. }
    78.  
    79. int stu_modify(const Stu* stu, Stu* stu_modify)
    80. {
    81.     if(NULL == stu)
    82.     {
    83.         return -1;
    84.     }
    85.  
    86.     Stu* temp = stu;
    87.     while(temp)
    88.     {
    89.         if(strcmp(temp->name, stu_modify->name) == 0)
    90.         {
    91.             (*temp).age = stu_modify->age;
    92.             (*temp).gender = stu_modify->gender;
    93.             (*temp).score = stu_modify->score;
    94.  
    95.             return 1;
    96.         }
    97.         temp = temp->next;
    98.     }
    99. }
    100.  
    101. //删除
    102. int stu_delete(Stu* stu, char* name)
    103. {
    104.     if (NULL == stu)
    105.     {
    106.         return -1;
    107.     }
    108.     
    109.     Stu* temp = stu;
    110.     while (temp)
    111.     {
    112.         if(NULL != temp->next && strcmp(temp->next->name, name) == 0)
    113.         {
    114.             //目标节点在重点
    115.             Stu* traget = temp->next;
    116.             Stu* tragetNext = traget->next;
    117.             temp->next = tragetNext;
    118.             free(traget);
    119.  
    120.             printf("已找到记录并删除\n");
    121.             return 1;
    122.         }
    123.         temp = temp->next;
    124.     }
    125.     
    126.     printf("未找到可删除记录\n");
    127.     return 0;
    128. }
    129.  
    130. void printStu(Stu* stu)
    131. {
    132.     Stu* temp = stu->next;
    133.     printf("打印学生信息\n");
    134.     while(temp)
    135.     {
    136.         printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    137.         temp = temp->next;
    138.     }
    139. }
    140.  
    141. int action_add()
    142. {
    143.     char name[10] = {'\0'};
    144.     int age;
    145.     int score;
    146.     Gend gender;
    147.  
    148.     printf("输入姓名, 年龄, 性别, 分数\n");
    149.     scanf("%s %d %d %d", name, &age, &gender, &score);
    150.     Stu* stu_new = (Stu*)malloc(sizeof(Stu));
    151.     if(NULL == stu_new)
    152.     {
    153.         printf("malloc fail");
    154.         return -1;
    155.     }
    156.  
    157.     memcpy(stu_new->name, name, 10);
    158.     stu_new->age = age;
    159.     stu_new->score = score;
    160.     stu_new->gender = gender;
    161.     stu_new->next = NULL;
    162.  
    163.     stu_add(stu_new);
    164.  
    165.     printStu(&g_stuDaynamic);
    166. }
    167.  
    168. int action_find(char* name)
    169. {
    170.     stu_find(&g_stuDaynamic, name);
    171.     return 0;
    172. }
    173.  
    174. int action_modify()
    175. {
    176.     char name[10] = {'\0'};
    177.     int age;
    178.     int score;
    179.     Gend gender;
    180.  
    181.     Stu *stu_modify_new = (Stu*)malloc(sizeof(Stu));
    182.     if(NULL == stu_modify_new)
    183.     {
    184.         printf("malloc fail");
    185.         return -1;
    186.     }
    187.  
    188.     printf("输入修改的姓名, 年龄, 性别, 分数\n");
    189.     scanf("%s %d %d %d", name, &age, &gender, &score);
    190.  
    191.     memcpy(stu_modify_new->name, name, 10);
    192.     stu_modify_new->age = age;
    193.     stu_modify_new->score = score;
    194.     stu_modify_new->gender = gender;
    195.  
    196.     stu_modify(&g_stuDaynamic, stu_modify_new);
    197.  
    198.     free(stu_modify_new);
    199.  
    200.     printStu(&g_stuDaynamic);
    201.  
    202.     return 1;
    203. }
    204.  
    205. int action_delete()
    206. {
    207.     printf("输入需要删除的记录：\n");
    208.     char* name[100];
    209.     scanf("%s", name);
    210.     stu_delete(&g_stuDaynamic, name);
    211.     printStu(&g_stuDaynamic);
    212.     return 0;
    213. }
    214.  
    215. bool isTargetAlpha(char c)
    216. {
    217.     if(toupper(c) == 'A' || toupper(c) == 'D' || toupper(c) == 'C' || toupper(c) == 'F' || toupper(c) == 'Q')
    218.     {
    219.         return true;
    220.     }
    221.  
    222.     return false;
    223. }
    224.  
    225. int main()
    226. {
    227.     bool m_flag = true;
    228.     if(NULL == g_stuDaynamic.next)
    229.     {
    230.         printf("g_stuDaynamic->next:%p\n", g_stuDaynamic.next);
    231.         printf("g_stuDaynamic->next is NULL\n");
    232.     }
    233.  
    234.     while(m_flag)
    235.     {
    236.         printf("选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):\n");
    237.         char action[2];
    238.         scanf("%s", action);
    239.         if(!isTargetAlpha(action[0]))
    240.         {
    241.             continue;
    242.         }
    243.         switch(toupper(action[0]))
    244.         {
    245.             case 'A':
    246.             {
    247.                 action_add();
    248.                 break;
    249.             }
    250.  
    251.             case 'F':
    252.             {
    253.                 printf("输入查询的姓名：\n");
    254.                 char name[100];
    255.                 scanf("%s", name);
    256.                 action_find(name);
    257.                 break;
    258.             }
    259.  
    260.             case 'C':
    261.             {
    262.                 action_modify();
    263.                 break;
    264.             }
    265.  
    266.             case 'D':
    267.             {
    268.                 action_delete();
    269.                 break;
    270.             }
    271.  
    272.             case 'Q':
    273.             {
    274.                 m_flag = false;
    275.                 printf("退出\n");
    276.                 break;
    277.             }
    278.  
    279.             default:
    280.             {
    281.                 printf("操作有误，请重新输入\n");
    282.                 break;
    283.             }
    284.         }        
    285.     }
    286.  
    287.     return 0;
    288. }
    289.  
    290.  
    291.

    感觉比想象的简单，没有之前那么复杂啊。

    反正自验证实现了功能，目前还遗留的就是输错信息，程序直接退出了。需要优化下。

    另外印象中删除好像还挺复杂呢？

    2024年1月11日20:01:11

    下面就是所谓的复杂的。现在写的是插入。好像删除也不复杂，之前印象中复杂的只有插入。不然链表也太难了吧。同时参考C和指针的书籍。其实这个代码一直你有一个问题，就是我在函数里把g_stuDaynamic写死了，不能处理其他的链表，没有通用性。这个也是看C和指针的书才发现的啊！！

    1.  
    2.  
    3. #include "test.h"
    4.  
    5. //动态指针
    6. //①枚举类型不会写(成员不会写)
    7. //②结构体指针写法不会写
    8. //③scanf循环
    9. //④scanf用法
    10. //⑤switch-case写法
    11. //⑥strcpy == 0,没有判断是否==0,导致直接打印0
    12. //⑦解决scanf读单个字符会把换行符\n读取，且字符变量中只存了\n
    13.  
    14.  
    15. //性别
    16. typedef enum Gender
    17. {
    18.     male,
    19.     female,
    20.     middle
    21. }Gend;
    22.  
    23. //结构体
    24. typedef struct stu
    25. {
    26.     char name[10];
    27.     int age;
    28.     Gend gender;
    29.     int score;
    30.     struct stu* next;
    31. }Stu;
    32.  
    33. Stu g_stuDaynamic;
    34.  
    35. int stu_add(Stu* stu)
    36. {
    37.     if(NULL == stu)
    38.     {
    39.         return -1;
    40.     }
    41.  
    42.     Stu *stuTemp = &g_stuDaynamic;
    43.  
    44.     while(stuTemp->next)
    45.     {
    46.         stuTemp = stuTemp->next;
    47.     }
    48.  
    49.     stuTemp->next = stu;
    50.  
    51.     return 1;
    52. }
    53.  
    54. //插入数据有序排列
    55. void stu_insert(Stu* new)
    56. {
    57.     Stu* previous;
    58.     Stu* current;
    59.     Stu* next;
    60.  
    61.     previous = &g_stuDaynamic;
    62.     current = g_stuDaynamic.next;
    63.  
    64.     while(current->next != NULL && current->score <= new->score )
    65.     {
    66.         previous = current;
    67.         current = current->next;
    68.     }
    69.  
    70.     if(current->next == NULL)
    71.     {
    72.         current->next = new;
    73.     }
    74.     else
    75.     {
    76.         previous->next = new;
    77.         new->next = current;
    78.     }
    79. }
    80.  
    81. int stu_find(Stu* stu, char* name)
    82. {
    83.     Stu *temp = stu;
    84.     while(NULL == temp)
    85.     {
    86.         return -1;
    87.     }
    88.  
    89.     while(temp)
    90.     {
    91.         if( strcmp(temp->name, name) == 0)
    92.         {
    93.             printf("find the record");
    94.             printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    95.  
    96.             return 1;
    97.         }
    98.         temp = temp->next;
    99.     }
    100.  
    101.     printf("find the record Empty!");
    102. }
    103.  
    104. int stu_modify(const Stu* stu, Stu* stu_modify)
    105. {
    106.     if(NULL == stu)
    107.     {
    108.         return -1;
    109.     }
    110.  
    111.     Stu* temp = stu;
    112.     while(temp)
    113.     {
    114.         if(strcmp(temp->name, stu_modify->name) == 0)
    115.         {
    116.             (*temp).age = stu_modify->age;
    117.             (*temp).gender = stu_modify->gender;
    118.             (*temp).score = stu_modify->score;
    119.  
    120.             return 1;
    121.         }
    122.         temp = temp->next;
    123.     }
    124. }
    125.  
    126. //删除
    127. int stu_delete(Stu* stu, char* name)
    128. {
    129.     if (NULL == stu)
    130.     {
    131.         return -1;
    132.     }
    133.  
    134.     Stu* temp = stu;
    135.     while (temp)
    136.     {
    137.         if(NULL != temp->next && strcmp(temp->next->name, name) == 0)
    138.         {
    139.             //目标节点在重点
    140.             Stu* traget = temp->next;
    141.             Stu* tragetNext = traget->next;
    142.             temp->next = tragetNext;
    143.             free(traget);
    144.  
    145.             printf("已找到记录并删除\n");
    146.             return 1;
    147.         }
    148.         temp = temp->next;
    149.     }
    150.  
    151.     printf("未找到可删除记录\n");
    152.     return 0;
    153. }
    154.  
    155. void printStu(Stu* stu)
    156. {
    157.     Stu* temp = stu->next;
    158.     printf("打印学生信息\n");
    159.     while(temp)
    160.     {
    161.         printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    162.         temp = temp->next;
    163.     }
    164. }
    165.  
    166. int action_add()
    167. {
    168.     char name[10] = {'\0'};
    169.     int age;
    170.     int score;
    171.     Gend gender;
    172.  
    173.     printf("输入姓名, 年龄, 性别, 分数\n");
    174.     scanf("%s %d %d %d", name, &age, &gender, &score);
    175.     Stu* stu_new = (Stu*)malloc(sizeof(Stu));
    176.     if(NULL == stu_new)
    177.     {
    178.         printf("malloc fail");
    179.         return -1;
    180.     }
    181.  
    182.     memcpy(stu_new->name, name, 10);
    183.     stu_new->age = age;
    184.     stu_new->score = score;
    185.     stu_new->gender = gender;
    186.     stu_new->next = NULL;
    187.  
    188.     stu_add(stu_new);
    189.  
    190.     printStu(&g_stuDaynamic);
    191. }
    192.  
    193. //插入数据进行有序排列
    194. int action_insert()
    195. {
    196.     char name[10] = {'\0'};
    197.     int age;
    198.     int score;
    199.     Gend gender;
    200.  
    201.     printf("输入姓名、年龄、性别、分数\n");
    202.     scanf("%s %d %d %d", name, &age, &gender, &score);
    203.     Stu* stu_new = (Stu*)malloc(sizeof(Stu));
    204.     if(NULL == stu_new)
    205.     {
    206.         printf("malloc fail");
    207.         return -1;
    208.     }
    209.  
    210.     memcpy(stu_new->name, name, 10);
    211.     stu_new->age = age;
    212.     stu_new->score = score;
    213.     stu_new->gender = gender;
    214.     stu_new->next = NULL;
    215.  
    216.     stu_insert(stu_new);
    217.  
    218.     printStu(&g_stuDaynamic);
    219. }
    220.  
    221. int action_find(char* name)
    222. {
    223.     stu_find(&g_stuDaynamic, name);
    224.     return 0;
    225. }
    226.  
    227. int action_modify()
    228. {
    229.     char name[10] = {'\0'};
    230.     int age;
    231.     int score;
    232.     Gend gender;
    233.  
    234.     Stu *stu_modify_new = (Stu*)malloc(sizeof(Stu));
    235.     if(NULL == stu_modify_new)
    236.     {
    237.         printf("malloc fail");
    238.         return -1;
    239.     }
    240.  
    241.     printf("输入修改的姓名, 年龄, 性别, 分数\n");
    242.     scanf("%s %d %d %d", name, &age, &gender, &score);
    243.  
    244.     memcpy(stu_modify_new->name, name, 10);
    245.     stu_modify_new->age = age;
    246.     stu_modify_new->score = score;
    247.     stu_modify_new->gender = gender;
    248.  
    249.     stu_modify(&g_stuDaynamic, stu_modify_new);
    250.  
    251.     free(stu_modify_new);
    252.  
    253.     printStu(&g_stuDaynamic);
    254.  
    255.     return 1;
    256. }
    257.  
    258. int action_delete()
    259. {
    260.     printf("输入需要删除的记录：\n");
    261.     char* name[100];
    262.     scanf("%s", name);
    263.     stu_delete(&g_stuDaynamic, name);
    264.     printStu(&g_stuDaynamic);
    265.     return 0;
    266. }
    267.  
    268. bool isTargetAlpha(char c)
    269. {
    270.     if(toupper(c) == 'A' || toupper(c) == 'D' || toupper(c) == 'C' || toupper(c) == 'F' || toupper(c) == 'Q' || toupper(c) == 'I')
    271.     {
    272.         return true;
    273.     }
    274.  
    275.     return false;
    276. }
    277.  
    278. //int i = 0;
    279. //
    280. //void add() const
    281. //{
    282. //    i++;
    283. //}
    284.  
    285. int list_func()
    286. {
    287. //    add();
    288.  
    289.     bool m_flag = true;
    290.     if(NULL == g_stuDaynamic.next)
    291.     {
    292.         printf("g_stuDaynamic->next:%p\n", g_stuDaynamic.next);
    293.         printf("g_stuDaynamic->next is NULL\n");
    294.     }
    295.  
    296.     while(m_flag)
    297.     {
    298.         printf("选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):\n");
    299. //        printf("选择操作(A:增加、D:删除、C、更改：\n");
    300. //        printf("hello");
    301.         char action[2];
    302.         scanf("%s", action);
    303.         if(!isTargetAlpha(action[0]))
    304.         {
    305.             continue;
    306.         }
    307.         switch(toupper(action[0]))
    308.         {
    309.             case 'A':
    310.             {
    311.                 action_add();
    312.                 break;
    313.             }
    314.  
    315.             case 'F':
    316.             {
    317.                 printf("输入查询的姓名：\n");
    318.                 char name[100];
    319.                 scanf("%s", name);
    320.                 action_find(name);
    321.                 break;
    322.             }
    323.  
    324.             case 'C':
    325.             {
    326.                 action_modify();
    327.                 break;
    328.             }
    329.  
    330.             case 'D':
    331.             {
    332.                 action_delete();
    333.                 break;
    334.             }
    335.  
    336.             case 'Q':
    337.             {
    338.                 m_flag = false;
    339.                 printf("退出\n");
    340.                 break;
    341.             }
    342.  
    343.             //插入数据有序排列
    344.             case 'I':
    345.             {
    346.                 action_insert();
    347.                 break;
    348.             }
    349.  
    350.             default:
    351.             {
    352.                 printf("操作有误，请重新输入\n");
    353.                 break;
    354.             }
    355.         }
    356.  
    357.  
    358.     }
    359.  
    360.     return 0;
    361. }
    362.  
    363.  
    364. //g_stuDaynamic->next:00000000
    365. //g_stuDaynamic->next is NULL
    366. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    367. //A
    368. //输入姓名, 年龄, 性别, 分数
    369. //zhangs 7 0 77
    370. //打印学生信息
    371. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    372. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    373. //A
    374. //输入姓名, 年龄, 性别, 分数
    375. //lilu 8 1 88
    376. //打印学生信息
    377. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    378. //姓名:lilu, 年龄:8, 性别:1, 成绩:88
    379. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    380. //A
    381. //输入姓名, 年龄, 性别, 分数
    382. //wangmei 9 1 99
    383. //打印学生信息
    384. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    385. //姓名:lilu, 年龄:8, 性别:1, 成绩:88
    386. //姓名:wangmei, 年龄:9, 性别:1, 成绩:99
    387. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    388. //I
    389. //输入姓名、年龄、性别、分数
    390. //xux 6 0 90
    391. //打印学生信息
    392. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    393. //姓名:lilu, 年龄:8, 性别:1, 成绩:88
    394. //姓名:wangmei, 年龄:9, 性别:1, 成绩:99
    395. //姓名:xux, 年龄:6, 性别:0, 成绩:90
    396. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    397. //I
    398. //输入姓名、年龄、性别、分数
    399. //xiaom 6 1 80
    400. //打印学生信息
    401. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    402. //姓名:xiaom, 年龄:6, 性别:1, 成绩:80
    403. //姓名:lilu, 年龄:8, 性别:1, 成绩:88
    404. //姓名:wangmei, 年龄:9, 性别:1, 成绩:99
    405. //姓名:xux, 年龄:6, 性别:0, 成绩:90
    406. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    407. //I
    408. //输入姓名、年龄、性别、分数
    409. //xiaoh 9 0 83
    410. //打印学生信息
    411. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    412. //姓名:xiaom, 年龄:6, 性别:1, 成绩:80
    413. //姓名:xiaoh, 年龄:9, 性别:0, 成绩:83
    414. //姓名:lilu, 年龄:8, 性别:1, 成绩:88
    415. //姓名:wangmei, 年龄:9, 性别:1, 成绩:99
    416. //姓名:xux, 年龄:6, 性别:0, 成绩:90
    417. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    418.  
    419.

    上面的代码插入尾部的时候会异常，下面的可以正常插入尾部

    1. #include "test.h"
    2.  
    3. //动态指针
    4. //①枚举类型不会写(成员不会写)
    5. //②结构体指针写法不会写
    6. //③scanf循环
    7. //④scanf用法
    8. //⑤switch-case写法
    9. //⑥strcpy == 0,没有判断是否==0,导致直接打印0
    10. //⑦解决scanf读单个字符会把换行符\n读取，且字符变量中只存了\n
    11.  
    12.  
    13. //性别
    14. typedef enum Gender
    15. {
    16.     male,
    17.     female,
    18.     middle
    19. }Gend;
    20.  
    21. //结构体
    22. typedef struct stu
    23. {
    24.     char name[10];
    25.     int age;
    26.     Gend gender;
    27.     int score;
    28.     struct stu* next;
    29. }Stu;
    30.  
    31. Stu g_stuDaynamic;
    32.  
    33. int stu_add(Stu* stu)
    34. {
    35.     if(NULL == stu)
    36.     {
    37.         return -1;
    38.     }
    39.  
    40.     Stu *stuTemp = &g_stuDaynamic;
    41.  
    42.     while(stuTemp->next)
    43.     {
    44.         stuTemp = stuTemp->next;
    45.     }
    46.  
    47.     stuTemp->next = stu;
    48.  
    49.     return 1;
    50. }
    51.  
    52. //插入数据有序排列
    53. //存在最后一个节点判断异常
    54. void stu_insert1(Stu* new)
    55. {
    56.     Stu* previous;
    57.     Stu* current;
    58.     Stu* next;
    59.  
    60.     previous = &g_stuDaynamic;
    61.     current = g_stuDaynamic.next;
    62.  
    63.     while(current->next != NULL && current->score <= new->score )
    64.     {
    65.         previous = current;
    66.         current = current->next;
    67.     }
    68.  
    69.     if(current->next == NULL)
    70.     {
    71.         current->next = new;
    72.     }
    73.     else
    74.     {
    75.         previous->next = new;
    76.         new->next = current;
    77.     }
    78. }
    79.  
    80. //处理有些复杂
    81. void stu_insert2(Stu* new)
    82. {
    83.     Stu* previous;
    84.     Stu* current;
    85.     Stu* next;
    86.  
    87.     previous = &g_stuDaynamic;
    88.     current = g_stuDaynamic.next;
    89.  
    90.     while(current->score <= new->score && current->next != NULL)
    91.     {
    92.         previous = current;
    93.         current = current->next;
    94.     }
    95.  
    96.     //这边处理起来有些吃力，感觉需要识别是因为到结尾了还是当前节点大于插入数据
    97.     if(current->score > new->score)
    98.     {
    99.         previous->next = new;
    100.         new->next = current;
    101.     }
    102.     else
    103.     {
    104.         current->next = new;
    105.     }
    106. }
    107.  
    108. //C和指针照着写
    109. void stu_insert3(Stu* new)
    110. {
    111.     Stu* previous;
    112.     Stu* current;
    113.     Stu* next;
    114.  
    115.     previous = NULL;
    116.     current = &g_stuDaynamic;
    117.  
    118.     while(current->score <= new->score && current != NULL)
    119.     {
    120.         previous = current;
    121.         current = current->next;
    122.     }
    123.  
    124.     //这边处理起来有些吃力，感觉需要识别是因为到结尾了还是当前节点大于插入数据
    125.     if(current->score > new->score)
    126.     {
    127.         previous->next = new;
    128.         new->next = current;
    129.     }
    130.     else
    131.     {
    132.         current->next = new;
    133.     }
    134. }
    135.  
    136. //C和指针照着写，程序死机
    137. void stu_insert4(Stu* new)
    138. {
    139.     Stu* previous;
    140.     Stu* current;
    141.     Stu* next;
    142.  
    143.     previous = NULL;
    144.     current = &g_stuDaynamic;
    145.  
    146.     while( current->score <= new->score && current != NULL)         //这边内存泄漏，访问其他内存，没有先判断current是否为空
    147.     {
    148.         previous = current;
    149.         current = current->next;
    150.     }
    151.  
    152.     //这边处理起来有些吃力，感觉需要识别是因为到结尾了还是当前节点大于插入数据
    153.     if(current->score > new->score)
    154.     {
    155.         previous->next = new;
    156.         new->next = current;
    157.     }
    158.     else
    159.     {
    160.         previous->next = new;
    161.     }
    162. }
    163.  
    164. //C和指针照着写，程序死机
    165. void stu_insert5(Stu* new)
    166. {
    167.     Stu* previous;
    168.     Stu* current;
    169.     Stu* next;
    170.  
    171.     previous = NULL;
    172.     current = &g_stuDaynamic;
    173.  
    174.     while( current->score <= new->score && current != NULL)         //这边内存泄漏，访问其他内存，没有先判断current是否为空
    175.     {
    176.         previous = current;
    177.         current = current->next;
    178.     }
    179.  
    180.     //这边处理起来有些吃力，感觉需要识别是因为到结尾了还是当前节点大于插入数据
    181.  
    182.     if(current->score > new->score)         //这边内存泄露，current=NULL时，内存泄漏
    183.     {
    184.         previous->next = new;
    185.         new->next = current;
    186.     }
    187.     else
    188.     {
    189.         previous->next = new;
    190.     }
    191. }
    192.  
    193. void stu_insert(Stu* new)
    194. {
    195.     Stu* previous;
    196.     Stu* current;
    197.     Stu* next;
    198.  
    199.     previous = NULL;
    200.     current = &g_stuDaynamic;
    201.  
    202.     while(current != NULL && current->score <= new->score)
    203.     {
    204.         previous = current;
    205.         current = current->next;
    206.     }
    207.  
    208.     //这边处理起来有些吃力，感觉需要识别是因为到结尾了还是当前节点大于插入数据
    209.     if(current == NULL)
    210.     {
    211.         previous->next = new;
    212.     }
    213.     else
    214.     {
    215.         previous->next = new;
    216.         new->next = current;
    217.     }
    218. }
    219.  
    220. int stu_find(Stu* stu, char* name)
    221. {
    222.     Stu *temp = stu;
    223.     while(NULL == temp)
    224.     {
    225.         return -1;
    226.     }
    227.  
    228.     while(temp)
    229.     {
    230.         if( strcmp(temp->name, name) == 0)
    231.         {
    232.             printf("find the record");
    233.             printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    234.  
    235.             return 1;
    236.         }
    237.         temp = temp->next;
    238.     }
    239.  
    240.     printf("find the record Empty!");
    241. }
    242.  
    243. int stu_modify(const Stu* stu, Stu* stu_modify)
    244. {
    245.     if(NULL == stu)
    246.     {
    247.         return -1;
    248.     }
    249.  
    250.     Stu* temp = stu;
    251.     while(temp)
    252.     {
    253.         if(strcmp(temp->name, stu_modify->name) == 0)
    254.         {
    255.             (*temp).age = stu_modify->age;
    256.             (*temp).gender = stu_modify->gender;
    257.             (*temp).score = stu_modify->score;
    258.  
    259.             return 1;
    260.         }
    261.         temp = temp->next;
    262.     }
    263. }
    264.  
    265. //删除
    266. int stu_delete(Stu* stu, char* name)
    267. {
    268.     if (NULL == stu)
    269.     {
    270.         return -1;
    271.     }
    272.  
    273.     Stu* temp = stu;
    274.     while (temp)
    275.     {
    276.         if(NULL != temp->next && strcmp(temp->next->name, name) == 0)
    277.         {
    278.             //目标节点在重点
    279.             Stu* traget = temp->next;
    280.             Stu* tragetNext = traget->next;
    281.             temp->next = tragetNext;
    282.             free(traget);
    283.  
    284.             printf("已找到记录并删除\n");
    285.             return 1;
    286.         }
    287.         temp = temp->next;
    288.     }
    289.  
    290.     printf("未找到可删除记录\n");
    291.     return 0;
    292. }
    293.  
    294. void printStu(Stu* stu)
    295. {
    296.     Stu* temp = stu->next;
    297.     printf("打印学生信息\n");
    298.     while(temp)
    299.     {
    300.         printf("姓名:%s, 年龄:%d, 性别:%d, 成绩:%d\n", temp->name, temp->age, temp->gender, temp->score);
    301.         temp = temp->next;
    302.     }
    303. }
    304.  
    305. int action_add()
    306. {
    307.     char name[10] = {'\0'};
    308.     int age;
    309.     int score;
    310.     Gend gender;
    311.  
    312.     printf("输入姓名, 年龄, 性别, 分数\n");
    313.     scanf("%s %d %d %d", name, &age, &gender, &score);
    314.     Stu* stu_new = (Stu*)malloc(sizeof(Stu));
    315.     if(NULL == stu_new)
    316.     {
    317.         printf("malloc fail");
    318.         return -1;
    319.     }
    320.  
    321.     memcpy(stu_new->name, name, 10);
    322.     stu_new->age = age;
    323.     stu_new->score = score;
    324.     stu_new->gender = gender;
    325.     stu_new->next = NULL;
    326.  
    327.     stu_add(stu_new);
    328.  
    329.     printStu(&g_stuDaynamic);
    330. }
    331.  
    332. //插入数据进行有序排列
    333. int action_insert()
    334. {
    335.     char name[10] = {'\0'};
    336.     int age;
    337.     int score;
    338.     Gend gender;
    339.  
    340.     printf("输入姓名、年龄、性别、分数\n");
    341.     scanf("%s %d %d %d", name, &age, &gender, &score);
    342.     Stu* stu_new = (Stu*)malloc(sizeof(Stu));
    343.     if(NULL == stu_new)
    344.     {
    345.         printf("malloc fail");
    346.         return -1;
    347.     }
    348.  
    349.     memcpy(stu_new->name, name, 10);
    350.     stu_new->age = age;
    351.     stu_new->score = score;
    352.     stu_new->gender = gender;
    353.     stu_new->next = NULL;
    354.  
    355.     stu_insert(stu_new);
    356.  
    357.     printStu(&g_stuDaynamic);
    358. }
    359.  
    360. int action_find(char* name)
    361. {
    362.     stu_find(&g_stuDaynamic, name);
    363.     return 0;
    364. }
    365.  
    366. int action_modify()
    367. {
    368.     char name[10] = {'\0'};
    369.     int age;
    370.     int score;
    371.     Gend gender;
    372.  
    373.     Stu *stu_modify_new = (Stu*)malloc(sizeof(Stu));
    374.     if(NULL == stu_modify_new)
    375.     {
    376.         printf("malloc fail");
    377.         return -1;
    378.     }
    379.  
    380.     printf("输入修改的姓名, 年龄, 性别, 分数\n");
    381.     scanf("%s %d %d %d", name, &age, &gender, &score);
    382.  
    383.     memcpy(stu_modify_new->name, name, 10);
    384.     stu_modify_new->age = age;
    385.     stu_modify_new->score = score;
    386.     stu_modify_new->gender = gender;
    387.  
    388.     stu_modify(&g_stuDaynamic, stu_modify_new);
    389.  
    390.     free(stu_modify_new);
    391.  
    392.     printStu(&g_stuDaynamic);
    393.  
    394.     return 1;
    395. }
    396.  
    397. int action_delete()
    398. {
    399.     printf("输入需要删除的记录：\n");
    400.     char* name[100];
    401.     scanf("%s", name);
    402.     stu_delete(&g_stuDaynamic, name);
    403.     printStu(&g_stuDaynamic);
    404.     return 0;
    405. }
    406.  
    407. bool isTargetAlpha(char c)
    408. {
    409.     if(toupper(c) == 'A' || toupper(c) == 'D' || toupper(c) == 'C' || toupper(c) == 'F' || toupper(c) == 'Q' || toupper(c) == 'I')
    410.     {
    411.         return true;
    412.     }
    413.  
    414.     return false;
    415. }
    416.  
    417. int list_func()
    418. {
    419.     bool m_flag = true;
    420.     if(NULL == g_stuDaynamic.next)
    421.     {
    422.         printf("g_stuDaynamic->next:%p\n", g_stuDaynamic.next);
    423.         printf("g_stuDaynamic->next is NULL\n");
    424.     }
    425.  
    426.     while(m_flag)
    427.     {
    428.         printf("选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):\n");
    429.         char action[2];
    430.         scanf("%s", action);
    431.         if(!isTargetAlpha(action[0]))
    432.         {
    433.             continue;
    434.         }
    435.         switch(toupper(action[0]))
    436.         {
    437.             case 'A':
    438.             {
    439.                 action_add();
    440.                 break;
    441.             }
    442.  
    443.             case 'F':
    444.             {
    445.                 printf("输入查询的姓名：\n");
    446.                 char name[100];
    447.                 scanf("%s", name);
    448.                 action_find(name);
    449.                 break;
    450.             }
    451.  
    452.             case 'C':
    453.             {
    454.                 action_modify();
    455.                 break;
    456.             }
    457.  
    458.             case 'D':
    459.             {
    460.                 action_delete();
    461.                 break;
    462.             }
    463.  
    464.             case 'Q':
    465.             {
    466.                 m_flag = false;
    467.                 printf("退出\n");
    468.                 break;
    469.             }
    470.  
    471.             //插入数据有序排列
    472.             case 'I':
    473.             {
    474.                 action_insert();
    475.                 break;
    476.             }
    477.  
    478.             default:
    479.             {
    480.                 printf("操作有误，请重新输入\n");
    481.                 break;
    482.             }
    483.         }
    484.  
    485.  
    486.     }
    487.  
    488.     return 0;
    489. }
    490.  
    491.  
    492. //g_stuDaynamic->next:00000000
    493. //g_stuDaynamic->next is NULL
    494. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    495. //A
    496. //输入姓名, 年龄, 性别, 分数
    497. //zhangs 7 0 77
    498. //打印学生信息
    499. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    500. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    501. //A
    502. //输入姓名, 年龄, 性别, 分数
    503. //lilu 8 1 88
    504. //打印学生信息
    505. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    506. //姓名:lilu, 年龄:8, 性别:1, 成绩:88
    507. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    508. //A
    509. //输入姓名, 年龄, 性别, 分数
    510. //wangmei 9 0 99
    511. //打印学生信息
    512. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    513. //姓名:lilu, 年龄:8, 性别:1, 成绩:88
    514. //姓名:wangmei, 年龄:9, 性别:0, 成绩:99
    515. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    516. //I
    517. //输入姓名、年龄、性别、分数
    518. //lili 5 1 101
    519. //打印学生信息
    520. //姓名:zhangs, 年龄:7, 性别:0, 成绩:77
    521. //姓名:lilu, 年龄:8, 性别:1, 成绩:88
    522. //姓名:wangmei, 年龄:9, 性别:0, 成绩:99
    523. //姓名:lili, 年龄:5, 性别:1, 成绩:101
    524. //选择操作(A:增加、D:删除、C:更改、F:查找、Q:退出):
    525.

    几经波折啊！

    3.2.2.2.2 阶段2

    现在可以实现数据的增加、插入、删除、查找、修改了。但是离C和指针还有一些 差别或者差距。

    差距在于我这个目前使用的是一个全局链表变量。所以所有的程序只能针对于这个链表运行。因为函数中写死了链表变量。

    所以这是我又想到一个点。就是怎么叫解耦或者什么叫解耦。那就是函数中不能出现全局变量或者写死某个值或变量。

    我的这段代码就是没有解耦，比如stu_insert函数中就出现这样的代码

    1. previous = &g_stuDaynamic;
    2. current = g_stuDaynamic.next;

    高度耦合。

    所以后面的代码修改方向就是需要解耦。

    3.2.2.3 解耦代码

    2024年1月16日 11:16:16

    下面是解耦的代码，

    搞的头炸啊！

    //lianbiao.c文件

    1. #include "lianbiao.h"
    2.  
    3. void func()
    4. {
    5.     printf("hello\n");
    6. }
    7.  
    8. bool isTargetCharacter(char* choose)
    9. {
    10.     if(choose[0] == 'A' || choose[0] == 'I' || choose[0] == 'D' || choose[0] == 'M' || choose[0] == 'F')
    11.     {
    12.         return true;
    13.     }
    14.  
    15.     return false;
    16. }
    17.  
    18. //这边printf也是有问题的，我也是把跟指针当做value=0在用，从第二个节点开始打印。同理，我的add函数也是等于是从value=0结构后面加的
    19. void print_lianbiao(lianbiao* stu)
    20. {
    21.     lianbiao* root = stu;
    22.     lianbiao* current = root->next;
    23.     while(current != NULL)
    24.     {
    25.         printf("姓名:%s,年龄:%d,性别:%d,成绩:%d\n", current->name, current->age, current->gender, current->score);
    26.         current = current->next;
    27.     }
    28. }
    29.  
    30. int stu_add1(lianbiao* stu, lianbiao* new_stu)
    31. {
    32.     while(stu == NULL)
    33.     {
    34.         return 0;
    35.     }
    36.  
    37.     lianbiao* previous = stu;
    38.     lianbiao** current = &previous->next;
    39.  
    40.     while(*current != NULL)
    41.     {
    42.         *current = (*current)->next;
    43.     }
    44.  
    45.     *current = new_stu;
    46.     return 1;
    47. }
    48.  
    49. int stu_add2(lianbiao* stu, lianbiao* new_stu)
    50. {
    51.     while(stu == NULL)
    52.     {
    53.         return 0;
    54.     }
    55.  
    56.     lianbiao* previous = stu;
    57.     lianbiao* current = previous->next;
    58.  
    59.     while(current != NULL)
    60.     {
    61.         current = current->next;
    62.     }
    63.  
    64.     lianbiao** p = ¤t;
    65.     *p = new_stu;
    66.     return 1;
    67. }
    68.  
    69. //吊毛，槽，这样写竟然就可以了，妈的，自己捣鼓一晚上都没弄好。看了书就好了
    70. int stu_add(lianbiao* stu, lianbiao* new_stu)
    71. {
    72.     while(stu == NULL)
    73.     {
    74.         return 0;
    75.     }
    76.  
    77.     lianbiao* previous = stu;           //stu是二级指针，解引用一次，里面的成员都可以被成功赋值
    78.     lianbiao* current = previous->next;     //现在复盘，大概是previous->next可以被赋值。但是现在的操作是previous->next赋值给previous，再去更改previous的值就更改不了next的值
    79.  
    80.     while(current != NULL)
    81.     {
    82.         previous = current;
    83.         current = current->next;
    84.     }
    85.  
    86.     previous->next = new_stu;
    87.  
    88.     return 1;
    89. }
    90.  
    91. int action_add(lianbiao* stu_lianbiao)
    92. {
    93.     char name[10];
    94.     int age;
    95.     int gender;
    96.     int score;
    97.     //lianbiao stu;       //这边好像不能写局部变量，栈上申请内存，感觉每次的地址是一样的额
    98.  
    99.     printf("输入需要增加(add)的数据, age=0时退出add操作:\n");
    100.     while(1)
    101.     {
    102.         printf("输入姓名、年龄、性别、成绩\n");
    103.         scanf("%s %d %d %d", name, &age, &gender, &score);
    104.         if(age == 0)
    105.         {
    106.             break;
    107.         }
    108.         lianbiao* stu = (lianbiao*)malloc(sizeof(lianbiao));
    109.         strcpy(stu->name, name);
    110.         stu->age = age;
    111.         stu->gender = gender;
    112.         stu->score = score;
    113.         stu->next = NULL;        //忘了写
    114.         if(stu_add(stu_lianbiao, stu))
    115.         {
    116.             printf("添加成功\n");
    117.         }
    118.     }
    119.     print_lianbiao(stu_lianbiao);
    120.     printf("结束添加add操作\n");
    121. }
    122.  
    123. //这个没有传入根指针的二级指针，竟然也成功了
    124. //我是把根指针当做一个value=0的节点在用了，所以都是在后面add
    125. int stu_insert(lianbiao* stu, lianbiao* new_stu)
    126. {
    127.     if(stu == NULL)
    128.     {
    129.         return 0;
    130.     }
    131.  
    132.     lianbiao* previous = NULL;
    133.     lianbiao* current = stu;
    134.  
    135.     while(current != NULL && current->score < new_stu->score)           //这个地方关于current->score < new_stu->score我是存在疑问的。但是实际调试的时候score的值是0.只能理解为全局变量会被初始化为0
    136.     {
    137.         previous = current;
    138.         current = current->next;
    139.     }
    140.  
    141.     if(current == NULL)                                 //这边我还是没有真正的理解书中表达的意思。这边应该写成previous == NULL
    142.     {
    143.         previous->next = new_stu;
    144.     }
    145.     else
    146.     {
    147.         previous->next = new_stu;
    148.         new_stu->next = current;
    149.     }
    150.  
    151.     return 1;
    152. }
    153.  
    154. void action_insert(lianbiao* stu_lianbiao)
    155. {
    156.     char name[10];
    157.     int age;
    158.     int gender;
    159.     int score;
    160.  
    161.     printf("输入需要插入(insert)的数据, age=0时退出insert操作:\n");
    162.     while(1)
    163.     {
    164.         printf("输入姓名、年龄、性别、成绩\n");
    165.         scanf("%s %d %d %d", name, &age, &gender, &score);
    166.         if(age == 0)
    167.         {
    168.             break;
    169.         }
    170.         lianbiao* stu = (lianbiao*)malloc(sizeof(lianbiao));
    171.         strcpy(stu->name, name);
    172.         stu->age = age;
    173.         stu->gender = gender;
    174.         stu->score = score;
    175.         stu->next = NULL;        //忘了写
    176.         if(stu_insert(stu_lianbiao, stu))
    177.         {
    178.             printf("添加成功\n");
    179.             print_lianbiao(stu_lianbiao);
    180.         }
    181.     }
    182.  
    183.     printf("结束添加add操作\n");
    184. }
    185.  
    186. void stu_list_func(lianbiao* stu_lianbiao)
    187. {
    188.     bool flag = true;
    189.     char choose[10];
    190.     printf("欢迎进入学生信息管理系统\n");
    191.     while(flag)
    192.     {
    193.         printf("选择操作A:增加、I:插入、D:删除、M:修改、F:查找\n");
    194.         scanf("%s", choose);
    195.         if(!isTargetCharacter(choose))
    196.         {
    197.             continue;
    198.         }
    199.  
    200.         switch(choose[0])
    201.         {
    202.         case 'A':
    203.             {
    204.                 action_add(stu_lianbiao);
    205.  
    206.                 break;
    207.             }
    208.  
    209.         case 'I':
    210.             {
    211.                 action_insert(stu_lianbiao);
    212.                 break;
    213.             }
    214.  
    215.         case 'D':
    216.             {
    217.                 break;
    218.             }
    219.  
    220.         case 'M':
    221.             {
    222.                 break;
    223.             }
    224.  
    225.         case 'F':
    226.             {
    227.                 break;
    228.             }
    229.  
    230.         case 'Q':
    231.             {
    232.                 flag = false;
    233.                 break;
    234.             }
    235.  
    236.         default:
    237.             {
    238.                 break;
    239.             }
    240.         }
    241.     }
    242. }
    243.  
    244. //D:\APP\codeBlock\ADTlianbiao\main.c
    245. //12, 7
    246. //Hello world!
    247. //欢迎进入学生信息管理系统
    248. //选择操作A:增加、I:插入、D:删除、M:修改、F:查找
    249. //A
    250. //输入需要增加(add)的数据, age=0时退出add操作:
    251. //输入姓名、年龄、性别、成绩
    252. //zhangs 7 0 77
    253. //添加成功
    254. //输入姓名、年龄、性别、成绩
    255. //lilu 8 1 88
    256. //添加成功
    257. //输入姓名、年龄、性别、成绩
    258. //wangmei 9 0 99
    259. //添加成功
    260. //输入姓名、年龄、性别、成绩
    261. //bv 0 0 0
    262. //姓名:zhangs,年龄:7,性别:0,成绩:77
    263. //姓名:lilu,年龄:8,性别:1,成绩:88
    264. //姓名:wangmei,年龄:9,性别:0,成绩:99
    265. //结束添加add操作
    266. //选择操作A:增加、I:插入、D:删除、M:修改、F:查找
    267. //I
    268. //输入需要插入(insert)的数据, age=0时退出insert操作:
    269. //输入姓名、年龄、性别、成绩
    270. //xiaoming 6 0 66
    271. //添加成功
    272. //姓名:xiaoming,年龄:6,性别:0,成绩:66
    273. //姓名:zhangs,年龄:7,性别:0,成绩:77
    274. //姓名:lilu,年龄:8,性别:1,成绩:88
    275. //姓名:wangmei,年龄:9,性别:0,成绩:99
    276. //输入姓名、年龄、性别、成绩
    277. //xiaohong 9 1 101
    278. //添加成功
    279. //姓名:xiaoming,年龄:6,性别:0,成绩:66
    280. //姓名:zhangs,年龄:7,性别:0,成绩:77
    281. //姓名:lilu,年龄:8,性别:1,成绩:88
    282. //姓名:wangmei,年龄:9,性别:0,成绩:99
    283. //姓名:xiaohong,年龄:9,性别:1,成绩:101
    284. //输入姓名、年龄、性别、成绩
    285. //xc 0 0 0
    286. //结束添加add操作
    287.

    //lianbiao.h

    1. #ifndef LIANBIAO_H
    2. #define LIANBIAO_H
    3.  
    4. #include "stdio.h"
    5. #include 
    6. #include 
    7.  
    8. typedef struct Lianbiao
    9. {
    10.     char name[10];
    11.     int age;
    12.     int gender;
    13.     int score;
    14.     struct Lianbiao* next;
    15. }lianbiao;
    16.  
    17. typedef struct TEST
    18. {
    19.     int a;
    20.     int* p;
    21. }Test;
    22.  
    23. void func();
    24.  
    25. void stu_list_func(lianbiao* stu_lianbiao);
    26.  
    27. #endif // LIANBIAO_H

    //main.c

    1. #include 
    2. #include 
    3.  
    4. #include "lianbiao.h"
    5.  
    6. lianbiao g_stu_lianbiao;
    7.  
    8. int testFun(Test* test)
    9. {
    10.     test->a = 12;
    11.     int* b  = (int*)malloc(sizeof(int));
    12.     *b = 7;
    13.     int* p = test->p;
    14.     p = b;      //这样写不能正常赋值
    15.  
    16.     int **q = &(test->p);       //不需要加括号，->运算符优先级高于&和*
    17.     *q = b;     //这样写可以正常赋值
    18. }
    19.  
    20. int main()
    21. {
    22.     printf("%s\n", __FILE__);
    23.  
    24.     Test test;
    25.     testFun(&test);
    26.     printf("%d, %d", test.a, *test.p);
    27.  
    28.     printf("Hello world!\n");
    29.     int *p = &g_stu_lianbiao;
    30.     stu_list_func(&g_stu_lianbiao);
    31.     return 0;
    32. }

    看打印记录感觉代码正常运行了。实际上上面的代码还是有问题，那就是我一直都其实没有理解根节点指针（rootp）是什么意思。在上面的diamante中，我其实一直都是这么用的。那就是将根节点指针指向的value=0的节点当做跟指针在用。（实际上g_stu_lianbiao的初始化就是0）。

    这也是我为什么打印的时候会跳过一个节点，写的奇奇怪怪。

    1. lianbiao* root = stu;
    2. lianbiao* current = root->next;

    上面显示我把root->next当做current。root->score所在的节点被我跳过了。

    3.2.2.4 解耦阶段二

    //lianbiao.h

    1. #ifndef LIANBIAO_H
    2. #define LIANBIAO_H
    3.  
    4. #include "stdio.h"
    5. #include 
    6. #include 
    7.  
    8. typedef struct Lianbiao
    9. {
    10.     char name[10];
    11.     int age;
    12.     int gender;
    13.     int score;
    14.     struct Lianbiao* next;
    15. }lianbiao;
    16.  
    17. typedef struct TEST
    18. {
    19.     int a;
    20.     int* p;
    21. }Test;
    22.  
    23. void func();
    24.  
    25. void stu_list_func(lianbiao** stu_lianbiao);
    26.  
    27. #endif // LIANBIAO_H

    //lianbiao.c

    1. #include "lianbiao.h"
    2.  
    3. void func()
    4. {
    5.     printf("hello\n");
    6. }
    7.  
    8. bool isTargetCharacter(char* choose)
    9. {
    10.     if(choose[0] == 'A' || choose[0] == 'I' || choose[0] == 'D' || choose[0] == 'M' || choose[0] == 'F')
    11.     {
    12.         return true;
    13.     }
    14.  
    15.     return false;
    16. }
    17.  
    18. //这边printf也是有问题的，我也是把跟指针当做value=0在用，从第二个节点开始打印。同理，我的add函数也是等于是从value=0结构后面加的
    19. void print_lianbiao1(lianbiao* stu)
    20. {
    21.     lianbiao* root = stu;
    22.     lianbiao* current = root->next;
    23.     while(current != NULL)
    24.     {
    25.         printf("姓名:%s,年龄:%d,性别:%d,成绩:%d\n", current->name, current->age, current->gender, current->score);
    26.         current = current->next;
    27.     }
    28. }
    29.  
    30. void print_lianbiao(lianbiao** stu)
    31. {
    32.     lianbiao* current = *stu;
    33.     while(current != NULL)
    34.     {
    35.         printf("姓名:%s,年龄:%d,性别:%d,成绩:%d\n", current->name, current->age, current->gender, current->score);
    36.         current = current->next;
    37.     }
    38. }
    39.  
    40. int stu_add1(lianbiao* stu, lianbiao* new_stu)
    41. {
    42.     while(stu == NULL)
    43.     {
    44.         return 0;
    45.     }
    46.  
    47.     lianbiao* previous = stu;
    48.     lianbiao** current = &previous->next;
    49.  
    50.     while(*current != NULL)
    51.     {
    52.         *current = (*current)->next;
    53.     }
    54.  
    55.     *current = new_stu;
    56.     return 1;
    57. }
    58.  
    59. int stu_add2(lianbiao* stu, lianbiao* new_stu)
    60. {
    61.     while(stu == NULL)
    62.     {
    63.         return 0;
    64.     }
    65.  
    66.     lianbiao* previous = stu;
    67.     lianbiao* current = previous->next;
    68.  
    69.     while(current != NULL)
    70.     {
    71.         current = current->next;
    72.     }
    73.  
    74.     lianbiao** p = ¤t;
    75.     *p = new_stu;
    76.     return 1;
    77. }
    78.  
    79. //吊毛，槽，这样写竟然就可以了，妈的，自己捣鼓一晚上都没弄好。看了书就好了
    80. int stu_add3(lianbiao* stu, lianbiao* new_stu)
    81. {
    82.     while(stu == NULL)
    83.     {
    84.         return 0;
    85.     }
    86.  
    87.     lianbiao* previous = stu;           //stu是二级指针，解引用一次，里面的成员都可以被成功赋值
    88.     lianbiao* current = previous->next;     //现在复盘，大概是previous->next可以被赋值。但是现在的操作是previous->next赋值给previous，再去更改previous的值就更改不了next的值
    89.  
    90.     while(current != NULL)
    91.     {
    92.         previous = current;
    93.         current = current->next;
    94.     }
    95.  
    96.     previous->next = new_stu;
    97.  
    98.     return 1;
    99. }
    100.  
    101. int stu_add(lianbiao** stu, lianbiao* new_stu)
    102. {
    103.     while(stu == NULL)
    104.     {
    105.         return 0;
    106.     }
    107.  
    108.     lianbiao* previous = NULL;           //stu是二级指针，解引用一次，里面的成员都可以被成功赋值
    109.     lianbiao* current = *stu;     //现在复盘，大概是previous->next可以被赋值。但是现在的操作是previous->next赋值给previous，再去更改previous的值就更改不了next的值
    110.  
    111.     while(current != NULL)
    112.     {
    113.         previous = current;
    114.         current = current->next;
    115.     }
    116.  
    117.     if(previous == NULL)
    118.     {
    119.         *stu = new_stu;
    120.     }
    121.     else
    122.     {
    123.         previous->next = new_stu;
    124.         new_stu->next = current;
    125.     }
    126.  
    127.     return 1;
    128. }
    129.  
    130. int action_add(lianbiao** stu_lianbiao)
    131. {
    132.     char name[10];
    133.     int age;
    134.     int gender;
    135.     int score;
    136.     //lianbiao stu;       //这边好像不能写局部变量，栈上申请内存，感觉每次的地址是一样的额
    137.  
    138.     printf("输入需要增加(add)的数据, age=0时退出add操作:\n");
    139.     while(1)
    140.     {
    141.         printf("输入姓名、年龄、性别、成绩\n");
    142.         scanf("%s %d %d %d", name, &age, &gender, &score);
    143.         if(age == 0)
    144.         {
    145.             break;
    146.         }
    147.         lianbiao* stu = (lianbiao*)malloc(sizeof(lianbiao));
    148.         strcpy(stu->name, name);
    149.         stu->age = age;
    150.         stu->gender = gender;
    151.         stu->score = score;
    152.         stu->next = NULL;        //忘了写
    153.         if(stu_add(stu_lianbiao, stu))
    154.         {
    155.             printf("添加成功\n");
    156.             print_lianbiao(stu_lianbiao);
    157.         }
    158.     }
    159.  
    160.     printf("结束添加add操作\n");
    161. }
    162.  
    163. //这个没有传入根指针的二级指针，竟然也成功了
    164. //我是把根指针当做一个value=0的节点在用了，所以都是在后面add
    165. int stu_insert1(lianbiao* stu, lianbiao* new_stu)
    166. {
    167.     if(stu == NULL)
    168.     {
    169.         return 0;
    170.     }
    171.  
    172.     lianbiao* previous = NULL;
    173.     lianbiao* current = stu;
    174.  
    175.     while(current != NULL && current->score < new_stu->score)           //这个地方关于current->score < new_stu->score我是存在疑问的。但是实际调试的时候score的值是0.只能理解为全局变量会被初始化为0
    176.     {
    177.         previous = current;
    178.         current = current->next;
    179.     }
    180.  
    181.     if(current == NULL)                                 //这边我还是没有真正的理解书中表达的意思。这边应该写成previous == NULL
    182.     {
    183.         previous->next = new_stu;
    184.     }
    185.     else
    186.     {
    187.         previous->next = new_stu;
    188.         new_stu->next = current;
    189.     }
    190.  
    191.     return 1;
    192. }
    193.  
    194. int stu_insert(lianbiao** stu, lianbiao* new_stu)
    195. {
    196.     if(stu == NULL)
    197.     {
    198.         return 0;
    199.     }
    200.  
    201.     lianbiao* previous = NULL;
    202.     lianbiao* current = *stu;
    203.  
    204.     while(current != NULL && current->score < new_stu->score)           //这个地方关于current->score < new_stu->score我是存在疑问的。但是实际调试的时候score的值是0.只能理解为全局变量会被初始化为0
    205.     {
    206.         previous = current;
    207.         current = current->next;
    208.     }
    209.  
    210.     if(previous == NULL)                                 //这边我还是没有真正的理解书中表达的意思。这边应该写成previous == NULL
    211.     {
    212.         *stu = new_stu;
    213.     }
    214.     else
    215.     {
    216.         previous->next = new_stu;
    217.  
    218.     }
    219.     new_stu->next = current;            //靠这个一直没在意，调试的时候才发现
    220.  
    221.     return 1;
    222. }
    223.  
    224. void action_insert(lianbiao* stu_lianbiao)
    225. {
    226.     char name[10];
    227.     int age;
    228.     int gender;
    229.     int score;
    230.  
    231.     printf("输入需要插入(insert)的数据, age=0时退出insert操作:\n");
    232.     while(1)
    233.     {
    234.         printf("输入姓名、年龄、性别、成绩\n");
    235.         scanf("%s %d %d %d", name, &age, &gender, &score);
    236.         if(age == 0)
    237.         {
    238.             break;
    239.         }
    240.         lianbiao* stu = (lianbiao*)malloc(sizeof(lianbiao));
    241.         strcpy(stu->name, name);
    242.         stu->age = age;
    243.         stu->gender = gender;
    244.         stu->score = score;
    245.         stu->next = NULL;        //忘了写
    246.         if(stu_insert(stu_lianbiao, stu))
    247.         {
    248.             printf("添加成功\n");
    249.             print_lianbiao(stu_lianbiao);
    250.         }
    251.     }
    252.  
    253.     printf("结束添加add操作\n");
    254. }
    255.  
    256. void stu_list_func(lianbiao** stu_lianbiao)
    257. {
    258.     bool flag = true;
    259.     char choose[10];
    260.     printf("欢迎进入学生信息管理系统\n");
    261.     while(flag)
    262.     {
    263.         printf("选择操作A:增加、I:插入、D:删除、M:修改、F:查找\n");
    264.         scanf("%s", choose);
    265.         if(!isTargetCharacter(choose))
    266.         {
    267.             continue;
    268.         }
    269.  
    270.         switch(choose[0])
    271.         {
    272.         case 'A':
    273.             {
    274.                 action_add(stu_lianbiao);
    275.  
    276.                 break;
    277.             }
    278.  
    279.         case 'I':
    280.             {
    281.                 action_insert(stu_lianbiao);
    282.                 break;
    283.             }
    284.  
    285.         case 'D':
    286.             {
    287.                 break;
    288.             }
    289.  
    290.         case 'M':
    291.             {
    292.                 break;
    293.             }
    294.  
    295.         case 'F':
    296.             {
    297.                 break;
    298.             }
    299.  
    300.         case 'Q':
    301.             {
    302.                 flag = false;
    303.                 break;
    304.             }
    305.  
    306.         default:
    307.             {
    308.                 break;
    309.             }
    310.         }
    311.     }
    312. }
    313.  
    314. //D:\APP\codeBlock\ADTlianbiao\main.c
    315. //12, 7
    316. //Hello world!
    317. //欢迎进入学生信息管理系统
    318. //选择操作A:增加、I:插入、D:删除、M:修改、F:查找
    319. //A
    320. //输入需要增加(add)的数据, age=0时退出add操作:
    321. //输入姓名、年龄、性别、成绩
    322. //zhangs 7 0 77
    323. //添加成功
    324. //姓名:zhangs,年龄:7,性别:0,成绩:77
    325. //输入姓名、年龄、性别、成绩
    326. //lilu 8 1 88
    327. //添加成功
    328. //姓名:zhangs,年龄:7,性别:0,成绩:77
    329. //姓名:lilu,年龄:8,性别:1,成绩:88
    330. //输入姓名、年龄、性别、成绩
    331. //wangmei 9 0 99
    332. //添加成功
    333. //姓名:zhangs,年龄:7,性别:0,成绩:77
    334. //姓名:lilu,年龄:8,性别:1,成绩:88
    335. //姓名:wangmei,年龄:9,性别:0,成绩:99
    336. //输入姓名、年龄、性别、成绩
    337. //vc 0 0 0
    338. //结束添加add操作
    339. //选择操作A:增加、I:插入、D:删除、M:修改、F:查找
    340. //I
    341. //输入需要插入(insert)的数据, age=0时退出insert操作:
    342. //输入姓名、年龄、性别、成绩
    343. //xiaoming 6 0 66
    344. //添加成功
    345. //姓名:xiaoming,年龄:6,性别:0,成绩:66
    346. //姓名:zhangs,年龄:7,性别:0,成绩:77
    347. //姓名:lilu,年龄:8,性别:1,成绩:88
    348. //姓名:wangmei,年龄:9,性别:0,成绩:99
    349. //输入姓名、年龄、性别、成绩
    350. //hanxue 9 1 102
    351. //添加成功
    352. //姓名:xiaoming,年龄:6,性别:0,成绩:66
    353. //姓名:zhangs,年龄:7,性别:0,成绩:77
    354. //姓名:lilu,年龄:8,性别:1,成绩:88
    355. //姓名:wangmei,年龄:9,性别:0,成绩:99
    356. //姓名:hanxue,年龄:9,性别:1,成绩:102
    357. //输入姓名、年龄、性别、成绩
    358. //wuhu 7 0 82
    359. //添加成功
    360. //姓名:xiaoming,年龄:6,性别:0,成绩:66
    361. //姓名:zhangs,年龄:7,性别:0,成绩:77
    362. //姓名:wuhu,年龄:7,性别:0,成绩:82
    363. //姓名:lilu,年龄:8,性别:1,成绩:88
    364. //姓名:wangmei,年龄:9,性别:0,成绩:99
    365. //姓名:hanxue,年龄:9,性别:1,成绩:102
    366. //输入姓名、年龄、性别、成绩
    367. //vc 0 0 0
    368. //结束添加add操作
    369. //选择操作A:增加、I:插入、D:删除、M:修改、F:查找
    370.

    //main.c

    1. #include 
    2. #include 
    3.  
    4. #include "lianbiao.h"
    5.  
    6. lianbiao* g_stu_lianbiao = NULL;
    7.  
    8. int testFun(Test* test)
    9. {
    10.     test->a = 12;
    11.     int* b  = (int*)malloc(sizeof(int));
    12.     *b = 7;
    13.     int* p = test->p;
    14.     p = b;      //这样写不能正常赋值
    15.  
    16. //    int **q = &(test->p);       //不需要加括号，->运算符优先级高于&和*
    17. //    *q = b;     //这样写可以正常赋值
    18.  
    19.     test->p = b;        //离谱的是，这样也可以更改结构体中指针的值
    20. }
    21.  
    22. //这里的问题是test是个指针，指向一块内存。test指针指向的内存中的数据可以更改。因为确实是对真实内存进行修改
    23. //链表中的问题是，更改根节点的值。指针的值是值传递，无法修改。所以要传递地址的地址
    24.  
    25. int main()
    26. {
    27.     printf("%s\n", __FILE__);
    28.  
    29.     Test test;
    30.     testFun(&test);
    31.     printf("%d, %d\n", test.a, *test.p);
    32.  
    33.     printf("Hello world!\n");
    34.     int *p = &g_stu_lianbiao;
    35.     stu_list_func(&g_stu_lianbiao);
    36.     return 0;
    37. }

    上面的代码就实现了C和指针里面的链表。

    2024年1月17日09:36:36

    今天还回顾了一下链表，理了一下，下面的是画的图

    所以对malloc也理解了一些。就是malloc申请了一块内存空间。用一个指针p指向那块内存。 

    四、编译报错处理

    4.1 报错1

    implicit declaration of function 'toupper' [-Wimplicit-function-declaration]

    加上头文件"ctype.h"就不报错了。但是按理没有加头文件程序不能执行啊。但是没有头文件程序也是正常执行了。

    翻译：函数'toupper'的隐式声明

    总结

    提示：这里对文章进行总结：
    例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

  • 相关阅读:
    unordered_map的键值不能直接用pair；而map 可以使用 pair 作为键值，而不需要额外定义哈希函数
    OpenJudge NOI 1.13 51:古代密码
    node 第十九天 使用node插件node-jsonwebtoken实现身份令牌jwt认证
    天翼物联与华为联合发布5GtoB终端认证标准2.0
    Leecode专题——回溯系列
    （二）Three光线检测-实现摄像机向鼠标点击位置滑动动画
    MySQL、高级SQL操作
    Unity-Input System新输入系统插件学习
    基于Springboot实现网上商城管理系统演示【项目源码+论文说明】
    消息队列MQ
  • 原文地址：https://blog.csdn.net/2301_77560238/article/details/133673397