C语言初识2

一、结构体

1.1：概念

1.1.1：为了将不同的数据整合成一个有机整体，以便于引用

1.1.2： C与C++

C语言面向过程 C++面向对象

1.1.3：定义方法1（仅声明）

1. struct 结构名{
2. 类型说明符 成员名；
5. ....
6. （成员列表）
7. };
9. struct student {
10. int num;
11. char name[10];
12. char sex;
13. int age;
14. float score;
15. char addr[30];
16. };

复制代码

1.1.4：定义方法2（声明的同时定义变量）

1. struct 结构名{
2. 类型说明符 成员名；
5. ....
6. （成员列表）
7. }变量名列表;
10. struct student {
11. int num;
12. char name[10];
13. char sex;
14. int age;
15. float score;
16. char addr[30];
17. }student1,student2;

复制代码

1.1.5：结构体变量的大小

1.1.5.1：例子1

1. struct student {
2. int num;
3. char name[10];
4. char sex;
5. int age;
6. float score;
7. char addr[30];
8. }student1,student2;
10. int main() {
12. printf("%d", sizeof(student1));
15. return 0;
16. }
18. 结果：
19. 56

复制代码

1.1.5.2：例子2

1. struct student {
2. int num;
3. char name[10];
4. char sex[5];
5. int age;
6. float score;
7. char addr[30];
8. }student1,student2;
10. int main() {
12. printf("%d", sizeof(student1));
15. return 0;
16. }
18. 输出：
19. 60

复制代码

1.1.5.3：分析过程

1.1.5.4：总结

• 对齐的是当前结构体中最大的数据类型的字节量：

  • 比如最大的是double，那就是要对齐8字节
  • 比如最大的是Int,那就是对齐4字节

• 当遇到数组时，要不要和下一项进行合并，要不要和下下一项进行合并，诸如此类的问题，遵循一个原则：
  合并，直到下一个数据本身就对齐

  • 比如例子2，因为char [10] 和char [5]都没对齐，所以合并，但int age 是对齐的，所以要在这之前进行补齐

1.1.6：定义方法3（无结构体名，直接定义变量）

1. struct {
2. int num;
3. char name[10];
4. char sex[5];
5. int age;
6. float score;
7. char addr[30];
8. }student1,student2;

复制代码

1.1.7：定义变量

• 1. struct 结构体名 变量名

  复制代码

• struct student 是结构体类型

• 1. sizeof(student) 是错误的
  2. sizeof(struct student) 是正确的

  复制代码

1.2：结构体变量的使用以及初始化

1.2.1：不能将结构体变量作为一个整体输入和输出

1.2.2：正确使用格式是： 结构体变量.成员

• “.”是成员运算符，在所有运算符中优先级最高；所以可以将

  结构体变量.成员 看作一个整体

• 例子

  1. struct {
  2. int num;
  3. char name[10];
  4. char sex[5];
  5. int age;
  6. float score;
  7. char addr[30];
  8. }student1,student2;
  10. struct data {
  11. int year;
  12. int month;
  13. int day;
  14. };
  15. struct people {
  16. int num;
  17. char name[20];
  18. struct data birthday;
  19. float score;
  20. }boy1,boy2;
  22. int main() {
  24. //printf("%d", sizeof(student1));
  26. printf("please input num:");
  27. scanf("%d", &boy1.num);
  29. printf("please input name:");
  30. scanf("%s", &boy1.name);
  32. printf("please input birthday:");
  33. scanf("%d%d%d", &boy1.birthday.year, &boy1.birthday.month, &boy1.birthday.day);
  35. printf("please input score:");
  36. scanf("%f", &boy1.score);
  38. printf("学号：%d\t姓名：%s\t生日：%d-%d-%d\t成绩：%f\n", boy1.num, boy1.name, boy1.birthday.year, boy1.birthday.month, boy1.birthday.day, boy1.score);
  41. boy2 = boy1;
  42. printf("%p\n", &boy1);
  43. printf("%p\n", &boy1.birthday);
  44. printf("%p\n", &boy2);
  46. return 0;
  47. }
  49. 输入：
  50. please input num:521
  51. please input name:liukai
  52. please input birthday:2001 6 8
  53. please input score:542.35
  54. 输出：
  55. 学号：521 姓名：liukai 生日：2001-6-8 成绩：542.349976
  56. 00007FF630BCD7A0
  57. 00007FF62A41D7B8
  58. 00007FF630BCD760
  60. 分析：可以看出结构体变量可以和其他变量一样进行成员赋值和变量之间的赋值

  复制代码

