课程章节 on 自学C大纲：从内存到数据库

第1章计算机怎么记住东西的

Mon, 01 Jan 0001 00:00:00 +0000

1.1 从一个小问题开始#

假设你想让计算机记住一个字母：

人看到的是字母 A。可是计算机里面没有一个小抽屉专门放“字母 A”。

它真正存进去的是一个数字：

问题来了：

为什么 65 会变成 A？

答案要分成两层看：内存里放的是 65 这个数字；程序按 ASCII 规则读它时，屏幕上显示成 A。

1.2 内存像一排格子#

内存可以先想成一排格子。每个格子有一个编号，格子里放一个小数字。

格子的编号叫地址。格子本身通常按字节来看。

一个字节有 8 个二进制位。每个位只能是 0 或 1，所以一个字节能表示：

00000000 -> 0
00000001 -> 1
01000001 -> 65
11111111 -> 255

也就是 0 到 255 之间的数字。

这几个二进制例子先说明一件事：

内存格子里先放的是数字。

1.3 `65` 为什么是 `A`#

65 本身不是 A。

65 变成 A，是因为有一张约定好的表。最常见的一张表叫 ASCII。

第2章变量和类型

Mon, 01 Jan 0001 00:00:00 +0000

2.1 上一章留下的问题#

上一章说过，内存格子里存的是数字。

比如一个格子里放着：

按整数看，它就是数字 65。

按 ASCII 字符看，它又是字母 A。

那程序怎么知道该用哪种读法？

这就是变量和类型要解决的问题。

2.2 变量：给内存格子起名字#

如果每次都说“去地址 0x1000 那个格子取数据”，写程序会很麻烦。

所以 C 语言允许给一块内存起名字：

int x = 65; // 声明一个 int 变量，初始化为 65

可以先这样看：

x 是名字。

65 是放进去的数据。

int 告诉程序：这块内存里的数据，先按整数来解释。

变量不是凭空存在的。它背后还是内存，只是程序员不用每次都直接写地址。

2.3 类型：告诉程序怎么解释这块内存#

看三行很像的代码：

int x = 65; // int：把 65 当整数看
char c = 65; // char：把 65 当字符看（ASCII 65 = 'A'）
float f = 65; // float：把 65 转成浮点数 65.0

它们都和数字 65 有关，但类型不一样。

先看 int 和 char。它们都写了 65，但程序取值时采用的读法不同。

第3章判断和循环

Mon, 01 Jan 0001 00:00:00 +0000

3.1 问题从哪来#

上一章知道了变量和类型：int score = 86; 把 86 放进一个叫 score 的整数变量里。

但有一个东西程序还不会做：

如果 score >= 60，打印"及格"。
否则，打印"不及格"。

这种"根据条件走不同路"的能力，C 语言里用 if/else 来表达。

另一个问题：如果有很多个分数要处理，总不能复制粘贴一百遍相同的代码。程序需要一种"回头再做一遍"的能力，这就是循环。

先看分支，再看循环。

3.2 先看一个例子#

假设手头有这些分数：

72 55 88 43 91 60 -1

-1 不是真正的分数，它是一个标记，意思是"输入结束了"。

这个程序的处理步骤：

读一个分数。
如果是 -1，停止。
如果 >= 60，算及格。
否则算不及格。
回到第 1 步，读下一个。

最后打印及格人数、不及格人数和平均分。

下面就把这个程序跑起来。

3.3 最小实验#

先跑一个小实验，再一段一段拆。

这段程序里会同时看到几个新东西：scanf 负责读输入，while 负责反复执行，if 负责根据条件选择路径。先观察它能做什么，后面再把每一块拆开看。

#include <stdio.h>

int main(void)
{
 int score; // 当前读到的分数
 int pass_count = 0; // 及格人数
 int fail_count = 0; // 不及格人数
 int sum = 0; // 分数总和

 printf("Enter scores (enter -1 to finish):\n");

 while (1) { // 无限循环，靠 break 跳出
 if (scanf("%d", &score) != 1) { // 确认读到了一个整数
 printf("Invalid input, please enter an integer.\n");
 return 1;
 }

 if (score == -1) { // 遇到 -1，结束
 break;
 }

 if (score >= 60) { // 及格
 pass_count = pass_count + 1;
 } else { // 不及格
 fail_count = fail_count + 1;
 }

 sum = sum + score; // 累加总分
 }

 int total = pass_count + fail_count; // 总人数

printf("Pass: %d\n", pass_count);
printf("Fail: %d\n", fail_count);

if (total > 0) { // 防止除以零
 printf("Average: %d\n", sum / total);
}

 return 0;
}

3.4 编译运行#

保存成 grade.c，编译：

第4章函数

Mon, 01 Jan 0001 00:00:00 +0000

4.1 问题从哪来#

上一章写了一个分数统计程序，循环读入分数，用 if/else if/else 判断等级，然后计数。程序能跑，但有一个烦人的地方：

如果想在多个地方都做"分数变等级"这件事——比如先统计优秀/及格/不及格的人数，再把每个分数的等级打印出来——if/else if/else 那段判断逻辑就得写两遍。

// 第一处：统计人数
if (score >= 90) { // 分数大于等于90
 excellent_count++; // 优秀人数加1
} else if (score >= 60) { // 分数在60到89之间
 pass_count++; // 及格人数加1
} else { // 分数小于60
 fail_count++; // 不及格人数加1
}

// 第二处：打印等级
if (score >= 90) { // 分数大于等于90
 printf("Excellent\n"); // 打印优秀
} else if (score >= 60) { // 分数在60到89之间
 printf("Pass\n"); // 打印及格
} else { // 分数小于60
 printf("Fail\n"); // 打印不及格
}

两段逻辑几乎一样，只是"命中之后做的事"不同。如果及格线从 60 改成 65，两处都得改。漏改一处，程序就出现前后不一致的 bug。

复制粘贴很容易埋下不一致的 bug。代码一多，改了一处忘了另一处，问题就藏在这种地方。

C 语言的解决办法是函数：把一段逻辑写一次，装进一个有名字的"小盒子"里。需要的时候叫一声它的名字，它就替你把活干了。

4.2 先看一个例子#

还是用分数变等级的场景。这次把判断等级的逻辑单独拿出来，放进一个叫 grade_of 的小盒子里：

#include <stdio.h>

// 定义一个函数：接收一个 int 分数，返回一个 char 等级
char grade_of(int score)
{
 if (score >= 90) return 'A';
 if (score >= 80) return 'B';
 if (score >= 60) return 'C';
 return 'F';
}

int main(void)
{
 int score;

 printf("Enter scores (enter -1 to finish):\n");

 while (1) {
 scanf("%d", &score);
 if (score == -1) break;

 char grade = grade_of(score); // 调用函数，拿到等级
 printf("%d -> %c\n", score, grade);
 }

 return 0;
}

主程序里没有 if/else 了。判断等级这件事，全部交给 grade_of 去做。主程序只管读分数、调函数、打印结果。

第5章数组

Mon, 01 Jan 0001 00:00:00 +0000

5.1 问题从哪来#

上一章写了函数，能把"判断等级"这类逻辑打包复用。函数解决的是"一段逻辑反复使用"的问题。

还有一个问题没有解决：循环里读到的分数，处理完就丢了。以后想再排序、找中位数、重新打印成绩单，就没有地方把这些分数取回来。

所以这一章先处理一个更基础的问题：

30 个学生的成绩，怎么存？

一种笨办法：

int score1, score2, score3, score4, score5;
// ...一直写到 score30

30 个变量，光是声明就占半个屏幕。求平均分要写 score1 + score2 + ... + score30，改起来更痛苦。

另一种笨办法：每读一个分数，直接累加，不存下来。

int sum = 0; // 累加器初始化为 0
for (int i = 0; i < 30; i++) { // 循环 30 次
 int score; // 临时存放每次读入的分数
 scanf("%d", &score); // 读入一个整数
 sum = sum + score; // 累加到总分
}

平均分算得出来，但回头找最高分就没办法了——分数已经读过去，没有留下来。

程序需要一个地方，把一批同类型的数据整整齐齐地放在一起，随时可以回头查看。这就是数组。

5.2 先看一个例子#

假设输入 5 个分数：

72 55 88 43 91

程序要做的事：