1.2.3：结构体变量初始化

1.2.3.1：定义时初始化

1. struct data {
2. int year;
3. int month;
4. int day;
5. };
6. struct people {
7. int num;
8. char name[20];
9. struct data birthday;
10. float score;
11. }boy1 = { 123,"liukai",{2001,6,11},963.256 }, boy2 ;
13. int main() {
15. //printf("%d", sizeof(student1));
17. //printf("please input num:");
18. //scanf("%d", &boy1.num);
20. //printf("please input name:");
21. //scanf("%s", &boy1.name);
23. //printf("please input birthday:");
24. //scanf("%d%d%d", &boy1.birthday.year, &boy1.birthday.month, &boy1.birthday.day);
26. //printf("please input score:");
27. //scanf("%f", &boy1.score);
29. printf("学号：%d\t姓名：%s\t生日：%d-%d-%d\t成绩：%f\n", boy1.num, boy1.name, boy1.birthday.year, boy1.birthday.month, boy1.birthday.day, boy1.score);
32. boy2 = boy1;
33. printf("%p\n", &boy1);
34. printf("%p\n", &boy1.birthday);
35. printf("%p\n", &boy2);
37. return 0;
38. }
41. 分析：需要值得注意的是，嵌套结构体的初始化要拿个{}括起来；
42. 在初始化嵌套结构体时，花括号的作用主要有两个：
43. 1、区分嵌套结构体的初始化值和外层结构体的其他成员初始化值，
44. 2、以及明确嵌套结构体自身成员的初始化顺序。

复制代码

1.2.3.2：常见错误

1. //只能在定义的时候进行整个初始化
2. case1:
3. struct people {
4. int num;
5. char name[20];
6. struct data birthday;
7. float score;
8. }boy1 = { 123,"liukai",{2001,6,11},963.256 }, boy2 ;
9. case2:
10. struct people boy3 = { 123,"liukai",{2001,6,11},963.256 }
11. case3:
12. struct people boy[2] = { { 123,"liukai",{2001,6,11},963.256 } ,{ 123,"liukai",{2001,6,11},963.256 } };
16. //这种定义之后再进行整个初始化的行为是错的
17. struct people boy[2];
18. boy[0] = { 123,"liukai",{2001,6,11},963.256 };
19. printf("学号：%d\t姓名：%s\t生日：%d-%d-%d\t成绩：%f\n", boy[0].num, boy[0].name, boy[0].birthday.year, boy[0].birthday.month, boy[0].birthday.day, boy[0].score);
21. 分析：
22. 后续试图通过 boy[0] = { 123,"liukai",{2001,6,11},963.256 };C 语言中，结构体变量初始化通常需要在定义时进行，或使用循环等逐个成员赋值的方式。

复制代码

1.3：结构体数组

1.3.1：定义

一个学生有好几个属性，但现在有十个学生；此时用的数组就是结构体数组。

1.3.2：初始化

1. struct people boy[2] = { { 123,"liukai",{2001,6,11},963.256 } ,{ 123,"liukai",{2001,6,11},963.256 } };

复制代码

1. struct people {
2. int num;
3. char name[20];
4. struct data birthday;
5. float score;
6. }boy[2] = { { 123,"liukai",{2001,6,11},963.256 } ,{ 123,"liukai",{2001,6,11},963.256 } };

复制代码

1.4：指向结构体类型数据的指针

1.4.1：定义

• 1. struct 结构名 *结构体指针变量

  复制代码

• 和结构体变量一样，也可以在定义结构体时直接进行声明定义

1.4.2：访问成员方式

• 结构指针变量->成员名

• *(结构指针变量).成员名

1. struct data {
2. int year;
3. int month;
4. int day;
5. };
6. struct people {
7. int num;
8. char name[20];
9. struct data birthday;
10. float score;
11. }boy[2] = { { 1234,"liukai",{2001,6,11},963.256 } ,{ 123,"liukai",{2001,6,11},963.256 } };
15. struct people *pboy=&boy[1];
16. printf("%d-%d-%d\n", pboy->birthday.year, pboy->birthday.month, pboy->birthday.day);
19. 分析：
20. 1、在pboy->birthday.year中，第二个地方使用.而不是->是因为birthday是结构体people中的一个成员，它本身是一个结构体类型（struct data），而不是一个指针。
21. 2、*pboy.birthday.year这种写法也是错误的，必须是(*pboy).birthday.year
22. 2.1、在C语言中，成员访问运算符->和.的优先级高于解引用运算符*。
23. 2.2、表达式*pboy.birthday.year会被错误地解析，因为编译器会优先处理.运算符。编译器会先尝试访问pboy这个指针对象的birthday成员，而不是首先解引用指针。

复制代码

1.5：结构体做函数参数

1.5.1：用结构体变量做函数参数

1. void dayin(struct people boy )
2. {
3. printf("%d", boy.num);
4. }

复制代码

1.5.2：用结构体变量指针做函数参数

1. void dayin(struct people *boy )
2. {
3. printf("%d", boy->num);
4. }

复制代码

二：链表

2.1：动态存储分配

541069.png&pos_id=img-blXEHShX-1745762881147)

2.1.1： malloc

2.1.2： free

2.2：链表

2.2.1：概念

• 链表是一种常见的数据结构，是动态的进行存储分配的一种结构

• 链表的组成

  • 头指针：存储一个地址，该地址指向第一个元素

  • 结点：用户需要的实际数据和链接结点的指针

2.2.2：静态链表的建立

1. struct score {
2. int math;
3. int english;
4. };
5. struct student {
6. int num;
7. struct score scr;
8. struct student* next;
9. };
11. int main() {
13. struct student stu1, stu2, * head,*temp;
14. head = &stu1;
15. stu1.next = &stu2;
16. stu2.next = NULL;
17. stu1.num = 1;
18. stu1.scr.math = 100;
19. stu1.scr.english = 10;
20. stu2.num = 2;
21. stu2.scr.math = 99;
22. stu2.scr.english = 9;
24. temp = head;
25. while (temp != NULL) {
26. printf("%d-",temp->num);
27. printf("%d-",temp->scr.math);
28. printf("%d\n", temp->scr.english);
29. temp = temp->next;
30. }
31. return 0;
32. }

复制代码

2.2.3：动态链表的建立

首先是当前结点的建立

case1：结束结点

case2：头节点

case3：后续节点

• 所谓动态链表的建立指的是在程序执行过程中，从无到有的建立起一个链表，即一个一个的开辟结点空间和输入结点数据，并建立起前后链接的关系