把 5 个分数存进数组。
遍历数组，找到最高分、最低分。
算出平均分。
打印结果。

5.3 最小实验#

先跑一个小实验，然后一段一段拆。

第6章字符串

Mon, 01 Jan 0001 00:00:00 +0000

6.1 问题从哪来#

上一章学了数组，能用 int scores[5] 存一组分数。

但学生的数据不只是分数。每个学生还有名字：

Alice 85
Bob 92
Charlie 78

名字不是单个字符，而是一串字符连在一起。char c = 'A' 只能存一个字母，存不下 Alice。

用数组的思路想：Alice 是 5 个字符，排成一排。char name[5] 似乎刚好够用。但事情没那么简单——程序需要知道这串字符在哪里结束。如果数组里有多余的空间，程序怎么区分"有效字符"和"空白垃圾"？

这就是字符串要解决的核心问题。

怎么在 C 语言里表示"一串字符"，并且让程序知道它在哪里结束？

6.2 先看一个例子#

假设要做这件事：

输入一个名字。
和预设的名字比较。
如果一样，打印"Found"。

程序的输入输出大概长这样：

Enter name:
$ Alice
Found: Alice

Enter name:
$ Mallory
Not found

这就是本章要写的程序。

6.3 最小实验#

#include <stdio.h>
#include <string.h> // strcmp 在这个头文件里

int main(void)
{
 char name[32]; // 用 char 数组存名字，最多 31 个字符

 printf("Enter name: "); // 提示用户输入
 scanf("%31s", name); // 读一个单词，限制最多 31 个字符

 if (strcmp(name, "Alice") == 0) { // strcmp 返回 0 表示两个字符串相同
 printf("Found: %s\n", name); // 打印找到的名字
 } else {
 printf("Not found\n"); // 名字不匹配
 }

 return 0;
}

这段代码做了三件事：

第7章结构体

Mon, 01 Jan 0001 00:00:00 +0000

7.1 问题从哪来#

上一章已经会用字符数组保存姓名，比如一批学生的名字可以这样放：

char names[100][32]; // 100 个名字，每个最多 31 字符 + 1 个 \0

再加上前面学过的学号和分数，如果要记录一批学生的完整信息，就容易写成三个数组：

int ids[100]; // 所有学生的学号 —— 三个数组靠下标关联
char names[100][32]; // 所有学生的姓名
int scores[100]; // 所有学生的分数

三个数组靠下标关联：ids[0]、names[0]、scores[0] 都属于第 0 个学生。

这样能跑，但有一个麻烦：没有任何语法机制保证这三个数组的下标始终同步。如果你不小心往 scores[3] 写了值，却忘了更新 ids[3]，这个学生的信息就对不上了。

有没有办法把一个学生的学号、姓名、分数放在一个变量里？

7.2 先看一个例子#

假设要记录三个学生：

学号	姓名	分数
1	Alice	92
2	Bob	78
3	Carol	85

每个学生有三种数据：一个整数（学号）、一串字符（姓名）、一个整数（分数）。

如果能把这三种数据绑成一个"包裹"，每个学生用一个包裹来表示，就不会对不上了。C 语言里做这件事的工具叫 结构体（struct）。

这里的姓名仍然沿用上一章的写法，用 char name[32] 保存一个英文名。

7.3 最小实验#

#include <stdio.h>

struct Student { // 定义结构体类型
 int id; // 学号
 char name[32]; // 姓名，最多存 31 个字节的内容
 int score; // 分数
};

int main(void)
{
 struct Student s; // 声明一个结构体变量

 s.id = 1; // 给学号赋值
 snprintf(s.name, sizeof(s.name), "%s", "Alice"); // 给姓名赋值
 s.score = 92; // 给分数赋值

 printf("ID: %d\n", s.id);
 printf("Name: %s\n", s.name);
 printf("Score: %d\n", s.score);

 return 0;
}

程序很短，但做了三件事：

第8章结构体数组和表

Mon, 01 Jan 0001 00:00:00 +0000

8.1 问题从哪来#

上一章用 struct Student 把一个学生的学号、姓名、分数绑在了一起。一条记录已经清楚了，但班里不会只有一个学生。

上一章的程序只做了一件事：把数据放进去，再用循环打出来。如果要做的不只是打印，而是往表里添加新学生、按学号查找某个学生、打印所有记录，就需要一套更有组织的写法。

一个班有几十个学生，程序要支持这些操作：

操作	做什么
添加	输入学号、姓名、分数，存进表里
查找	给一个学号，找到对应的学生并打印
打印	把表里所有学生逐行输出

这三个操作，用结构体数组加一个 count 变量就能实现。

8.2 先看一个例子#

假设表一开始是空的，count = 0。用户连续添加三名学生：

学号 1，Alice，92 分
学号 2，Bob，78 分
学号 3，Carol，85 分

每添加一条，程序都把新记录写到 students[count]，再把 count 加一。三次添加后，students[0] 到 students[2] 是有效记录，count = 3，下一条会写到 students[3]。

接着按学号 2 查找，程序从 students[0] 开始比对，读到 students[1] 时找到 Bob。打印全部记录时，也只打印 students[0] 到 students[2]。这两个操作只读已有记录，不会改变表里的内容，也不会改变 count。

8.3 最小实验#

这段代码带了一个简单菜单。读的时候先看三件事：students[count] 写入新记录，for 循环只扫 count 条，打印时也只打印已经使用的记录。

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

struct Student {
 int id;
 char name[32];
 int score;
};

void clear_line(void)
{
 int ch;
 while ((ch = getchar()) != '\n' && ch != EOF) {
 // 丢掉本行剩余字符
 }
}

int main(void)
{
 struct Student students[100]; // 最多 100 条记录
 int count = 0; // 当前有 0 条
 int choice;

 while (1) {
 printf("\n1-Add 2-Search 3-Print 0-Exit\n");
 printf("Choice: ");
 if (scanf("%d", &choice) != 1) {
 clear_line();
 printf("Please enter a number.\n");
 continue;
 }
 clear_line();

 if (choice == 0) {
 break;
 } else if (choice == 1) {
 // 添加一条记录
 if (count >= 100) {
 printf("Table full, cannot add.\n");
 continue;
 }
 printf("ID: ");
 if (scanf("%d", &students[count].id) != 1) {
 clear_line();
 printf("ID must be an integer.\n");
 continue;
 }
 clear_line();

 printf("Name: ");
 if (scanf("%31s", students[count].name) != 1) {
 clear_line();
 printf("Failed to read name.\n");
 continue;
 }
 clear_line();

 printf("Score: ");
 if (scanf("%d", &students[count].score) != 1) {
 clear_line();
 printf("Score must be an integer.\n");
 continue;
 }
 clear_line();

 count = count + 1; // 记录数加 1
 printf("Added successfully, total records: %d\n", count);

 } else if (choice == 2) {
 // 按学号查找
 int target;
 printf("Enter ID to search: ");
 if (scanf("%d", &target) != 1) {
 clear_line();
 printf("ID must be an integer.\n");
 continue;
 }
 clear_line();

 int found = 0; // 标记是否找到
 for (int i = 0; i < count; i++) {
 if (students[i].id == target) {
 printf("Found: ID %d, Name %s, Score %d\n",
 students[i].id,
 students[i].name,
 students[i].score);
 found = 1;
 break; // 找到就停
 }
 }
 if (!found) {
 printf("Student with ID %d not found.\n", target);
 }

 } else if (choice == 3) {
 // 打印所有记录
 if (count == 0) {
 printf("Table is empty.\n");
 continue;
 }
 printf("\nID Name Score\n");
 printf("----------------\n");
 for (int i = 0; i < count; i++) {
 printf("%d %s %d\n",
 students[i].id,
 students[i].name,
 students[i].score);
 }
 printf("----------------\n");
 printf("Total records: %d\n", count);

 } else {
 printf("Invalid choice, please try again.\n");
 }
 }

 printf("Exited.\n");
 return 0;
}

8.4 编译运行#

保存成 table.c，编译：

第9章文件保存和读取

Mon, 01 Jan 0001 00:00:00 +0000

9.1 问题从哪来#

上一章用 struct Student 和结构体数组管理学生记录，能添加、查找、打印。但只要程序一关，所有数据全部消失。

原因很简单：结构体数组存在内存里，内存是易失的——断电就清空。