1. #define _CRT_SECURE_NO_WARNINGS // 必须放在第一行！
2. #include<stdio.h>
3. #include<stdlib.h>
4. struct score {
5. int math;
6. int english;
7. };
8. struct student {
9. int num;
10. struct score scr;
11. struct student* next;
12. };
14. struct student* creat() {
15. int n = 0;
16. struct student* head, * p,*tail;
17. head = p = tail = NULL;
18. while (1) {
19. //创建节点
20. p = (struct student*)malloc(sizeof(struct student));
21. //赋初始值
22. printf("input your num:");
23. scanf("%d", &p->num);
24. printf("input your math:");
25. scanf("%d", &p->scr.math);
26. printf("input your english:");
27. scanf("%d", &p->scr.english);
28. p->next = NULL;
29. //判断结束条件
30. if (p->num == 0) {
31. printf("input ending!\n");
32. return head;
33. }
34. //全局增加
35. n++;
36. //指针移动
37. if (n == 1) {
38. head = p;
39. tail = p;
40. }
41. else {
42. tail->next = p;
43. tail = p;
44. }
46. }
48. }
50. int main() {
52. struct student* head, * p;
53. head = p = NULL;
54. head = p = creat();
55. while (p != NULL) {
56. printf("num-%d math-%d english-%d\n", p->num, p->scr.math, p->scr.english);
57. p = p->next;
58. }
60. printf("out ending!\n");
61. return 0;
62. }
64. 需要注意的点：
65. 1、结点初始化的流程：
66. p = (struct student*)malloc(sizeof(struct student));//创建结点空间并返回指针
67. printf("please input num:\n");//输入成员值
68. scanf("%d", &(p->num));
69. printf("please input math:\n");
70. scanf("%d", &(p->scr.math));
71. printf("please input english:\n");
72. scanf("%d", &(p->scr.english));
73. p->next = NULL;//next指针初始化为空
74. 2、如果是第一个结点;//头尾指针均指向头节点
75. head = p;
76. tail = p;
77. 如果不是第一个结点：//链接尾指针节点和当前初始化的结点，并且更新tail指针
78. tail->next = p;
79. tail = p;
80. 3、在&(p->scr.math)中，括号()是为了改变运算顺序，确保p->scr.math先被解析为一个完整的表达式，然后再取它的地址。
81. 在&p->scr.math中，->运算符的优先级高于&，所以p->scr.math也会先被解析为一个完整的表达式，然后再取它的地址。
82. 4、malloc的返回值是void*，必须要加一个强制转换
83. 5、总结流程：
84. 开始：
85. 5.1：初始化变量：
86. n = 0（全局变量，记录节点数）。
87. head = NULL（头指针初始化为NULL）。
88. tail = NULL（尾指针初始化为NULL）。
91. 5.2：循环开始：
92. 5.2.1：创建新节点p，并初始化成员值及next指针。
93. 5.2.2：判断当前节点是否为结束节点：
94. 是：跳出循环。
95. 否：继续下一步。
96. 5.2.3：n++（节点计数加1）。
97. 5.2.4：判断是否为第一个节点：
98. 是：
99. head = p（设置头指针为当前节点）。
100. tail = p（设置尾指针为当前节点）。
101. 跳回循环开始。
102. 否：
103. 更新尾指针：tail->next = p（将新节点链接到尾部）。
104. 更新尾指针为当前节点：tail = p。
105. 跳回循环开始
106. 6、一定记得加入头文件stdlib

复制代码

2.2.4： 为什么要进行malloc动态分配内存

如果使用如下代码：

1. struct student* creat() {
2. int n = 0;
3. struct student* head, * p,*tail;
4. head = p = tail = NULL;
5. while (1) {
6. //创建节点
7. struct student stu;
8. p = &stu;
9. //p = (struct student*)malloc(sizeof(struct student));
10. //赋初始值
11. printf("input your num:");
12. scanf("%d", &p->num);
13. printf("input your math:");
14. scanf("%d", &p->scr.math);
15. printf("input your english:");
16. scanf("%d", &p->scr.english);
17. p->next = NULL;
18. //判断结束条件
19. if (p->num == 0) {
20. printf("input ending!\n");
21. return head;
22. }
23. //全局增加
24. n++;
25. //指针移动
26. if (n == 1) {
27. head = p;
28. tail = p;
29. }
30. else {
31. tail->next = p;
32. tail = p;
33. }
35. }
37. }

复制代码

1. 用上述代码分析如下：
3. 调用 creat() 函数时：
4. +-------------------+
5. | creat() 栈帧 |
6. | (局部变量 stu) |
7. | stu --> 数据 |
8. +-------------------+
9. 函数返回后：
10. +-------------------+
11. | creat() 栈帧 | --> 已被销毁
12. +-------------------+
13. head 指向已销毁的 stu

复制代码

1. 用malloc分析：
3. 调用 creat() 函数时：
4. +--------------------------------+
5. | creat() 栈帧 |
6. | |
7. | head --> [堆内存] --> 节点1 |
8. | tail --> [堆内存] --> 节点1 |
9. | p --> [堆内存] --> 节点1 |
10. | |
11. | 节点1 --> 节点2 --> ... |
12. | |
13. +--------------------------------+
15. 函数返回后：
16. +--------------------------------+
17. | main() 栈帧 |
18. | |
19. | head --> [堆内存] --> 节点1 |
20. | p --> [堆内存] --> 节点1 |
21. | |
22. | 节点1 --> 节点2 --> ... |
23. | |
24. +--------------------------------+
26. 内存释放：
27. +--------------------------------+
28. | main() 栈帧 |
29. | |
30. | 调用 free(head) |
31. | |
32. | head --> NULL |
33. | p --> NULL |
34. | |
35. +--------------------------------+

复制代码

特性	栈内存	堆内存
管理方式	编译器自动管理	程序员手动管理
分配效率	高效（通过指针调整）	相对低效（涉及更多的内存管理操作）
生命周期	与作用域绑定	程序员控制
使用场景	局部变量、短期存储	动态数据结构、长期存储
风险	无（编译器处理）	内存泄漏、悬空指针

2.2.5：链表结点的删除

case1: head为空，，即链表为空

case2:删除头节点，只需要移动head指针

case3:删除后面结点，需要移动q->next指针（一定要确保p不为NULL）

case4:未找到删除结点

case3和case4需要通过一个while去遍历，再利用一个if判断排除case4

1. struct student* delete(struct student *head,int delete_num) {
2. if (head == NULL) {
3. printf("list is empty!\n");
4. return NULL;
5. }
6. if (head->num == delete_num) {
7. head = head->next;
8. return head;
9. }
10. else {
11. struct student* p=head->next;
12. struct student* q = head;
13. if (p == NULL) {
14. printf("delete error!\n");
15. return head;
16. }
17. while (p->num != delete_num&&p->next!=NULL) {
18. q = p;
19. p = p->next;
20. }
21. if (p->num == delete_num) {//这种情况包含了p->next!=NULL和p->next==NULL两种情况，但处理步骤是相同的
22. q->next = p->next;
23. }
24. else {//这种情况只包含了一种情况p->num != delete_num&&p->next==NULL，说明未找到
25. printf("delete fail!!\n");
26. }
27. }
28. return head;
29. }
33. int delete_num;
34. printf("please input delete_num:");
35. scanf("%d", &delete_num);
36. head=delete(head,delete_num);
38. 分析：
39. 1、注意要返回head指针
40. 2、如果删除的是头指针要进行特殊处理
41. 3、q指针的含义是要删除节点的前一个指针，p是要删除的当前指针
42. 4、要考虑到未找到删除结点的情况，即p->num!=XX&&p->next==NULL
43. 5、head为NULL则直接返回

复制代码

2.2.6：动态链表的插入

case1： head为空，说明链表为空，直接令head=add_node

case2： 插入第一个结点，需要改变add_node->next指针，再令head=add_node

case3： 插入中间结点。需要改变q,p的值（一定要确保p不为NULL）

case4：插入表尾结点，只需要改变p->next=add_node

case3和case4需要通过一个while去遍历，再利用一个if判断排除case4

1. struct student* add(struct student* head, struct student* add_node) {
2. if (head == NULL) {
3. return add_node;
4. }
5. if (head->num > add_node->num) {
6. add_node->next = head;
7. return add_node;
8. }
9. struct student* q, * p;
10. q = head;
11. p = head->next;
13. if (p == NULL) {
14. head->next = add_node;
15. return head;
16. }
17. while (p->num < add_node->num&&p->next!=NULL) {
18. q = p;
19. p = p->next;
20. }
21. if (p->num > add_node->num) {
22. q->next = add_node;
23. add_node->next = p;
24. }
25. else {
26. p->next = add_node;
27. }
28. return head;
30. }
35. struct student* padd_node;
36. padd_node = (struct student*)malloc(sizeof(struct student));
37. printf("please input add_node num:");
38. scanf("%d", &padd_node->num);
39. printf("please input add_node math:");
40. scanf("%d", &padd_node->scr.math);
41. printf("please input add_node english:");
42. scanf("%d", &padd_node->scr.english);
43. padd_node->next = NULL;
44. head = add(head, padd_node);

复制代码

2.2.7：链表的查找

case1： head为空，直接返回null

case2：能找到

case3：到末尾了找不到返回NULL

case2和case3还是通过一个while先进行一个遍历，再根据一个if来进行区别