要把数据留下来，得把它写到文件里。文件存在磁盘上，断电不丢。下次程序启动，再从文件读回来。

这一章要做的事：把结构体数组里的学生记录写成文本文件，再从文本文件恢复成结构体数组。

9.2 先看一个例子#

假设内存里有两个学生：

学号	姓名	分数
1001	Alice	86
1002	Bob	91

保存到文件 students.txt 后，文件内容长这样：

1001 Alice 86
1002 Bob 91

每行一个学生，学号、姓名、分数用空格隔开。

下次程序启动，读这个文件，就能把这两条记录重新填回结构体数组。

这就是"持久化"的基本思路：保存时，把结构体字段写成文本行；读取时，再按同样的格式把文本行拆回字段。

9.3 最小实验#

这段演示只新增两个函数：save_students 和 load_students。main 用来准备几条记录、调用这两个函数、观察文件有没有留下来。

第 8 章的菜单、添加、查找都先拿掉。这样实验里只剩下一件事：数组里的记录怎样写进文件，又怎样从文件读回数组。把这两个函数看清楚以后，再接回菜单程序就只是调用位置的问题。

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

struct Student { // 学生结构体：学号、姓名、分数
 int id;
 char name[32];
 int score;
};

// 把 students 数组的前 count 条写入文件
int save_students(const char *filename, struct Student students[], int count)
{
 FILE *fp = fopen(filename, "w"); // "w" 表示写模式，文件不存在会创建
 if (fp == NULL) {
 return -1; // 打开失败
 }

 for (int i = 0; i < count; i++) {
 fprintf(fp, "%d %s %d\n", // 格式和 printf 一样，只是输出到文件
 students[i].id,
 students[i].name,
 students[i].score);
 }

 fclose(fp); // 写完必须关
 return 0;
}

// 从文件读取学生记录，填入 students 数组，返回读到的条数
int load_students(const char *filename, struct Student students[], int max_count)
{
 FILE *fp = fopen(filename, "r"); // "r" 表示读模式
 if (fp == NULL) {
 return 0; // 文件不存在，返回 0 条
 }

 int count = 0;
 while (count < max_count &&
 fscanf(fp, "%d %31s %d", // %31s 防止姓名写越界
 &students[count].id,
 students[count].name,
 &students[count].score) == 3) { // 成功读到 3 个字段才算一条
 count++;
 }

 fclose(fp);
 return count;
}

int main(void)
{
 struct Student students[100]; // 学生数组，最多100条记录
 int count = 0; // 当前实际记录数

 // 先尝试从文件加载
 count = load_students("students.txt", students, 100);
 if (count > 0) {
 printf("Loaded %d records from file:\n", count);
 } else {
 printf("File not found, starting fresh.\n");
 }

 // 显示已有记录
 for (int i = 0; i < count; i++) {
 printf(" %d %s %d\n", students[i].id, students[i].name, students[i].score);
 }

 // 手动添加两条记录。写入数组前，先确认还有空位。
 if (count < 100) {
 students[count].id = 1001;
 snprintf(students[count].name, sizeof(students[count].name), "%s", "Alice");
 students[count].score = 86;
 count++;
 } else {
 printf("Table full, skipping Alice.\n");
 }

 if (count < 100) {
 students[count].id = 1002;
 snprintf(students[count].name, sizeof(students[count].name), "%s", "Bob");
 students[count].score = 91;
 count++;
 } else {
 printf("Table full, skipping Bob.\n");
 }

 // 保存到文件
 if (save_students("students.txt", students, count) == 0) {
 printf("Saved %d records to students.txt\n", count);
 } else {
 printf("Save failed!\n");
 }

 return 0;
}

9.4 编译运行#

保存成 file_demo.c，编译：

第10章指针和动态容量

Mon, 01 Jan 0001 00:00:00 +0000

10.1 问题从哪来#

第 9 章已经把学生记录写进文件，程序关了再开，数据还能读回来。文件解决的是“数据会不会留下来”。

现在看内存里的学生表。上几章一直用结构体数组存学生记录：

struct Student students[100]; // 固定大小的数组，最多存 100 条
int count = 0; // 当前已存入的学生数量

100 条，写死在代码里。如果学校今年招了 120 个学生，第 101 条就放不进去了。

一种做法是把 100 改成 10000，但 10000 条还是有上限，而且大多数时候只用了几十条，剩下 9000 多格全浪费了。

另一种做法是问用户"你要存几条"，按需分配。但用户往往不知道自己最终要存多少：今天加 5 个，明天加 10 个，后天又删掉 3 个。

真正需要的是：一开始分配一小块空间，快用完时自动变大。

本章先不处理文件读写，只把固定的 students[100] 换成会增长的学生表。文件保存和读取以后仍然可以接在这张表外面。

这个能力在 C 语言里叫做动态内存分配。它依赖两个基础概念：函数怎么拿到外面的变量，以及指针怎么保存一块内存的地址。

10.2 函数改不了外面的变量#

动态内存分配依赖一个基础：函数要能修改调用者的变量。先用一个最小的例子把这个基础看清。

假设要写一个函数，交换两个整数。第一版这样写：

#include <stdio.h>

void swap(int a, int b) // a、b 是 x、y 的副本，不是变量本身
{
 int tmp = a; // 保存 a 的值
 a = b; // 改的是副本 a
 b = tmp; // 改的是副本 b，外面的 x、y 不变
}

int main(void)
{
 int x = 3, y = 7;
 swap(x, y); // 传值：x 和 y 的值被复制给 a 和 b
 printf("x=%d, y=%d\n", x, y);
 return 0;
}

运行结果：

第11章链表

Mon, 01 Jan 0001 00:00:00 +0000

11.1 问题从哪来#

上一章用动态数组存学生记录，容量能增长了。但有一个麻烦没解决：中间插入和删除太贵。

假设数组里有 5 个学生，要在第 2 个位置插入一个新学生：

Bob 到 Eve 四个人全部要往后挪一格，空出位置给新学生。图里的数字是下标，所以“第 2 个位置”对应下标 1。如果有 10 万条记录，在头部插入就要移动 10 万次。

删除也一样。删掉第 1 个学生，后面的全部要往前挪。

能不能有一种结构，插入和删除时不用移动其他元素？

11.2 用指针串起来#

数组的痛点在于所有元素必须挤在一起。打破这个规则的办法是：让每个学生自己记住下一个学生在哪里。

第 10 章已经见过地址。&students[1] 就是第 2 个学生的地址。如果学生记录里除了存自己的学号和名字，还额外存一个地址，指向下一个学生的地址，那从第一个学生就能找到第二个，从第二个就能找到第三个。三个人不需要紧挨着，只靠地址就能串成一条链。

这个结构里，每个学生是一个节点（node），节点有两部分：

部分	内容
`data`	学生的信息（`struct Student`）
`next`	一个指针，存下一个节点的地址

next 里存的是内存地址。最后一个节点后面没有节点时，就把 next 设为 NULL。节点散落在堆内存的各个角落，不需要紧挨着，只要靠 next 里的地址互相找到就行。

插入时，只需要改两条指针：前一个节点的 next 指向新节点，新节点的 next 指向原来的下一个节点。其他节点完全不用动。删除时也一样，让前一个节点的 next 跳过被删节点，直接指向下一个。链表中只改指针，不搬数据。

11.3 最小实验#

先看节点长什么样：

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

struct Student {
 int id;
 char name[32];
 int score;
};

struct Node {
 struct Student data; // 这个节点存的学生信息
 struct Node *next; // 指向下一个节点，没有下一个就是 NULL
};

一个节点就是一个 struct Node，里面装着一个学生的信息，外加一根指针指向下一个节点。

第12章栈和撤销

Mon, 01 Jan 0001 00:00:00 +0000

12.1 问题从哪来#

上一章用链表存学生记录，能插能删能查。上一章最后提到编辑器的撤销功能，换到学生记录里，也会遇到同一种问题：

你刚插入了一条学号为 7 的记录，本来想输入 "Alice"，却打成了 "Ailce"。发现错了，想撤销。

链表能帮你删掉 id 为 7 的记录，但前提是——你记得刚才插入的 id 是 7。如果连续插入了十几条，你还记得最后一条是哪个 id 吗？

程序需要一种机制：自动记住操作顺序，撤销时先撤最后做的那一步。