1. struct student* search(struct student* head, int search_num) {
2. struct student * p = head;
3. if (head == NULL) {
4. return NULL;
5. }
6. while (p->num != search_num&&p->next!=NULL) {
7. p = p->next;
8. }
9. if (p->num == search_num) {
10. return p;
11. }
12. else {
13. return NULL;
14. }
15. }
18. struct student* psearch;
19. int search_num;
20. printf("please input search_num:");
21. scanf("%d", &search_num);
22. psearch = search(head, search_num);
23. if (psearch != NULL) {
24. printf("num-%d math-%d english-%d\n", psearch->num, psearch->scr.math, psearch->scr.english);
25. }
26. else {
27. printf("search error!!\n");
28. }

复制代码

2.2.8：链表一系列操作完整代码(第一份代码有BUG，分析两份代码)

1. #define _CRT_SECURE_NO_WARNINGS // 必须放在第一行！
2. #include<stdio.h>
3. #include<stdlib.h>
4. struct score {
5. int math;
6. int english;
7. };
8. struct student {
9. int num;
10. struct score scr;
11. struct student* next;
12. };
14. struct student* creat() {
15. int n = 0;
16. struct student* head, * p,*tail;
17. head = p = tail = NULL;
18. while (1) {
19. //创建节点
21. p = (struct student*)malloc(sizeof(struct student));
22. //赋初始值
23. printf("input your num:");
24. scanf("%d", &p->num);
25. printf("input your math:");
26. scanf("%d", &p->scr.math);
27. printf("input your english:");
28. scanf("%d", &p->scr.english);
29. p->next = NULL;
30. //判断结束条件
31. if (p->num == 0) {
32. printf("input ending!\n");
33. return head;
34. }
35. //全局增加
36. n++;
37. //指针移动
38. if (n == 1) {
39. head = p;
40. tail = p;
41. }
42. else {
43. tail->next = p;
44. tail = p;
45. }
47. }
49. }
51. struct student* delete(struct student *head,int delete_num) {
52. if (head == NULL) {
53. printf("list is empty!\n");
54. return NULL;
55. }
56. if (head->num == delete_num) {
57. head = head->next;
58. return head;
59. }
60. else {
61. struct student* p=head->next;
62. struct student* q = head;
63. while (p->num != delete_num&&p->next!=NULL) {
64. q = p;
65. p = p->next;
66. }
67. if (p->num == delete_num) {
68. q->next = p->next;
69. }
70. else {
71. printf("delete fail!!\n");
72. }
73. }
74. return head;
75. }
77. struct student* add(struct student* head, struct student* add_node) {
78. if (head == NULL) {
79. return add_node;
80. }
81. if (head->num > add_node->num) {
82. add_node->next = head;
83. return add_node;
84. }
85. struct student* q, * p;
86. q = head;
87. p = head->next;
88. while (p->num < add_node->num&&p->next!=NULL) {
89. q = p;
90. p = p->next;
91. }
92. if (p->num > add_node->num) {
93. q->next = add_node;
94. add_node->next = p;
95. }
96. else {
97. p->next = add_node;
98. }
99. return head;
101. }
103. struct student* search(struct student* head, int search_num) {
104. struct student * p = head;
105. if (head == NULL) {
106. return NULL;
107. }
108. while (p->num != search_num&&p->next!=NULL) {
109. p = p->next;
110. }
111. if (p->num == search_num) {
112. return p;
113. }
114. else {
115. return NULL;
116. }
117. }
120. int main() {
122. struct student* head, * p;
123. head = p = NULL;
124. head = p = creat();
125. while (p != NULL) {
126. printf("num-%d math-%d english-%d\n", p->num, p->scr.math, p->scr.english);
127. p = p->next;
128. }
130. printf("out ending!\n");
132. int delete_num;
133. printf("please input delete_num:");
134. scanf("%d", &delete_num);
135. head=delete(head,delete_num);
137. struct student* padd_node;
138. padd_node = (struct student*)malloc(sizeof(struct student));
139. printf("please input add_node num:");
140. scanf("%d", &padd_node->num);
141. printf("please input add_node math:");
142. scanf("%d", &padd_node->scr.math);
143. printf("please input add_node english:");
144. scanf("%d", &padd_node->scr.english);
145. padd_node->next = NULL;
146. head = add(head, padd_node);
152. p = head;
153. while (p != NULL) {
154. printf("num-%d math-%d english-%d\n", p->num, p->scr.math, p->scr.english);
155. p = p->next;
156. }
157. printf("out ending!\n");
161. struct student* psearch;
162. int search_num;
163. printf("please input search_num:");
164. scanf("%d", &search_num);
165. psearch = search(head, search_num);
166. if (psearch != NULL) {
167. printf("num-%d math-%d english-%d\n", psearch->num, psearch->scr.math, psearch->scr.english);
168. }
169. else {
170. printf("search error!!\n");
171. }
172. return 0;
173. }

复制代码

1. #define _CRT_SECURE_NO_WARNINGS // 必须放在第一行！
2. #include<stdio.h>
3. #include<stdlib.h>
4. int n = 0;
5. struct score {
6. int math;
7. int english;
8. };
9. struct student {
10. int num;
11. char name[10];
12. struct score scr;
13. struct student* next;
14. };
15. struct student* creat() {
16. struct student* head, * tail, * p;
17. head = tail = p = NULL;
18. while (1) {
19. //创建结点并初始化
20. p = (struct student*)malloc(sizeof(struct student));
21. printf("please input num:");
22. scanf("%d", &p->num);
23. printf("please input name:");
24. scanf("%s", p->name);
25. printf("please input math:");
26. scanf("%d", &p->scr.math);
27. printf("please input english:");
28. scanf("%d", &p->scr.english);
29. p->next = NULL;
30. //判断是否是结束结点（判断输入的num是不是0）
31. if (p->num == 0) {
32. return head;
33. }
34. //不是结束结点
35. n++;
36. //判断是不是头节点
37. if (n == 1) {
38. head = tail = p;
39. }
40. else {
41. tail->next = p;
42. tail = p;
43. }
45. }
47. }
49. void print(struct student* head) {
50. struct student* p = head;
51. while (p != NULL) {
52. printf("num-%d\tname-%s\tmath-%d\tenglish-%d\n", p->num, p->name, p->scr.math, p->scr.english);
53. p = p->next;
54. }
55. }
57. struct student* search(struct student* head, int search_num) {
58. if (head == NULL) {
59. return NULL;
60. }
61. struct student* p = head;
62. while (p->num != search_num && p->next != NULL) {
63. p = p->next;
64. }
65. if (p->num == search_num) {
66. return p;
67. }
68. else {
69. return NULL;
70. }
71. }
73. struct student* add(struct student* head, struct student* add_node) {
74. if (head == NULL) {//空链表
75. return add_node;
76. }
77. if (head->num > add_node->num) {//插到头结点
78. add_node->next = head;
79. return add_node;
80. }
81. struct student* q, * p;
82. q = head;
83. p = head->next;
84. if (p == NULL) {
85. head->next = add_node;
86. return head;
87. }
88. while (p->num < add_node->num&&p->next!=NULL) {//中间结点和尾结点
89. q = p;
90. p = p->next;
91. }
92. if (p->num == add_node->num) {
93. printf("add_node repeat!\n");
94. return head;
95. }
96. if (p->num > add_node->num) {//此判断说明插入链表中间节点
97. q->next = add_node;
98. add_node->next = p;
99. }
100. else {//此判断说明插入链表尾节点
101. p->next = add_node;
102. }
104. return head;
107. }
110. struct student* delete(struct student* head, int delete_num) {
111. if (head == NULL) {
112. printf("delete error!\n");
113. return head;
114. }
115. if (head->num == delete_num) {
116. printf("delete success\n");
117. return head->next;
118. }
119. struct student* q, * p;
120. q = head;
121. p = head->next;
122. if (p == NULL) {
123. printf("delete error!\n");
124. return head;
125. }
126. while (p->num != delete_num && p->next != NULL) {
127. q = p;
128. p = p->next;
129. }
130. if (p->num == delete_num) {
131. q->next = p->next;
132. printf("delete success\n");
133. return head;
134. }
135. else {
136. printf("delete error!\n");
137. return head;
138. }
144. }
147. int main() {
148. struct student* head, *search_node,*add_node;
149. int search_num, delete_num;
151. head = creat();
152. print(head);
154. add_node = (struct student*)malloc(sizeof(struct student));
155. printf("please input add_node num:");
156. scanf("%d", &add_node->num);
157. printf("please input add_node name:");
158. scanf("%s", add_node->name);
159. printf("please input add_node math:");
160. scanf("%d", &add_node->scr.math);
161. printf("please input add_node english:");
162. scanf("%d", &add_node->scr.english);
163. add_node->next = NULL;
164. head = add(head, add_node);
165. print(head);
167. printf("please input delete_num:");
168. scanf("%d", &delete_num);
169. head = delete(head, delete_num);
170. print(head);
172. printf("please input search_num:");
173. scanf("%d", &search_num);
174. search_node = search(head,search_num);
175. if (search_node == NULL) {
176. printf("search erroe!\n");
177. }
178. else {
179. printf("num-%d\tname-%s\tmath-%d\tenglish-%d\n", search_node->num, search_node->name, search_node->scr.math, search_node->scr.english);
180. }
183. return 0;
184. }