这种"最后做的最先被取出来"的顺序，有一个专门的名字——后进先出（Last In, First Out，LIFO）。实现后进先出的数据结构叫栈（stack）。

12.2 先看一个例子#

想象一摞盘子。你洗好一个就放在最上面，取的时候也从最上面拿。最后放上去的盘子最先被取走。

操作	盘子栈的变化	说明
放入 A	[A]	A 在最底下
放入 B	[A, B]	B 在 A 上面
放入 C	[A, B, C]	C 在最上面
取出一个	[A, B]	取出的是 C，后进先出
取出一个	[A]	取出的是 B

两个关键动作：

push（压栈）：把一个元素放到栈顶。
pop（弹栈）：从栈顶取出一个元素。

在撤销场景里，每次插入操作把学生 id push 进栈，撤销时 pop 出最近的 id 并删除对应记录。

第13章队列

Mon, 01 Jan 0001 00:00:00 +0000

13.1 问题从哪来#

上一章用栈实现了撤销功能。栈的特点是后进先出：最后放进去的最先被取出来。

但有些场景恰恰需要反过来。想象一个打印队列：你先点了打印文档 A，同事接着点了打印文档 B。打印机应该先打 A 再打 B，因为 A 先到。如果用栈来管理，B 会被先打印——这不合理。

食堂打饭、医院挂号、银行叫号，都是同一个规则：先来的先处理，后来的排在后面。这种顺序叫先进先出（First In, First Out，FIFO）。实现先进先出的数据结构叫队列（queue）。

13.2 先看一个例子#

想象食堂排队。学生一个一个走到队尾站好，打饭窗口从队头开始服务。

操作	队列的变化	说明
学生 A 来排队	[A]	A 既是队头也是队尾
学生 B 来排队	[A, B]	A 在队头，B 在队尾
学生 C 来排队	[A, B, C]	C 排到队尾
窗口服务一个	[B, C]	A 打完走了，B 变成队头
窗口服务一个	[C]	B 打完了

两个关键动作：

入队（enqueue）：走到队尾排队。
出队（dequeue）：从队头离开。

13.3 最小实验#

队列的实现和栈很像，只是多了一个下标。核心只有三样东西：一个数组，两个整数下标。

int queue[100]; // 最多排 100 个
int front = 0; // 队头：下一个要出队的位置
int rear = 0; // 队尾：下一个要入队的位置

非空时，front 是队头元素的位置，rear 是下一个空位。当 front == rear 时队列是空的。

第14章四则运算计算器

Mon, 01 Jan 0001 00:00:00 +0000

14.1 问题从哪来#

上一章讲了队列，先进先出，适合排队场景。但有一类任务不适合先进先出——表达式计算。

考虑这个表达式：

$$ 3 + 5 \times 2 $$

如果从左到右依次处理：先算 3 + 5 = 8，再算 8 * 2 = 16。但数学规则说乘法优先，应该先算 5 * 2 = 10，再算 3 + 10 = 13。

再加括号：

$$ 3 + 5 \times (2 + 1) $$

括号里的 2 + 1 要最先算，然后 5 * 3 = 15，最后 3 + 15 = 18。顺序完全不是从左到右。

把这个表达式画成树，会更容易看出计算顺序：下面的节点先合并，越往上越接近最后结果。

程序需要一种办法：记住还没算的数和运算符，根据优先级决定什么时候算。前面学过的栈，正好能帮程序暂存这些还不能立刻处理的内容。

14.2 先看一个例子#

语法树说明了表达式应该按什么顺序合并，但程序读到的输入仍然是一串字符。它从左到右扫描，每读到一个字符，就把暂时还不能计算的内容放进栈里。

这个过程需要两类栈：

数字栈：保存还没合并的数。
运算符栈：保存还没处理的运算符。

扫描时的规则可以分成三种动作：