复制代码

2.3： typedef

用typedef声明新的类型名来代替已有的类型名

2.3.1：用法1(一般数据类型)：

1. typedef int III;
2. int main() {
4. III iii = 10;
5. printf("%d", iii);
6. return 0;
8. }

复制代码

2.3.2：用法2（定义结构体类型）：

1. typedef struct {
2. int year;
3. int month;
4. int day;
5. }DATA;
7. DATA birthday;
8. birthday.year = 2001;
9. birthday.month = 06;
10. birthday.day =8;
11. printf("year-%d,month-%d,day-%d", birthday.year, birthday.month, birthday.day);

复制代码

typedef 定义结构体

• 语法 ：在定义结构体的同时，使用 typedef 为其创建一个别名，这样在后续声明变量时就可以直接使用这个别名，而不需要再写 struct 关键字。

2.3.3：用法3（定义为数组类型）

1. typedef int NUM[100];
2. NUM num = { 0 };
3. printf("%d\n", sizeof(num));
6. typedef char* p;
7. p p1= "hello";
8. printf("%s\n", p1);
12. typedef int (*p)(int,int);
13. int fun(int a, int b) {
14. return a + b;
15. }
16. p p1;
17. p1 = fun;
18. printf("sum=%d\n", p1(1, 2));

复制代码

三、补充知识

在 C 语言中，数据的进制表示主要通过特定的前缀来区分，以下是常见进制及其前缀的介绍：

十进制（Decimal）

• 前缀特点 ：没有特殊前缀，数字直接按正常方式书写即可，比如 123、456 等，都是十进制数。
• 适用场景 ：日常编程中，十进制是最常用的表示方式，适用于各种整数和小数的表示，比如变量赋值、数学运算等。

八进制（Octal）

• 前缀特点 ：以数字 0（零）开头，例如 0123、0456 等。需要注意的是，这里的 0 是阿拉伯数字零，不是字母 O。
• 适用场景 ：八进制在某些特定场景下比较有用，比如文件权限设置（如 Unix/Linux 系统中的文件权限），用八进制表示权限更简洁直观。在编程中，如果需要将整数以八进制形式输出或处理，可以使用八进制前缀。

十六进制（Hexadecimal）

• 前缀特点 ：以 0x 或 0X 开头，例如 0x1A2B、0XABCDEF 等。十六进制数中可以用字母 A-F（不区分大小写）来表示数值 10-15。
• 适用场景 ：十六进制常用于表示内存地址、颜色值（如 HTML/CSS 中的颜色代码）、位操作等场景。因为十六进制和二进制的转换比较方便，每一位十六进制数对应 4 位二进制数，在处理低层数据或硬件相关编程时也很常用。

二进制（Binary）

• 前缀特点 ：在标准 C 语言中，没有官方规定的二进制前缀。但在一些编译器（如 GCC）支持的扩展语法中，可以用 0b 或 0B 作为前缀来表示二进制数，例如 0b1010、0B1101 等。
• 适用场景 ：二进制主要用于底层编程、位操作相关的场景，如设置硬件寄存器、处理二进制文件等。虽然标准 C 没有二进制前缀，但在实际编程中，如果编译器支持，使用二进制前缀可以让代码更直观易懂。