读到数字，直接压入数字栈。
读到运算符，和运算符栈顶比较优先级；如果栈顶应该先算，就先弹栈计算。
读到右括号 )，一直计算到遇见左括号 (。

下图停在 3 + 5 * 这一刻。* 的优先级高于栈顶的 +，所以 + 暂时留在栈里，* 入栈。

第15章排序

Mon, 01 Jan 0001 00:00:00 +0000

15.1 问题从哪来#

前面几章多次用过学生表：学号、姓名、分数，存进数组。按学号查找时，最直接的办法就是从第 0 条扫到最后一条，逐条比对。

数据少的时候这没什么问题。但如果有 1000 条记录，每次查找平均要比较 500 次。而且不只是查找——打印时想按学号从小到大排列、按分数从高到低排名，这些操作通常会先要求：数据有顺序。

数组刚建好时，数据按输入顺序存放，没有规律。学号 5 排在学号 2 前面，学号 1 排在学号 9 后面。

让数据有顺序，程序里通常要先做一件事：排序。如果能把学号排成 1、2、3、5、9 这样的顺序，后面很多事情都会变简单。这一章解决的就是：怎么把一组无序的数据变成有序的。

15.2 先看一个例子#

假设有一组学号，还没排过序：

[5] [2] [4] [6] [1] [3]

目标是排成：

[1] [2] [3] [4] [5] [6]

插入排序的做法是：把数组分成两半，左边是已排序区，右边是未排序区。一开始已排序区只有第一个元素，剩下的都是未排序区。然后每次从未排序区取一个元素，插入到已排序区的正确位置。

这个过程就像打扑克牌：手里已经排好了一小叠牌，新摸到一张，就从右往左一张一张比，找到合适的位置插进去。

15.3 最小实验#

#include <stdio.h>

// 插入排序：把 arr[0..n-1] 从小到大排
void insertion_sort(int arr[], int n)
{
 for (int i = 1; i < n; i++) { // 从第 2 个元素开始，逐个插入
 int key = arr[i]; // key 是当前要插入的元素
 int j = i - 1; // j 指向已排序区的最后一个

 // 把比 key 大的元素往后移，给 key 腾位置
 while (j >= 0 && arr[j] > key) {
 arr[j + 1] = arr[j]; // 元素后移一位
 j--;
 }
 arr[j + 1] = key; // 插入到正确位置
 }
}

void print_array(int arr[], int n)
{
 for (int i = 0; i < n; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
}

int main(void)
{
 int ids[] = {5, 2, 4, 6, 1, 3};
 int n = sizeof(ids) / sizeof(ids[0]);

 printf("Before sort: ");
 print_array(ids, n);

 insertion_sort(ids, n);

 printf("After sort: ");
 print_array(ids, n);

 return 0;
}

15.4 编译运行#

保存成 sort.c，编译：

第16章二分查找

Mon, 01 Jan 0001 00:00:00 +0000

16.1 问题从哪来#

前面几章用线性查找在数组里找学生：

for (int i = 0; i < count; i++) { // 从第一个元素开始逐个遍历
 if (students[i].id == target) { // 比较当前元素的学号与目标
 return i; // 找到，返回下标
 }
}
return -1; // 遍历完未找到，返回 -1

不管数组有没有排序，都是从第一个开始，一个一个比。10 万个学生，最坏情况要比较 10 万次。

但很多时候，数据是排好序的。比如学生按学号从小到大排好，电话簿按姓名排好，仓库货架按编号排好。排好序的数组有一个线性查找完全没用到的性质：如果中间那个元素比目标小，目标只可能在右半边；如果比目标大，只可能在左半边。

每次比较都能排除一大段候选位置。10 万个元素，$2^{17} = 131072$，最多 17 次就能确定目标在哪里，或者确定目标不存在。

16.2 先看一个例子#

假设有一组学号，已经从小到大排好：

索引： 0 1 2 3 4 5 6 7 8 9
学号： 12 25 33 41 57 64 78 82 91 96

要找学号 57。

第 1 步：看最中间那个。low = 0，high = 9，mid = (0 + 9) / 2 = 4，ids[4] = 57。正好等于目标，找到了，返回索引 4。

第17章二叉搜索树

Mon, 01 Jan 0001 00:00:00 +0000

17.1 问题从哪来#

上一章用有序数组存学生 id，配合二分查找，查找速度是 $O(\log n)$。但插入一个新 id 时，要把比它大的元素全部往后挪一位，腾出位置。10 万条记录，最坏情况下要挪 10 万次。

问题的根源在于数组是连续存储的。元素之间紧紧挨着，中间插一个，后面的全得动。

有没有一种结构，插入时不用移动已有元素，查找时也能利用"大小关系"跳过一部分无关数据？

17.2 先看一个例子#

假设要存这几个学生 id：50、30、70、20、40、60、80。

换一种方式来组织。先取第一个 id 50 作为"根"。之后每来一个新 id，跟当前节点比：

比它小，往左走；
比它大，往右走；
走到空位置，就把自己放进去。

插完 30：30 比 50 小，放在 50 左边。

插完 70：70 比 50 大，放在 50 右边。

插完 20：20 比 50 小，往左走到 30；20 比 30 小，放在 30 左边。

插完 40：40 比 50 小，往左走到 30；40 比 30 大，放在 30 右边。

以此类推，全部插完后长这样：

每个节点最多有两个分支：左边的都比自己小，右边的都比自己大。这就是二叉搜索树（Binary Search Tree，BST）。

17.3 最小实验#

二叉搜索树的节点只有三样东西：一个 id，两根指针。这个小实验先只存 id，方便观察树的形状；如果要存完整学生记录，也可以把 name、score 这些字段一起放进节点。

第18章哈希表

Mon, 01 Jan 0001 00:00:00 +0000

18.1 问题从哪来#

上一章用二叉搜索树存学生 id。查找时每走一步会丢掉一个方向的子树；树比较平衡时，效率接近 $O(\log n)$。但这个效率有两个前提：

树要平衡。如果按有序数据插入，树退化成链表，查找变成 $O(n)$。
每次查找都要沿着树走好几层，每一层都要做一次比较。

按 id 精确查找时，有没有可能跳过"一层层比较"，直接算出 id 该去哪个桶？

打个比方。一排柜子，编号 0 到 9。学生 id 是 123，把 123 除以 10 余 3，直接去 3 号柜子找。不用从 0 号柜子开始一个一个翻。

这就是哈希表的思路：用一个函数把 id 转换成桶编号，直接定位。

18.2 先看一个例子#

假设我们有 5 个桶，编号 0 到 4。学生 id 分别是 10、15、22、37、48。

用 id 除以 5 取余数：

id	id % 5	桶编号
10	0	0
15	0	0
22	2	2
37	2	2
48	3	3

第19章程序正确性：复杂度、测试和不变量

Mon, 01 Jan 0001 00:00:00 +0000

19.1 问题从哪来#

前面几章写过很多数据结构：数组、链表、栈、队列、树、哈希表。

这些结构都能保存或组织数据，其中数组、链表、树、哈希表还常用来查找数据。但写到这里会遇到两个很实际的问题：

这个版本是不是真的比另一个版本快？
插入、删除、查找很多次以后，结构有没有悄悄坏掉？

比如哈希表的理想查找是 $O(1)$，但如果所有 id 都落进同一个桶，它就退化成链表。二分查找很快，但前提是数组已经排好序。二叉搜索树查找很快，但前提是树没有退化得太严重。

这些前提不能只靠感觉。程序需要自己打印、计数、检查。不变量就是程序运行前后都应该守住的条件。

19.2 先看一个例子#

查找 13 这件事，几种结构走的路不同：

有序数组是 {1, 3, 5, 7, 9, 11, 13, 15}。顺序查找从第一个元素开始，一个一个往后比，看到 1, 3, 5, 7, 9, 11, 13 才停，一共检查 7 次。

二分查找利用“数组已经排好序”这个事实。第一次看中间的 7，发现 13 更大，就去右半边；第二次看 11，还是更大；第三次看 13，找到。它没有检查前面的每个数，只检查了 7, 11, 13 这 3 个位置。

链表查找也是从头往后走，但走几步取决于节点顺序。下面的程序用头插法建立链表，13 正好排在第二个节点，所以链表查找检查 2 次。二叉搜索树从根节点开始，比当前节点大就往右走，比当前节点小就往左走；这组数据里查找 13 会经过 7, 11, 13。哈希表更直接一些，先算 13 % 11 得到桶编号 2，再到 2 号桶里找。

可以给每个查找函数加一个 steps 计数器。每检查一个候选元素或节点，就让 steps 加一。运行后不只看到“找到了”，还能看到“找了几步”。

19.3 最小程序#

下面这个程序只做一件事：用几种结构查找同一个 id，并打印检查次数。第 18 章的哈希函数在这里命名为 bucket_of，意思是根据 id 算出桶编号。代码里还加了两个小检查：

第20章数组版数据库

Mon, 01 Jan 0001 00:00:00 +0000

20.1 问题从哪来#

前面几章学了结构体、数组、指针、函数，也开始用测试和不变量检查程序。用结构体能表示一个学生，用数组能存一批学生，用函数能把逻辑拆开。

但这些能力分散在不同的小程序里。每次写一个新功能，就得在 main 里重新声明数组、重新写循环、重新管理 count。如果要同时管理两份学生名单，比如一班和二班，就得复制一份数组和一份计数器。

上一章还留了一个提醒：程序不只是能跑，还要守住自己的边界。这里最重要的边界就是 count：它不能小于 0，也不能超过数组容量；插入、查找、删除、列出都只能围着有效记录转。

能不能把这些数据和操作打包在一起，让"数据库"变成一个独立的东西？

20.2 先看一个例子#

假设有一个程序，用户做了这几步操作：

插入学号 1，Alice，92 分。
插入学号 2，Bob，78 分。
插入学号 3，Carol，85 分。
按学号 2 查找，找到 Bob。
删除学号 2。
列出所有学生，只剩 Alice 和 Carol。

这几步的关键变化，是 rows 里有效记录的范围和 count 一起移动：

插入时新记录写到 rows[count]，然后 count 加一。查找只读数组，不改变 count。删除时找到那条记录，把后面的记录往前挪一格，再让 count 减一。列出时只读 count 以内的记录。

20.3 最小实验#

数据库的核心结构只有两样东西：一个数组，一个计数器。

#define DB_CAPACITY 100

struct Student {
 int id;
 char name[32];
 int score;
};

struct DB {
 struct Student rows[DB_CAPACITY]; // 最多 100 条记录
 int count; // 当前有多少条
};

第21章动态数据库表

Mon, 01 Jan 0001 00:00:00 +0000

这一章要解决的问题是：把固定数组改成动态数组，用 capacity 记录总容量，用 count 记录当前条数。插入时如果 count == capacity，就用 realloc 扩容。这样，学生表不再卡在写死的 100 条上。

21.1 问题从哪来#

第 20 章已经把学生记录和操作收进了 struct DB。它的内部大致长这样：

struct DB {
 struct Student rows[100];
 int count;
};

rows[100] 还是写死在代码里。第 101 条记录就放不进去。

一种做法是把 100 改成 10000，但 10000 条还是有上限。而且大多数时候只用了几十条，剩下几千格全浪费了。

真正需要的是：一开始分配一小块空间，快用完时自动变大。

容量缩小也可以做，但它需要额外规则：什么时候缩、缩到多小、怎样避免刚缩完又马上扩。本章先把插入时自动扩容这条路径跑通。

第 10 章讲过 malloc、realloc、free 三个函数，那一次用 struct StudentTable 做了演示。这一章把同样的思路用到数据库上——给 DB 结构体加一个 capacity 字段，让它自己管理容量。

21.2 先看一个例子#

假设数据库初始容量是 2，连续插入 5 条记录：

先分配 2 格。插入 Alice、Bob 后，count 变成 2，正好等于 capacity。下一次插入 Carol 前，程序先把容量扩到 4，再写入 Carol。插入 Dave 后又满了，所以插入 Eve 前再扩到 8。

第22章链表版存储

Mon, 01 Jan 0001 00:00:00 +0000

22.1 问题从哪来#

前面几章的数据库一直用数组存记录。数组按下标访问很快，但中间插入和删除要搬动后面的元素——10 万条记录删第 1 条，后面 99999 条全部要往前挪。

第 11 章讲过链表：插入和删除只需要改几根指针，不用搬动任何节点。那一章的链表是独立的，和数据库没有关系。

现在的问题是：能不能把数据库的存储从数组换成链表？ 插入、查找、删除、遍历这些操作还能用吗？

22.2 先看一个例子#

上一章的动态数组版数据库长这样：

struct DB {
 struct Student *rows;
 int count;
 int capacity;
};

rows 指向一段连续的数组空间，count 记录当前有多少条，capacity 记录这段空间能装多少条。第 20 章的固定数组和第 21 章的动态数组有一个共同点：有效记录仍然从 rows[0] 开始连续排列。

所以数组版遍历时可以用下标访问 rows[i]。这个特点让访问第 i 条记录很快，也带来一个代价：中间插入和删除要搬动后面的元素。

链表版数据库长这样：

struct DB {
 struct Node *head;
};

数据放在一串节点里，每个节点通过 next 指针连起来，head 指向第一个节点。

两种版本对外提供的能力一样：插入、查找、删除、遍历。但内部结构完全不同，操作的实现方式也不同。

22.3 最小实验#

先定义节点和数据库结构：

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

struct Student { // 学生记录：学号、姓名、分数
 int id;
 char name[32];
 int score;
};

struct Node { // 链表节点：存放一条学生数据 + 指向下一节点的指针
 struct Student data;
 struct Node *next;
};

struct DB { // 数据库结构：只记链表头指针
 struct Node *head;
};

struct DB 只有一个成员：head 指针。它指向链表的第一个节点，链表为空时 head 是 NULL。

第23章数据库接口

Mon, 01 Jan 0001 00:00:00 +0000

23.1 问题从哪来#

前面的章节里，我们用数组存过学生记录，也用链表存过。每次换一种存储方式，操作数据的代码就要跟着重写。

用数组时，插入是这样的：

students[count].id = id;
count++;

如果链表版维护了 tail 指针，插入可能变成这样：

struct Node *new_node = malloc(sizeof(*new_node));
new_node->data.id = id;
new_node->next = NULL;
tail->next = new_node;

两段代码做的事情一样——往数据库里加一条记录。但写法完全不同。如果程序里有十处地方在操作学生数据，换成链表就要改十处。改多了，就容易出错。

问题出在哪？外部代码直接碰了内部存储的细节。count 是数组版的细节，tail 是链表版的细节。这些细节一旦暴露在外面，换存储方式就会牵一发动全身。

能不能让外部代码只看到一套固定的函数名，不关心里面怎么存的？

23.2 先看一个例子#

假设有一个学生管理程序，需要做四件事：初始化数据库、插入学生、按 id 查找、按 id 删除。

不管底层用什么结构，这四件事不会变。变的只是每件事具体怎么做。

如果把"做什么"和"怎么做"分开：

外部代码只管调用 db_insert(&db, student)，不关心 db_insert 里面用的是数组还是链表。
db_insert 的实现负责把 student 存到合适的地方。

这样，换了内部存储，只要 db_insert 的函数签名不变，外部代码就不用改。

这个思路叫封装：把内部细节包起来，只暴露必要的接口。

23.3 最小实验#

接口就是一组函数签名。先把签名定下来：

void db_init(struct DB *db);
int db_insert(struct DB *db, struct Student s);
int db_find(struct DB *db, int id, struct Student *out);
int db_delete(struct DB *db, int id);
void db_free(struct DB *db);

五个函数，五件事：

第24章多文件编译和模块边界

Mon, 01 Jan 0001 00:00:00 +0000

24.1 问题从哪来#

上一章把数据库接口稳定下来了。外部代码只需要调用：

db_init(&db);
db_insert(&db, student);
db_find(&db, id, &out);
db_delete(&db, id);
db_free(&db);

接口稳定以后，所有代码继续放在一个文件里也能跑。但文件会越来越长：上面是结构体，中间是一堆 db_* 函数，下面是 main。功能继续增加时，索引、文件保存、日志、命令解析都会挤进同一个文件。

一个文件太长时，读代码的人很难分清：哪些是外部可以用的接口，哪些只是数据库内部的细节。

24.2 三个文件#

最小拆法是三个文件：

文件	放什么
`student_db.h`	公共结构、常量和函数声明
`student_db.c`	数据库函数的具体实现
`main.c`	调用数据库接口，完成用户要做的事

main.c 不应该直接读写 rows 和 count。它包含头文件，知道有哪些函数可以调用，具体怎么插入、查找、删除，交给 student_db.c。

24.3 student_db.h：把接口写出来#

下面这版仍然使用固定数组。固定数组不是更适合真正的数据库；它只是让变量更少，读代码时可以把注意力放在文件分工上。容量仍由 MAX_ROWS 控制，插入、查找、删除的规则和上一章保持一致。

// student_db.h
#ifndef STUDENT_DB_H
#define STUDENT_DB_H

#define MAX_NAME 32
#define MAX_ROWS 100

struct Student {
 int id;
 char name[MAX_NAME];
 int score;
};

struct DB {
 struct Student rows[MAX_ROWS];
 int count;
};

void db_init(struct DB *db);
int db_insert(struct DB *db, struct Student s);
int db_find(struct DB *db, int id, struct Student *out);
int db_delete(struct DB *db, int id);
void db_free(struct DB *db);
void db_list(const struct DB *db);

#endif

#ifndef、#define、#endif 是头文件保护。它们防止同一个头文件在同一个 .c 的预处理结果里展开多次，尤其避免 struct Student、struct DB 这类类型被重复定义。

第25章数据库索引

Mon, 01 Jan 0001 00:00:00 +0000

25.1 问题从哪来#

数组版数据库有五个稳定接口：db_init、db_insert、db_find、db_delete、db_free。外部代码只调用这五个函数，不需要知道里面是数组、链表，还是别的存储方式。

但接口稳定不等于效率好。不管底层用什么存储，db_find 的实现都是从头到尾逐条扫描：

for (int i = 0; i < db->count; i++) {
 if (db->rows[i].id == id) {
 *out = db->rows[i]; // 把找到的记录复制给调用方
 return 1;
 }
}
return 0;

10 条记录无所谓，扫一遍很快就完了。10 万条记录呢？找一个 id 最坏要比较 10 万次。

二分查找能利用有序数组：每次比较排除一半，10 万个元素最多 17 次。但二分查找要求数据按 id 排好序。数据库的记录不一定按 id 排——先插入 id=5，再插入 id=3，再插入 id=8，记录在数组里的顺序是 5、3、8，不是 3、5、8。直接对记录数组做二分查找，结果不对。

可以在记录旁边维护一份"目录"：目录按 id 排好序，每一项记录这个 id 在哪一行。这份目录叫索引。

25.2 一个小例子#

数据库里有三条学生记录：

行号: 0 1 2
记录: [5,Alice] [3,Bob] [8,Carol]

记录按插入顺序存放，id 顺序是 5、3、8，没有排序。如果要找 id=3，必须从行号 0 开始扫，比较两次才找到。

给记录旁边加一张"目录"：

目录（按 id 排序）:
 id=3 → 行号 1
 id=5 → 行号 0
 id=8 → 行号 2

目录按 id 从小到大排好。查找 id=3 时，先在目录里做二分查找：看中间那个（id=5），比 3 大，去左半边；左半边只有一个 id=3，找到了，对应行号 1。比较了两次，直接跳到 rows[1]，拿到 Bob 的记录。

第26章数据库持久化

Mon, 01 Jan 0001 00:00:00 +0000

26.1 问题从哪来#

第25章给数据库加了索引。记录区 rows 保存完整学生记录，索引区 index 按 id 排序，索引项里保存 id -> row_pos。查找时先在索引里二分查找，再跳到记录区。

但这两块数据都在内存里。程序退出后，rows 和 index 占用的内存都会被操作系统回收。下一次启动，数据库又是空的。

第 9 章已经做过文件读写：把学生记录写成文本行，再从文本行读回结构体。这个办法仍然能用，只是现在要处理一个新问题：

记录区要保存。
索引区要不要保存？

答案是：只保存记录区，加载时重建索引。

索引是根据记录的 id 和它在记录区中的位置建立出来的辅助结构。只要记录还在，索引就能重新生成。把索引也写进文件，反而会多一个一致性问题：文件里的记录被改了，索引可能就过期了。

26.2 先看一个例子#

内存里的数据库有三条记录：

rows[0] = {5, "Alice", 92}
rows[1] = {3, "Bob", 78}
rows[2] = {8, "Carol", 85}

索引区按 id 排序：

index[0] = {id=3, row_pos=1}
index[1] = {id=5, row_pos=0}
index[2] = {id=8, row_pos=2}

保存时，只把记录区写进文件：

5 Alice 92
3 Bob 78
8 Carol 85

第27章日志和恢复

Mon, 01 Jan 0001 00:00:00 +0000

27.1 问题从哪来#

第26章把数据库保存到文件。保存时，程序打开 students.db，把记录区一行一行写进去。

这解决了"程序退出后数据消失"的问题，但没有解决"写到一半崩溃"的问题。

假设 students.db 原来有三条记录：5 Alice 92、3 Bob 78、8 Carol 85。程序要保存新状态。它用 "w" 打开文件，旧内容立刻被清空。写完前两条时程序崩溃，文件只剩前两行。

Carol 丢了。旧文件已经被清空，新文件又没写完整。

要让数据库更稳，修改数据之前需要先留下操作记录：

我要插入谁？
我要删除谁？

这份操作记录就是日志。

27.2 先看一个例子#

一次插入操作不再直接改内存，而是分两步：

先把 INSERT 8 Carol 85 追加到日志文件。
再把 Carol 插入内存数据库。

如果崩溃发生在不同位置：

崩溃位置	日志	内存	恢复时怎么处理
写日志前	没有操作	没改	什么都不用做
写日志后、改内存前	有操作	没改	回放日志，把操作补上
改内存后、保存前	有操作	改了但没进快照	回放日志，得到同样结果

启动恢复时做两件事：

从 students.db 加载上次保存好的快照。
从 students.log 逐行回放快照之后发生的操作。

快照文件保存某一刻的完整状态，日志文件保存那一刻之后的变化。

第28章命令协议

Mon, 01 Jan 0001 00:00:00 +0000

28.1 问题从哪来#

前面已经有了一个会保存、会恢复的小数据库。操作它的方式仍然是写 C 代码：

struct Student s = {8, "Carol", 85};
db_insert_logged(&db, "students.log", s);
db_delete_logged(&db, "students.log", 3);

这对写程序的人有用，对普通用户不方便。用户不应该为了插入一条记录去改源码、重新编译、再运行。

更自然的方式是输入一行文字：

$ INSERT 8 Carol 85
$ SELECT 8
$ DELETE 3
$ RANGE 1 10

程序读取这行文字，解析出命令名和参数，然后调用对应的数据库函数。

28.2 先看一个例子#

命令行交互大概长这样：

$ INSERT 5 Alice 92
Insert succeeded
$ INSERT 3 Bob 78
Insert succeeded
$ SELECT 3
ID: 3 Name: Bob Score: 78
$ RANGE 1 6
ID: 5 Name: Alice Score: 92
ID: 3 Name: Bob Score: 78
$ DELETE 3
Delete succeeded
$ exit

每条命令都有相同结构：

第29章状态机和更稳的命令解析

Mon, 01 Jan 0001 00:00:00 +0000

29.1 问题从哪来#

上一章的命令协议能处理：

INSERT 5 Alice 92

按空格拆开，得到 4 段：

下标	参数
0	`INSERT`
1	`5`
2	`Alice`
3	`92`

但如果名字里有空格：

INSERT 5 "Alice Wang" 92

普通按空格拆词会把 "Alice Wang" 拆成两段。这就错了。Alice Wang 应该是一整个名字。

29.2 状态是什么#

解析一行文字时，程序不是只看当前字符，还要知道"当前处在什么位置"：

状态	含义
普通状态	还没进入一个参数，遇到空格就跳过
单词状态	正在读一个普通参数，遇到空格就结束
引号状态	正在读引号里的参数，空格也是内容的一部分

状态机就是：读到一个字符，根据当前状态决定下一步怎么走。

29.3 最小程序#

这个程序只负责把一行命令拆成参数。它不实现完整数据库，只打印拆出来的参数，方便观察解析结果。这里的 token 可以理解为"拆出来的一个参数"。

#include <ctype.h> // isspace 判断空白字符
#include <stdio.h> // printf 打印结果

#define MAX_ARGS 8 // 最多拆出 8 个参数

// 状态机的三种状态：不在参数中 / 在普通参数中 / 在引号参数中
enum State {
 OUTSIDE, // 还没进入参数，遇到空格跳过
 IN_WORD, // 正在读一个空格分隔的参数
 IN_QUOTE // 正在读双引号内的参数，空格不算分隔符
};

// 把一行命令拆成参数数组，返回参数个数；出错返回负数
int split_command(char *line, char *args[], int max_args)
{
 enum State state = OUTSIDE; // 初始状态：不在参数中
 int argc = 0; // 当前已收集的参数个数

 // 逐个字符扫描整行
 for (char *p = line; *p != '\0'; p++) {
 if (state == OUTSIDE) {
 if (isspace((unsigned char)*p)) {
 continue; // 空白字符：继续跳过
 }

 if (argc >= max_args) {
 return -1; // 参数数量超上限
 }

 if (*p == '"') {
 // 遇到左双引号：参数从引号后一个字符开始
 args[argc++] = p + 1;
 state = IN_QUOTE; // 进入引号状态
 } else {
 // 普通字符：参数从这里开始
 args[argc++] = p;
 state = IN_WORD; // 进入单词状态
 }
 } else if (state == IN_WORD) {
 if (isspace((unsigned char)*p)) {
 *p = '\0'; // 写入 \0 切断当前参数
 state = OUTSIDE; // 退出单词状态，回到空闲
 }
 } else if (state == IN_QUOTE) {
 if (*p == '"') {
 *p = '\0'; // 右引号改写为 \0，切断当前参数
 state = OUTSIDE; // 退出引号状态，回到空闲
 }
 }
 }

 if (state == IN_QUOTE) {
 return -2; // 扫描结束仍在引号中：引号未闭合
 }

 return argc; // 返回拆出的参数个数
}

void print_args(char *args[], int argc)
{
 for (int i = 0; i < argc; i++) {
 printf("args[%d] = <%s>\n", i, args[i]);
 }
}

int main(void)
{
 // 测试输入：双引号包裹的姓名
 char line[] = "INSERT 5 \"Alice Wang\" 92";
 char *args[MAX_ARGS];

 int argc = split_command(line, args, MAX_ARGS);
 if (argc < 0) {
 printf("Parse failed, error code: %d\n", argc);
 return 1;
 }

 print_args(args, argc);
 return 0;
}

29.4 编译运行#

保存为 parse_quote.c，编译：

第30章向量

Mon, 01 Jan 0001 00:00:00 +0000

30.1 问题从哪来#

前面的程序已经能把用户输入拆成命令和参数，数据库接到的还是一个很明确的目标：插入记录、按 id 查找、按 id 删除。按 id 查找的逻辑很直接——给一个 id，从头到尾比对，找到就返回。

但有一类问题，数据库回答不了：

学生 Alice 和谁最像？
这篇文章和哪篇最接近？
这首歌和哪首风格相似？

这些问题不是在找"相等"，而是在找"相近"。id = 3 能精确命中一条记录，但"和 Alice 最像"需要比较每条记录和 Alice 之间的差距。

要比较差距，首先得把记录变成一组数字。

30.2 先看一个例子#

假设数据库里有三个学生：

id	name	score
1	Alice	92
2	Bob	65
3	Carol	88

用 db_find(&db, 1, &out) 能精确找到 Alice。但"谁和 Alice 最像"这个问题，数据库没法回答。score 只有一个数字，Alice 和 Carol 都是高分，可她们的学习习惯可能完全不同。一个数字能比较大小，但描述太粗糙。

如果给每个学生多记几个数字呢？

name	每周学习时长	出勤率	作业完成率
Alice	21.0	0.95	0.90
Bob	5.0	0.60	0.50
Carol	15.0	0.85	0.80

三个数字排成一行，就构成了一个向量（vector）：

第31章距离和相似度

Mon, 01 Jan 0001 00:00:00 +0000

31.1 问题从哪来#

上一章把学生记录变成了向量。Alice 是 [21.0, 0.95, 0.90]，Bob 是 [5.0, 0.60, 0.50]，Carol 是 [15.0, 0.85, 0.80]。逐维度看差值能看出一些差别，但三个差值不是一个数。

数据库里存了 100 个学生，有人问"谁和 Alice 最像"——逐维度看差值要看 100 × 3 = 300 个数字，然后自己在脑子里合成一个结论。这件事应该交给程序做。

程序需要一个函数：输入两个向量，输出一个数字。这个数字能代表"像不像"。

31.2 先看一个例子#

回到上一章的三个学生，只看两个维度（学习时长和出勤率），在平面上画出来：

Alice：(21.0, 0.95)
Bob：(5.0, 0.60)
Carol：(15.0, 0.85)

直觉告诉我们 Alice 和 Carol 离得近。用尺子量也能量出来。但程序没有尺子，它只有数字。

平面上两点的距离公式是勾股定理：

$$d = \sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2}$$

Alice 和 Carol 的距离：$\sqrt{(21-15)^2 + (0.95-0.85)^2} = \sqrt{36 + 0.01} \approx 6.00$。

Alice 和 Bob 的距离：$\sqrt{(21-5)^2 + (0.95-0.60)^2} = \sqrt{256 + 0.1225} \approx 16.00$。

第32章 Top-K和KNN

Mon, 01 Jan 0001 00:00:00 +0000

给一个查询向量，遍历数据库里的记录，算距离，保留距离最小的 K 条。这就是 KNN（K-Nearest Neighbors）。它的基本动作不复杂：算距离、比大小、留 K 个。

32.1 问题从哪来#

上一章学会了算两个向量之间的距离。只看学习时长和出勤率这两个维度时，Alice 和 Bob 的距离约为 16.00，Alice 和 Carol 的距离约为 6.00，一比就知道谁更像。

但数据库里不会只有两条记录。真实的问题是这样的：

数据库里有 1000 个学生。我输入一个新学生的特征向量，想找数据库里和他最像的 5 个人。

这就是 KNN（K-Nearest Neighbors，K 近邻） 问题：给一个查询点，从所有记录里找出距离最近的 K 条。

这一章里的 Top-K 指的是"距离最小的 K 个"。如果把每条记录到查询点的距离都算出来，Top-K 就是距离表里排在最前面的 K 条。

32.2 先看一个例子#

假设数据库里有 6 个学生，每个学生用二维向量描述（学习时长、出勤率）：

id	name	vec
1	Alice	[21.0, 0.95]
2	Bob	[5.0, 0.60]
3	Carol	[15.0, 0.85]
4	Dave	[18.0, 0.90]
5	Eve	[8.0, 0.65]
6	Frank	[23.0, 0.92]

现在有一个查询点 Q = [16.0, 0.88]，想找和 Q 最像的 3 个学生（K = 3）。

第33章 KMeans

Mon, 01 Jan 0001 00:00:00 +0000

33.1 问题从哪来#

上一章的 KNN 能回答"这个点和哪些点最像"。给一个新点，程序遍历数据库，找出距离最近的 K 条记录。

但 KNN 需要一个查询点：先给出 Q，程序再找 Q 附近的记录。

如果没有查询点，只是手里有一批数据，问题就变了。数据库里有一百个学生，每个学生有两个特征数字，比如学习时长和考试分数。程序能不能只看这些数字，自己把学生分成几组？

这就是聚类（clustering）要解决的问题：不需要标签，让程序自动分组。同一组里的点互相靠近，不同组的点互相远离。

注意一下，这里的 K 和上一章 KNN 里的 K 含义不同。KNN 的 K 是“找几条最近记录”，KMeans 的 K 是“分成几组”。

33.2 先看一个例子#

假设数据库里有 8 个学生，每个学生有两个特征：学习时长（小时/周）和考试分数（0~100）。

学生	学习时长	考试分数
A	2	30
B	3	35
C	4	28
D	5	40
E	15	80
F	16	85
G	17	78
H	18	90

把这 8 个点画在坐标系里，肉眼就能看出来：左边有 4 个点聚在一起（学习少、分数低），右边有 4 个点聚在一起（学习多、分数高）。

第34章线性回归

Mon, 01 Jan 0001 00:00:00 +0000

34.1 问题从哪来#

上一章的 KMeans 能把数据自动分成几组。分组之后，我们知道某个点被分到哪一组。

但有一类问题，KMeans 回答不了：

知道学生每周学习多少小时，想预测他的考试成绩。
知道房子的面积，想预测它的价格。
知道广告投入多少钱，想预测销售额。

这些问题不是在分组，而是在"给一个数字，算出另一个数字"。输入和输出都可以当作连续数值处理。分组算法把世界切成几块，但这些问题是想在数据里找到一条趋势线。

34.2 先看一个例子#

假设调查了 6 个学生的每周学习时长和考试成绩：

学生	每周学习时长 $x$	考试成绩 $y$
A	2	55
B	4	60
C	6	68
D	8	75
E	10	82
F	12	88

把这 6 个点画在坐标系里，横轴是学习时长，纵轴是成绩：

这些点不是随机散开的——学习时间越长，成绩越高。点大致沿着一条看不见的线排列。

如果能把这条线找出来，给一个新的学习时长，就能沿着这条线读出预测的成绩。比如学习 7 小时，预测成绩大约是多少？

这就是线性回归要做的事：给散点图找一条最佳拟合直线。

34.3 拟合是什么意思#

“找一条线"在数学上就是找两个数：斜率 $a$ 和截距 $b$，使得 $y = ax + b$ 尽量贴近所有数据点。

什么叫"尽量贴近”？对每个数据点，用线算出的 $\hat{y}_i = a x_i + b$ 和真实值 $y_i$ 之间有差距。这个差距叫误差（error）：

课程章节 on 自学C大纲：从内存到数据库

第1章 计算机怎么记住东西的

1.1 从一个小问题开始#

1.2 内存像一排格子#

1.3 65 为什么是 A#

第2章 变量和类型

2.1 上一章留下的问题#

2.2 变量：给内存格子起名字#

2.3 类型：告诉程序怎么解释这块内存#

第3章 判断和循环

3.1 问题从哪来#

3.2 先看一个例子#

3.3 最小实验#

3.4 编译运行#

第4章 函数

4.1 问题从哪来#

4.2 先看一个例子#

第5章 数组

5.1 问题从哪来#

5.2 先看一个例子#

5.3 最小实验#

第6章 字符串

6.1 问题从哪来#

6.2 先看一个例子#

6.3 最小实验#

第7章 结构体

7.1 问题从哪来#

7.2 先看一个例子#

7.3 最小实验#

第8章 结构体数组和表

8.1 问题从哪来#

8.2 先看一个例子#

8.3 最小实验#

8.4 编译运行#

第9章 文件保存和读取

9.1 问题从哪来#

9.2 先看一个例子#

9.3 最小实验#

9.4 编译运行#

第10章 指针和动态容量

10.1 问题从哪来#

10.2 函数改不了外面的变量#

第11章 链表

11.1 问题从哪来#

11.2 用指针串起来#

11.3 最小实验#

第12章 栈和撤销

12.1 问题从哪来#

12.2 先看一个例子#

第13章 队列

13.1 问题从哪来#

13.2 先看一个例子#

13.3 最小实验#

第14章 四则运算计算器

14.1 问题从哪来#

14.2 先看一个例子#

第15章 排序

15.1 问题从哪来#

15.2 先看一个例子#

15.3 最小实验#

15.4 编译运行#

第16章 二分查找

16.1 问题从哪来#

16.2 先看一个例子#

第17章 二叉搜索树

17.1 问题从哪来#

17.2 先看一个例子#

17.3 最小实验#

第18章 哈希表

18.1 问题从哪来#

18.2 先看一个例子#

第19章 程序正确性：复杂度、测试和不变量

19.1 问题从哪来#

19.2 先看一个例子#

19.3 最小程序#

第20章 数组版数据库

20.1 问题从哪来#

20.2 先看一个例子#

20.3 最小实验#

第21章 动态数据库表

第1章计算机怎么记住东西的

1.3 `65` 为什么是 `A`#

第2章变量和类型

第3章判断和循环

第4章函数

第5章数组

第6章字符串

第7章结构体

第8章结构体数组和表

第9章文件保存和读取

第10章指针和动态容量

第11章链表

第12章栈和撤销

第13章队列

第14章四则运算计算器

第15章排序

第16章二分查找

第17章二叉搜索树

第18章哈希表

第19章程序正确性：复杂度、测试和不变量

第20章数组版数据库

第21章动态数据库表

第22章链表版存储

第23章数据库接口

第24章多文件编译和模块边界

第25章数据库索引

第26章数据库持久化

第27章日志和恢复

第28章命令协议

第29章状态机和更稳的命令解析

第30章向量

第31章距离和相似度

第34章线性回归