Firefly

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
description: 这是我新 Astro 博客的第一篇文章。
5
image: ./cover.jpg
6
tags: [前端, 开发]
7
category: 前端开发
8
draft: false
9
---

属性	描述
`title`	文章标题。
`published`	文章发布日期。
`updated`	文章更新日期。如果未设置，将默认使用发布日期。
`pinned`	是否将此文章置顶在文章列表顶部。
`description`	文章的简短描述。显示在首页上。
`image`	文章封面图片路径。 1. 以 `http://` 或 `https://` 开头：使用网络图片 2. 以 `/` 开头：`public` 目录中的图片 3. 不带任何前缀：相对于 markdown 文件的路径
`tags`	文章标签。
`category`	文章分类。
`lang`	文章语言代码（如 `zh-CN`）。仅当文章语言与站点默认语言不同时设置。
`licenseName`	文章内容的许可证名称。
`licenseUrl`	文章内容的许可证链接。
`author`	文章作者。
`sourceLink`	文章内容的来源链接或参考。
`draft`	如果这篇文章仍是草稿，则不会显示。
`comment`	是否启用此文章的评论功能。默认为 `true`。
`slug`	自定义文章 URL 路径。如果不设置，将使用文件名作为 URL。
`password`	文章密码。设置后文章内容将被 AES-256-GCM 加密，访客需输入密码才能查看。
`passwordHint`	密码提示。显示在密码输入框上方，帮助访客回忆密码，也可以不加。

文章文件的放置位置#

您的文章文件应放置在 src/content/posts/ 目录中。您也可以创建子目录来更好地组织您的文章和资源。

1
src/content/posts/
2
├── post-1.md
3
└── post-2/
4
    ├── cover.png
5
    └── index.md

自定义文章 URL (Slug)#

什么是 Slug？#

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例#

示例 1：使用文件名作为 URL#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/my-first-blog-post

示例 2：自定义 Slug#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
slug: hello-world
5
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/hello-world

示例 3：其他语言文件名使用Slug#

1
---
2
title: 如何使用 Firefly 博客主题
3
published: 2023-09-09
4
slug: how-to-use-firefly-blog-theme
5
---

文件：src/content/posts/如何使用Firefly博客主题.md

URL：/posts/how-to-use-firefly-blog-theme

Slug 使用建议#

使用英文和连字符：my-awesome-post 而不是 my awesome post
保持简洁：避免过长的 slug
具有描述性：让 URL 能够反映文章内容
避免特殊字符：只使用字母、数字和连字符
保持一致性：在整个博客中使用相似的命名模式

注意事项#

Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
如果多个文章使用相同的 slug，后面的文章会覆盖前面的
Slug 会自动转换为小写

ResNet学习心得

Sun, 21 Jun 2026 00:00:00 GMT

在上一章节，我们着重介绍了有关卷积神经网络的计算原理与优化方法，这一章，我们将介绍ResNet这一个里程碑式的神经网络，它解决了朴实神经网络在训练中的层数增加导致的深度神经网络训练中的梯度消失/爆炸问题和网络深度增加时准确度饱和甚至下降的现象（退化问题）

ResNet被发明于2015年，它的优化方法大大加速了机器学习领域的研究进度，下面我将介绍它的核心创新点：残差学习。

从图中图像我们可以观测到：随着网络层增加，训练集和测试集的loss都有增加（准确度下降），那么，是什么导致了这一点呢？我们来假设是因为过拟合或梯度消失/梯度爆炸这两种原因来进行分析：

1、过拟合：过拟合现象指的是在训练集上表现的很好，但是在测试集上表现差的情况，但是从图中分析可知：数据在测试集和训练集上表现的都比较差，所以这并非训练数据不足或模型复杂度过高导致的过拟合现象。

2、梯度下降/梯度爆炸：在传统神经网络中，如果出现传递的值过小或过大，随着层数加深会导致结果失真的问题，通过前几章介绍的归一化处理可以很好的解决这个问题。

通过跳跃连接的方法，我们可以用这种映射的方式来进行计算，

果网络已经足够好**：F(x) 会接近 0，输出就是 0+x=x，相当于”我停在原地，不往下走”，不会让性能变差。如果网络还能优化**：F(x) 会学习到需要调整的部分，比如上面例子中的 0.1。梯度传播**：在反向传播时，梯度可以通过 x 直接传回，不会因为多层传递而消失，就像给梯度开了一条”高速公路”

优化设计：

多进程编程总结

Sun, 21 Jun 2026 00:00:00 GMT

本章记录笔者在多进程编程中的实验心得与感受。

1、多进程的相关概念：

1>进程是程序一次执行的过程，有一定的生命周期，分为：创建态，就绪态，执行态，挂起态和死亡态。

2>进程是计算机资源分配的基本单位，系统会给每个进程分配0—4G的虚拟内存，其中0—3G是用户空间，3—4G是内核空间

3>其中多个进程中0—3G的用户空间是相互独立的，但是，3—4G的内核空间是相互共享的用户空间细分为：栈区、堆区、静态区

4>进程的调度机制：时间片轮询上下文切换机制

请注意！！！如果你足够细心，你会发现这和我们在计算机组成原理里面讲过的并发行为很相似，单核多次轮询是多进程编程的精髓所在，区别于多线程编程，那个就是我们常讲的并行了。

4> 并发和并行的区别：并发：针对于单核CPU系统在处理多个任务时，使用相关的调度机制，实现多个任务进行细化时间片轮询时，在宏观上感觉是多个任务同时执行的操作，同一时刻，只有一个任务在被CPU处理并行：是针对于多核CPU而言，处理多个任务时，同一时间，每个CPU处理的任务之间是并行的，实现的是真正意义上多个任务同时执行

2、进程的内存管理

1> 物理内存：内存条上（硬件上）真正存在的存储空间

2> 虚拟内存：程序运行后，通过内存映射单元，将物理内存映射出4G的虚拟内存，共进程使用

进程和程序的区别：#

进程：进程是动态的，程序一次执行的过程，有生命周期，会被内核分配1-3G用户空间，进程在内存实时上存着。

程序：程序是静态的，没有生命周期，是存在磁盘存储设备上的二进制文件

eg.cpp ->g++ hello.cpp -> a.out

进程的种类#

进程一共有三种：交互进程、批处理进程、守护进程

1> 交互进程：它是由shell控制，可以直接和用户进行交互的，例如文本编辑器

2> 批处理进程：内部维护了一个队列，被放入该队列中的进程，会被统一处理。例如 g++编译器的一步到位的编译

3> 守护进程：脱离了终端而存在，随着系统的启动而运行，随着系统的退出而停止。例如：操作系统的服务进程

进程PID的概念#

1> PID（Process ID）:进程号，进程号是一个大于等于0的整数值，是进程的唯一标识，不可能重复。

2> PPID(Parent Process ID):父进程号，系统中允许的每个进程，都是拷贝父进程资源得到的

3> 在linux系统中的 /proc目录下的数字命名的目录其实都是一个进程

特殊的进程#

1> 0号进程（idel）：他是由linux操作系统启动后运行的第一个进程，也叫空闲进程，当没有其他进程运行时，会运行该进程。他也是1号进程和2号进程的父进程

2> 1号进程（init）：由0号进程创建，处理硬件初始化和收养孤儿进程的操作

3> 2号进程（kthreadd）：也称调度进程，由0号进程创建，主要完成任务调度问题、

4> 孤儿进程：当前进程还正在运行，其父进程已经退出了。说明：每个进程退出后，其分配的系统资源应该由其父进程进行回收，否则会造成资源的浪费

5> 僵尸进程：当前进程已经退出了，但是其父进程没有为其回收资源

好了，下面笔者记录一下关于孤儿进程和僵尸进程的处理办法：

首先是孤儿进程，因为linux特有的孤儿进程处理机制，即1号进程收养。

系统处理：

孤儿进程会被 init 进程 (PID=1) 或 systemd 自动收养

孤儿进程继续正常运行，不受影响

当孤儿进程结束时，init 进程会负责回收其资源

影响：几乎无负面影响，系统会自动处理。

僵尸进程：子进程先退出，但父进程没有回收其退出状态，导致子进程的进程描述符仍驻留在内核中，僵尸进程已经死亡，不占用 CPU、不占用内存，只占用一个进程表项（内核中的一个小结构体）。所以这里我们不能用常用的kill -9来处理这个问题，此时如果实使用 ps aux | a.out可以看到未被回收的子进程有Z的标识。

注意：单个僵尸进程影响很小，但如果大量积累（如成千上万个），会耗尽系统的进程号资源，导致无法创建新进程。

人工处理办法：#

孤儿进程不用处理，我们现在介绍僵尸进程的预防

子进程退出后父进程使用:

wait(NULL); // 阻塞等待任意子进程 // 或 waitpid(pid, NULL, 0); // 等待特定子进程 // 或 waitpid(pid, NULL, WNOHANG); // 非阻塞等待

或者忽略信号，让内核进程1统一回收：

`// 在父进程中设置 signal(SIGCHLD, SIG_IGN);

// 之后创建子进程时，子进程退出后会自动被内核回收 // 注意：这样就无法获取子进程的退出状态了`

处理方面：

`# 找到僵尸进程的父进程 ps -eo pid,ppid,stat,cmd | grep ‘Z’

杀死父进程（假设父进程 PID 是 1234）#

kill -9 1234

或者发送 SIGCHLD 信号提醒父进程回收#

kill -CHLD 1234`

杀死僵尸进程的父进程会让进程1来接管一切然后内核自动处理。

进程操作指令#

`//ps指令：能够查看当前运行的进程相关属性 ps -ef //:能够显示进程之间的关系

UID：用户ID号 PID：进程号 PPID：父进程号 C:用处不大 STIME:开始运行的时间 TTY：如果是问号表示这个进程不依赖于终端而存在 CDM：名称

ps -ajx //:能够显示当前进程的状态

PGID：进程组ID SID：会话组ID STAT：进程的状态

ps -aux //:可以查看当前进程对CPU和内存的占用率

%CPU：CPU占用率 %MEM ：内存占用率

top //动态查看进程的相关属性

kill指令：发送信号的指令使用方式：kill -信号号进程号可以通过指令：kill -l查看能够发送的信号有哪些

pidof：查看进程的进程号使用方式：pidof 进程名 `

进程的状态切换#

1、如果有停止的进程，可以在终端输入指令：jobs -l查看停止进程的作业号 2、通过使用指令：bg 作业号实现将停止的进程进入后台运行状态，如果只有一个停止的进程，输入bg不加作业号也可以 3、对后台运行的进程，输入 fg 作业号实现将后台运行的进程切换到前台运行 4、直接将可执行程序后台运行： ./可执行程序 &

多进程的实现#

1、创建父子进程

pid_t pid=fork(); //此时pid>0为父进程，pid=0为子进程

注意：父进程结束要wait(NULL)等待子进程的exit(0);

2、父子进程号获取

` #include #include pid_t getpid(void); 功能：获取当前进程的进程号参数：无返回值：当前进程的进程号

pid_t getppid(void); 功能：获取当前进程的父进程pid号参数：无返回值：当前进程的父进程pid `

使用方法：

`#include #include #include

int main() { printf(“当前进程 PID: %d\n”, getpid()); printf(“父进程 PPID: %d\n”, getppid()); return 0; }`

进程退出：exit/_exit

` #include void exit(int status); 功能：退出当前进程，并刷新当前进程打开的标准IO的缓冲区参数：进程退出时的状态，会将改制与 0377进行位与运算后，返回给回收资源的进程返回值：无

#include void _exit(int status); 功能：退出当前进程，不刷新当前进程打开的标准IO的缓冲区参数：进程退出时的状态，会将改制与 0377进行位与运算后，返回给回收资源的进程返回值：无`

进程回收：wait(NULL)最常见。

进程间通信#

1> 由于多个进程的用户空间是相互独立的，其栈区、堆区、静态区的数据都是彼此私有的，所以不可能通过用户空间中的区域完成多个进程之间数据的通信

2> 可以使用外部文件来完成多个进程之间数据的传递，一个进程向文件中写入数据，另一个进程从文件中读取数据。该方式要必须保证写进程先执行，然后再执行读进程，要保证进程执行的同步性

3> 我们可以利用内核空间来完成对数据的通信工作，本质上，在内核空间创建一个特殊的区域，一个进程向该区域中存放数据，另一个进程可以从该区域中读取数据

管道通信#

1> 管道的原理：管道是一种特殊的文件，该文件不用于存储数据，只用于进程间通信。管道分为有名管道和无名管道。

2> 在内核空间创建出一个管道通信，一个进程可以将数据写入管道，经由管道缓冲到另一个进程中读取

无名管道#

无名管道：顾名思义就是没有名字的管道，会在内存中创建出该管道，不存在于文件系统，随着进程结束而消失。无名管道仅适用于亲缘进程间通信，不适用于非亲缘进程间通信。无名管道的API。

int fd[2]; pipe(fd); // 创建管道，fd[0]读端，fd[1]写端 pid_t pid = fork(); if (pid > 0) { // 父进程 - 写 close(fd[0]); // 关闭读端 const char *msg = "Hello from parent"; write(fd[1], msg, strlen(msg)); close(fd[1]); } else if (pid == 0) { // 子进程 - 读 close(fd[1]); // 关闭写端 char buf[100] = {0}; read(fd[0], buf, sizeof(buf)); printf("子进程收到: %s\n", buf); close(fd[0]); }

有名管道#

有名管道：有名字的管道文件，会在文件系统中创建一个真实存在的管道文件，既可以完成亲缘进程间通信，也可以完成非亲缘进程间通信

`进程1：写端 mkfifo(“/tmp/my_fifo”, 0664); // 创建有名管道 int fd = open(“/tmp/my_fifo”, O_WRONLY); const char *msg = “Hello from writer”; write(fd, msg, strlen(msg)); close(fd); 进程2：读端

int fd = open(“/tmp/my_fifo”, O_RDONLY); char buf[100] = {0}; read(fd, buf, sizeof(buf)); printf(“收到: %s\n”, buf); close(fd); return 0;

注意，管道通信是半双工，一次只能一端到另一端。

信号#

信号 = 软件中断**，是进程间通信的异步通知机制。

异步性：信号随时可能到达，打断进程正常执行

简单性：只传递信号编号，不携带复杂数据

全局性：同一信号对所有进程含义相同

kill -l # 列出所有信号 man 7 signal # 查看信号手册

信号的处理方式#

`#include //忽略信号 signal(SIGINT, SIG_IGN); // 忽略 Ctrl+C

//自定义信号 #include #include #include #include

// 信号处理函数 void sig_handler(int sig) { printf(“\n收到信号: %d\n”, sig); // 注意：处理函数中只能调用异步信号安全函数 }

int main() { // 注册信号处理函数 signal(SIGINT, sig_handler);

while (1) { printf(“运行中… (按 Ctrl+C 测试)\n”); sleep(2); } return 0; } `

//举例子 #include //定义信号处理函数 void handler(int signo) { if(signo == SIGUSR1) { printf("逆子，何至于此!!!\n"); raise(SIGKILL); //向自己发送一个自杀信号 kill(getpid(), SIGKILL) } } int main(int argc, const char *argv[]) { //将子进程发送的信号绑定到指定功能中 if(signal(SIGUSR1, handler) == SIG_ERR) { perror("signal error"); return -1; } //创建父子进程 pid_t pid = fork(); if(pid > 0) { //父进程 while(1) { printf("我真的还想再活五百年\n"); sleep(1); } }else if(pid == 0) { //子进程 sleep(5); printf("红尘已经看破，叫上父亲一起死吧\n"); kill(getppid(), SIGUSR1); //向自己的父进程发送了一个自定义的信号 exit(EXIT_SUCCESS); //退出进程 } return 0; }

system V提供的进程间通信概述#

这一章，我们将要介绍消息队列和共享内存这两个概念，其中共享内存和信号量搭配使用。

1> 对于内核提供的三种通信方式，对于管道而言，只能实现单向的数据通信，对于信号通信而言，只能完成多进程之间消息的通知，不能起到数据传输的效果。为了解决上述问题，引入的系统 V进程间通信

2> system V提供的进程间通信方式分别是：消息队列、共享内存、信号量（信号灯集）

3> 有关system V进程间通信对象相关的指令

ipcs 可以查看所有的信息（消息队列、共享内存、信号量） ipcs -q:可以查看消息队列的信息 ipcs -m:可以查看共享内存的信息 ipcs -s:可以查看信号量的信息 ipcrm -q/m/s ID :可以删除指定ID的IPC对象

4> 上述的三种通信方式，也是借助内核空间完成的相关通信，原理是在内核空间创建出相关的对象容器，在进行进程间通信时，可以将信息放入对象中，另一个进程就可以从该容器中取数据了。

5> 与内核提供的管道、信号通信不同：system V的ipc对象实现了数据传递的容器与程序相分离，也就是说，即使程序以己经结束，但是放入到容器中的数据依然存在，除非将容器手动删除。

消息队列#

使用消息队列要通过声明结构体传输：此时结构体需要有一个类型变量和一个消息存储容器，而后续我们的空间大小是总大小减去类型变量大小的空间。

注意：

1、对于消息而言，由两部分组成：消息的类型和消息正文，消息结构体由用户自定义

2、对于消息队列而言，任意一个进程都可以向消息队列中发送消息，也可以从消息队列中取消息

3、多个进程，使用相同的key值打开的是同一个消息队列

4、对消息队列中的消息读取操作是一次性的，被读取后，消息队列中不存在该消息了

5、消息队列的大小：16K7

使用过程：

`1、声明结构体 2、key_t一个独有钥匙key 3、msgget(key,IPC_CREAT|0664)申请一个队列空间返回msgid; 4、用结构体声明一个消息 5、如果是接收那就bzero,如果发送那就fgets(buf,MSGSZ,stdin);buf.mtext[strlen(buf.mtext)-1]= ‘\0’; 6、如果发送那就msgsnd(msqid, &buf, MSGSZ, 0);如果接收那就 msgrcv(msqid, &buf, MSGSZ, 1, 0);(参数4： 0:表示每次都取消息队列中的第一个消息，无论类型。0:读取队列中第一个类型为msgtyp的消息。

共享内存#

5> 注意：

//通过地址访问共享内存中的数据

1、共享内存是多个进程共享同一个内存空间，使用时可能会产生竞态，为了解决这个问题，共享内存一般会跟信号量一起使用，完成进程的同步功能

2、共享内存VS消息队列：消息队列能够保证数据的不丢失性，而共享内存能够保证数据的时效性

3、对共享内存的读取操作不是一次性的，当读取后，数据依然存放在共享内存中

4、使用共享内存，跟正常使用指针是一样的，使用时，无需再进行用户空间与内核空间的切换了，所以说，共享内存是所有进程间通信方式中效率最高的一种通信方式。

使用方法：

1、通过key_t创建一个key值 2、通过shmid= shmget(key, PAGE_SIZE, IPC_CREAT|0664)创建共享内存段，返回shmid。 3、类指针操作，将共享内存段映射到用户空间char *addr = (char *)shmat(shmid, NULL, 0)； 4、同消息队列的发送接收操作 5、shmdt取消映射：shmdt(addr) 6、shmctl(shmid, IPC_RMID, NULL) == -1删除共享内存段

信号量#

注意：

1、信号量集是完成多个进程间同步问题的，一般不进行信息的通信

2、信号量集的使用，本质上是对多个value值进行管控，每个信号量控制一个进程，在进程执行前，申请一个信号量的资源，执行后，释放另一个信号量的资源

3、如果当前进程申请的信号量值为0，则当前进程在申请处阻塞，直到其他进程将该信号量中的资源增加到大于0

使用方法：

`#include union semun { int val; // 设置信号量的值 struct semid_ds *buf; //关于信号量集属性的操作 unsigned short *array; //对于信号量集中所有信号量的操作 struct seminfo __buf; / Buffer for IPC_INFO(Linux-specific) */ }; //定义一个关于对信号量初始化函数 int init_sem(int semid, int semno) { int val = -1; printf(“请输入第%d个信号量的初始值：”, semno+1); //让用户输入信号量的初始值 scanf(“%d”, &val); getchar(); //吸收回车，以免影响其他程序 //调用semctl完成设置 union semun us; us.val = val; if(semctl(semid, semno, SETVAL, us) == -1) { perror(“semctl error”); return -1; } return 0; } //创建信号量集并初始化表示本次创建的信号量集中信号灯的个数 int create_sem(int semcount){ //1、创建key值 key_t key = ftok(”/”, ‘k’); if(key == -1) { perror(“ftok error”); return -1; } //2、通过key值创建信号量集 int semid = -1; if((semid = semget(key, semcount, IPC_CREAT|IPC_EXCL|0664)) == -1) { if(errno == EEXIST) //表示信号量集已经存在，直接打开即可 { semid = semget(key, semcount, IPC_CREAT|0664); //将信号量集直接打开 return semid; } perror(“semget error”); return -1; } //3、循环将信号量集中的所有信号量进行初始化 //该操作，只有在第一次创建信号量集时需要进行操作，后面再打开该信号量集时，就无需进行初始化操作了 for(int i=0; i

上述是第一步：手动封装信号量函数简化后续调用，相当于预处理操作。

2、int semid = create_sem(2); 调用自定义函数，完成对信号量集的创建 3、共享内存板块 4、while内操作开始和结束调用： P(semid, 0); 和 V(semid, 1); 5、调用自定义函数：删除信号量集 delete_sem(semid);

若有遗漏将会补充！

拓展单向循环链表

Sun, 21 Jun 2026 00:00:00 GMT

—————————————本文旨在讨论计算机知识欢迎指正——————————————— 书接上回：我们已经了解了链表如何编写与前置节点和头指针两种表示方式，下面，我们来了解进阶写法———如何实现单向循环链表。下面，我们来梳理一下循环链表的实现方式：这是朴素的链表实现形式：这是我们理想中的循环链表实现形式：这就是我们大体的思路，然后，我们将要实现它：

首先，我们第一个难点就是———如何来构造链表的结构体；因为我们需要循环，那么我们必须要知道尾巴在哪里，所以结构体里必须有tail这一容器，然后我们还要考虑如果每次我们都用一个迭代器去迭代遍历找尾巴tail的话，效率会非常低，我们需要一个更好的表示形式

1
// 定义节点结构
2
typedef int Element;
3
typedef struct _loop_node {
4
Element val;//数据域
5
struct _loop_node *next;//地址域，指向下一个
6
} LoopNode;
7

8
// 定义单向循环链表的头结构
9
typedef struct {
10
LoopNode header;//头结点
11
LoopNode *tail;//尾巴的容器，相当于一个移动指针迭代器；
12
int num;//计数器，用来遏制循环次数，防止无限循环
13
} LinkLoopList;

于是，笔者想到了两种结构，分别是头插法和尾插法： 1、头插法：

1
int insertLinkLoopHeader(LinkLoopList* link_loop, Element value) {
2
// 1. 先有新节点
3
LoopNode *node = malloc(sizeof(LoopNode));
4
if (node == NULL) {
5
return -1;
6
}
7
node->val = value;//新节点赋值
8
node->next = link_loop->header.next;//插到头结点的下一个元素的前面；
9
link_loop->header.next = node;//更新头结点在新节点的前面
10

11
// 2. 判断尾指针是否需要更新
12
if (link_loop->tail== &link_loop->header) {
13
link_loop->tail = node;
14
}
15
++link_loop->num;
16
return 0;
17
}

展开收起

2、尾插法：

1
int insertLinkLoopTail(LinkLoopList* link_loop, Element value) {
2
// 1. 先有新节点
3
LoopNode *node = malloc(sizeof(LoopNode));
4
if (node == NULL) {
5
return -1;
6
}
7
node->val = value;
8
node->next = link_loop->tail->next;//尾部插入
9
link_loop->tail->next = node;//与原尾部节点衔接
10
link_loop->tail = node;//更新尾部
11

12
++link_loop->num;//更新数量
13

14
return 0;
15
}

展开收起

然后我们从头考虑初始化和声明结构体：

1
// 定义节点结构
2
typedef int Element;
3
typedef struct _loop_node {
4
Element val;
5
struct _loop_node *next;
6
} LoopNode;
7

8
// 定义单向循环链表的头结构
9
typedef struct {
10
LoopNode header;
11
LoopNode *rear;
12
int num;
13
} LinkLoopList;

这是初始化：

1
void initLinkLoopList(LinkLoopList* link_loop) {
2
link_loop->header.next = link_loop->tail = &link_loop->header;//头指针和尾指针同时指向头结点
3
link_loop->num = 0;
4
}

删除：

1
int deleteLinkLoopList(LinkLoopList* link_loop, Element value) {
2
LoopNode *node = &link_loop->header;
3

4
while (node->next != &link_loop->header && node->next->val != value) {
5
node = node->next;
6
}
7
if (node->next->val == value) {
8
LoopNode *tmp = node->next;
9
node->next = tmp->next;
10
free(tmp);//释放空间，删除操作
11
--link_loop->num;
12
} else {
13
printf("No %d element!\n", value);
14
}
15
return 0;
16
}

展开收起

呈现操作：

1
void showLinkLoopList(const LinkLoopList* link_loop) {
2
LoopNode *node = link_loop->header.next;
3
while (node != &link_loop->header) {
4
printf("\t%d", node->val);
5
node = node->next;
6
}
7
printf("\n");
8
}

销毁函数：

1
void destroyLinkLoopList(LinkLoopList* link_loop) {
2
LoopNode *node = link_loop->header.next;
3
while (node != &link_loop->header) {
4
LoopNode *tmp = node;
5
node = node->next;
6
free(tmp);
7
--link_loop->num;
8
}
9
printf("Table %d element!\n", link_loop->num);
10
}

最后，是测试函数：

1
void test01() {
2
LinkLoopList table;
3
initLinkLoopList(&table);
4

5
for (int i = 0; i < 10; ++i) {
6
insertLinkLoopRear(&table, i + 100);
7
}
8
showLinkLoopList(&table);
9
printf("======================\n");
10
deleteLinkLoopList(&table, 106);
11
showLinkLoopList(&table);
12

13
destroyLinkLoopList(&table);
14
}
15

16
/* 以下是几组约瑟夫环的测试答案，包括每个被杀者的顺序编号和最后的幸存者:
17
* 当n=5，k=2时，被杀者的顺序编号为2, 4, 1, 5，最后的幸存者是3。
18
* 当n=10，k=3时，被杀者的顺序编号为3, 6, 9, 2, 7, 1, 8, 5, 10，最后的幸存者是4。
19
* 当n=7，k=2时，被杀者的顺序编号为2, 4, 6, 1, 5, 3，最后的幸存者是7。
20
* 当n=10，k=17时，最后的幸存者是3
21
*/
22
void test_Joseph() {
23

24
}
25

26
int main() {
27
test01();
28

29
return 0;
30
}

展开收起

————————完结撒花！！！——————希望对你有所帮助！

数据结构之树及树的存储

Sun, 21 Jun 2026 00:00:00 GMT

——————————————本栏目旨在交流计算机知识————————————————— 上一章节，我们介绍了线性的数据结构：表，栈，队列。接下来，我们将进入下一章节——树结构的学习。首先，我们先介绍一下树的基本概念：结点**：使⽤树结构存储的每一个数据元素都被称为“结点”。例如图中的A就是一个结点。根结点**：有一个特殊的结点，这个结点没有前驱，我们将这种结点称之为根结点。⽗结点（双亲结点）、子结点和兄弟结点**：对于ABCD四个结点来说，A就是BCD的⽗结点，也称之为双亲结点。⽽BCD都是A的子结点，也称之为孩子结点。对于BCD来说，因为他们都有同一个爹，所以它们互相称之为兄弟结点。叶子结点**：如果一个结点没有任何子结点，那么此结点就称之为叶子结点。层级**：每一同辈分的节点称为同一层级。结点的度**：结点拥有的子树的个数，就称之为结点的度。树的度**：在各个结点当中，度的最⼤值。为树的度。树的深度或者⾼度：结点的层次从根结点开始定义起，根为第一层，根的孩子为第二层。依次类推。高度**：每一条路径的深度。树的高度**：最深的路径的高度。不同于线性结构的一条到底，树结构是一种逐渐扩散的结构。我们算法中的dfs与bfs就是用树的原理来完成的。在树结构中，我们不再关心客观全局的先后绝对位置，而是关心每个节点本身的前置与后继，前驱节点我们称为：双亲节点（父节点），后继节点我们称为：孩子节点（子节点）。（特殊的，有时候我们称同一层级的不同元素为兄弟元素，隔着两代的称为祖父节点，再往前则为祖先节点了）下面我们来介绍一下主流的几种树的表示方法： 1、双亲表示法：（此表示法找双亲会效率很高，但是找孩子的效率很低）

双亲表示法的实现形式是以顺序表存储结构为基本方法来实现，主体思想是：利用顺序表存储，其表元素用数据和父节点构成：

特点分析：根结点没有双亲，所以位置域设置为-1

知道一个结点，找他的⽗结点，非常容易，O(1)级

找孩子节点，必须遍历整个表

如图：

2、孩子表示法（此表示法找双亲会效率很高，但是找孩子的效率很低）

如图所示，孩子表示法是基于链表的结构实现的，我们实现的具体思路为：先构建一个链表的基础结构体，然后再声明一个结构体数组用来存储每一个节点，然后向有子树的节点为表头从左到右形成描述下一层的链表，作为查找孩子的索引。直到叶子节点为止。

这样，每当我们需要寻找某个节点的孩子节点时，那么我们就可以通过链表很容易的找到孩子元素了，而不是运用遍历这种耗时费力的朴素方法。但是这种孩子表示法很难寻找双亲，效率低。

进阶版————双亲表示法与孩子表示法合二为一：

如图所示：我们依然是用一个结构体来储存基本数据类型，但是，我们多声明了一个int类型用来标识该节点的父类节点，以弥补孩子表示法难以找寻父类的缺点。

好了，现在我们已然完成了基本表示法的讲解，下面，我们来介绍一下拓展板块的表示法：孩子兄弟表示法

上文，我们已然介绍了兄弟即为同层的不同节点，那么，如果我们想找寻节点的兄弟的时候，前文所述的表示法就不太够用了，于是我们可以尝试构建以下的结构：

在树结构中，同一层的节点互为兄弟节点。例如普通树中，节点 A、B 和 C 互为兄弟节点，⽽节点 D、E 和 F 也互为兄弟节点。*

所谓孩子兄弟表示法，指的是⽤将整棵树⽤二叉链表存储起来，具体实现方案是：从树的根节点开始，依次存储各个结点的孩子结点和兄弟结点。在二叉链表中，各个结点包含三部分内容：*

* *

孩子兄弟表示法，旨在以左孩子右兄弟的方法来表示节点之间的关系，通过这样的二叉结构我们可以很好的寻找孩子和兄弟：在以孩子兄弟表示法构建的二叉链表中，如果要查找结点 x 的所有孩子，则只要根据该结点的 firstchild 指针找到它的第一个孩子，然后沿着孩子结点的 nextsibling 指针不断地找它的兄弟结点，就可以找到结点 x 的所有孩子。好了，以上就是树及树的存储的基本知识结构原理了，希望能够给你带来帮助！

数据结构之顺序栈与链式栈

Sun, 21 Jun 2026 00:00:00 GMT

——————————————本文旨在交流计算机技术，欢迎指正————————————— 上一大章，我们深入讲解了链表的内容，这一章，我们详细介绍一种较为简单的数据结构———栈。首先，我们介绍栈是什么：栈是一种单向的结构，其中栈的底部是固定的，不可以进出，我们可操作的部分只有栈顶，来进行出入栈操作。如图：那么，这种结构的优越性在哪里呢？我们可知这种出站入栈的方式可以和好的追踪上一步的痕迹，所以在计算机应用中，我们常用的快捷键“ctrl+z”回溯键就是利用栈的原理实现的。同时，栈还是定义局部变量时操作系统为我们自动分配的一段有限空间。

下面，我们来介绍顺序栈：在书写顺序栈之前，我们先要了解四个概念：满栈递增，满栈递减，空栈递增，空栈递减。下面附上代码：

1
//空栈递增
2
a1.data[a1.pos]=1;//先赋值
3
a1.pos++;//后移动pos位置
4
//每次完成一次后pos指向空的栈位置

空栈递增： ——————————————————————————————————————————

1
//满栈递增
2
pos++;//先更新pos指向位置
3
a1.data[a1.pos]=1;//再赋值
4
//每次完成后pos指向当前赋值的位置

满栈递增： ———————————————————————————————————————————

1
//空栈递减
2
a1.data[a1.pos]=e;//先赋值
3
pos--;//后更新位点
4
//只不过是从栈顶最大值开始，大往小递减，指向赋值下小的那一个空栈点

空栈递减： ———————————————————————————————————————————

1
//满栈递减
2
pos--;//先更新指向
3
a1.data[a1.pos]=e;//后更新栈值
4
//从栈顶大往小递减顺序，pos指向离栈底更近的一个空栈值

满栈递减： —————————————————————————————————————————————————————————————————————————————————————— 好了，现在我们已经介绍完顺序栈的基本结构和入栈方法了，下面，我们来完成一下这个数据结构吧！ 1、首先是.h中的声明及（不懂的可以看我第一章讲的.h文件的作用）：

1
typedef int Element;
2
#define MaxStackSize 5
3

4
typedef struct {
5
STACK_SIZE
6
int top;
7
} ArrayStack;
8

9
/* 递增空栈 */
10
void initArrayStack(ArrayStack *stack);
11

12
void pushArrayStack(ArrayStack *stack, Element e);
13
void popArrayStack(ArrayStack *stack);
14

15
Element getTopArrayStack(const ArrayStack *stack);
16

17
int isEmptyArrayStack(const ArrayStack *stack);
18
int isFullArrayStack(const ArrayStack *stack);

展开收起

2、然后是初始化：

1
void initArrayStack(ArrayStack* stack) {
2
memset(stack->data, 0, sizeof(stack->data));
3
stack->top = 0;
4
}

3、增删改查操作（这里我们经常使用递增空栈来完成）：

1
void pushArrayStack(ArrayStack* stack, Element e) {
2
stack->data[stack->top] = e;
3
++stack->top;
4
}
5
//增加函数
6

7
void popArrayStack(ArrayStack* stack) {
8
--stack->top;
9
}
10
//删除函数
11

12
Element getTopArrayStack(const ArrayStack* stack) {
13
int pos = stack->top - 1;
14
return stack->data[pos];
15
}
16
//查询函数
17

18
int isEmptyArrayStack(const ArrayStack* stack) {
19
return stack->top == 0;
20
}
21
//判断是否是空栈
22

23
int isFullArrayStack(const ArrayStack* stack) {
24
return stack->top == MaxStackSize;
25
}
26
//判断是否满栈

展开收起

好了，我们已经讲解完成了顺序栈操作，接下来，我们来讲解链式栈的操作。类比表结构，既然有顺序表，我们就有链式表。与链式表原理，我们也有链式栈（同理，链式栈的逻辑结构也是旨在寻找零散空间插入，不再是顺序栈的那种整块空间但是实际空间分配还是依照操作系统来分配）：关于链式栈的构建，因为我们每次出栈的时候是找前一次的入栈并指向它，所以我们入栈的时候地址域指针指向前一个。下面是一个概念图：由此，模仿链式结构，我们可以实现链式栈： 1、头文件.h文件的编写：

1
typedef int Element;
2
#include "common.h"
3

4
typedef struct _node {
5
Element data;
6
struct _node *next;
7
} StackNode;//节点
8

9
typedef struct {
10
StackNode *top;
11
int count;
12
} LinkStack;//栈底
13

14
LinkStack *createLinkStack();
15
void releaseLinkStack(LinkStack *stack);
16

17
int pushLinkStack(LinkStack *stack, Element e);
18
int popLinkStack(LinkStack *stack, Element *e);

展开收起

2、实现增删改查

1
#include "linkStack.h"
2
#include
3
#include
4

5
//创建栈
6
LinkStack* createLinkStack() {
7
LinkStack* link_stack = malloc(sizeof(LinkStack));
8
if (link_stack == NULL) {
9
fprintf(stderr, "linkStack malloc failed!\n");
10
return NULL;
11
}
12
link_stack->top = NULL;
13
link_stack->count = 0;
14

15
return link_stack;
16
}
17

18
//销毁栈
19
void releaseLinkStack(LinkStack* stack) {
20
if (stack) {
21
while (stack->top) {
22
StackNode *tmp = stack->top;
23
stack->top = tmp->next;
24
free(tmp);
25
--stack->count;
26
}
27
printf("stack count: %d\n", stack->count);
28
}
29
}
30

31
//入栈
32
int pushLinkStack(LinkStack* stack, Element e) {
33
StackNode *node = malloc(sizeof(StackNode));
34
if (node == NULL) {
35
fprintf(stderr, "Stack Node malloc failed!\n");
36
return -1;
37
}
38
node->data = e;
39

40
node->next = stack->top;
41
stack->top = node;
42
++stack->count;
43
return 0;
44
}
45

46
//出栈
47
int popLinkStack(LinkStack* stack, Element* e) {
48
if (stack->top == NULL) {
49
fprintf(stderr, "stack empty!\n");
50
return -1;
51
}
52
*e = stack->top->data;
53
StackNode *tmp = stack->top;
54
stack->top = tmp->next;
55
free(tmp);
56
--stack->count;
57
return 0;
58
}

展开收起

好了，我们已经讲解完毕顺序栈和链式栈，下面去练习一下吧~~~ ——————————————希望能对你有所帮助！——————————————————

数据结构二叉树的基本介绍

Sun, 21 Jun 2026 00:00:00 GMT

————————————本文旨在讨论与学习计算机知识，欢迎交流———————————— 上一章，我们讲解了树结构的综述导论，那么，现在我们来深入了解一下树结构中最常用研究的结构——二叉树结构（上一章的扩展——孩子兄弟表示法就是利用的二叉树的原理）。以上是关于普通二叉树的基本概念，我们可以结合上一章树的概念记忆。特别的，我们需要注意：二叉树是度不超过二的树，其子树也是二叉树。下面，我们来了解一下有关二叉树的两个重要概念：满二叉树与完全二叉树。

1、满二叉树

满二叉树是指除了叶子结点外的每一个节点的度都是二且深度相同的树。

2、完全二叉树

完全二叉树是指度不为二的节点只存在与倒数二、三行且叶子结点只存在于倒数一、二行的树。

介绍完满二叉树与完全二叉树的基本概念之后，我们下面要剖析它们的重要性质：

性质1：在二叉树的第i层上的结点最多为2 个。(i ≥ 1)

性质2：深度为k的二叉树至多有2 -1个结点。(i ≥ 1)

性质3：在一棵二叉树中，叶结点的数目比度为2的结点数目多一个。

原理：

加的1为根节点，其解释为：度为1的节点1+度为2的节点2+根节点。

性质4：

性质5：如果有一棵n个结点的完全二叉树，其结点编号按照层次序（从上到下，从左到右），则除根结点外，满足[i/2 , i, 2i, 2i+1]（父，自身，左孩子，右孩子）的规则。

二叉树的存储：

通常，我们摒弃顺序存储（除了少量特殊的二叉树），因为这种存储方式非常浪费空间，我们更多使用链式存储来存储数据。而对于树，链式二叉树我们也有树头，树头作为起点更新和查找树上元素，不过当前我们仍不能自由快速的查询元素，直到我们学到二叉搜索树的时候我们会再次介绍树的搜索与遍历操作。希望能对你有所帮助！

数据结构深度搜索与广度搜索的概念

Sun, 21 Jun 2026 00:00:00 GMT

————————————本文旨在交流计算机知识，欢迎指正！———————————— 上一章节我们系统介绍了树的存储结构与基本概念，这一章，我们将详细介绍一下——树的基本应用。首先，笔者会介绍树的基本遍历模式，其次，我会详细讲解深度优先搜索和广度优先搜索的概念。首先，我们来介绍一下树的几种遍历形式：

先序遍历
中序遍历
后序遍历

关于这三种遍历我们会讲两种方法来介绍推理方式：方法一：无脑法此方法是最接近于计算机运行本身的，比较冗杂。对于如图所示的树，我将基于它给出做法：

我们可以很轻易的写出这棵树在计算机里的搜索过程（方法：从根节点向下遍历，先左后右，若是遇到空则再重复一遍上一个节点）：ABBCDDDCCBAEEFGHHHGKKKGFFEA。

我们可以发现——不管是怎样的树，按照这种规律遍历，每个独立的节点都一定会出现三次而所谓先序遍历则是：保留第一次出现的数字——ABCDEFGHK

中序遍历则是：保留第二次出现的数字——BDCAEHGKF

后序遍历则是：保留第三次出现的数字——DCBHKGFEA

依此，我们可以实现对二叉树的先中后三序遍历。

方法二：归纳法此方法是基于找规律的逻辑归纳法，在写树的代码的时候非常实用。

先序遍历：先序遍历利用先左子树后右子树的顺序从根节点开始先把根节点的左边一直遍历到底再开始遍历右子树。

中序遍历：一个“V”原则，从底部开始，遵循V的形状——左下，中上，右下的路径遍历，若是中间经过的节点有子树，则再次重复一遍V的过程在子树上。

后序遍历：从下到上先左后右，根的左子树每层遍历完成后向上一层遍历但不遍历根节点，然后同理遍历根右边子树，最后遍历根节点。

我们可以发现：先序遍历和后序遍历可以确定根节点，中序遍历可以确认左子树和右子树，知其二（先＋中或后＋中）可推断其树：好了，讲述完成了遍历过程后，我们来讲解一下代码的逻辑过程：好了，介绍完基本遍历的思路过程之后，我们来正式的介绍深度优先搜索和广度优先搜索的概念。那么，我们先从深度优先搜索开始：深度优先搜索的思路形象的表述是：“一条路走到黑，不撞南墙不回头”。每次遍历（先序）走到叶子结点才回头，走另一条道路。注意：

注意枚举的顺序，要做到对每个点都依次枚举到。
注意输出方案时 return 的位置。
要从数据存入的第一个点开始依次搜（比如数组从 1 开始存，那么 dfs(1) ）。
迷宫问题的方向数组别写错
dfs 前可以预处理
如果是寻找最短路径多数使用bfs（广度优先搜索）而非dfs（深度优先搜索），不过二十以内的步数也能用dfs，如果数量再多而不想超时就用记忆化。

下面我们来说说bfs吧，bfs（广度优先搜索）就像辐射雷达一样一圈圈一层层的前进，找到了最短层（最短路径）就返回，利用queue队列实现。

整体思路#

其思路为从图上一个节点出发，访问先访问其直接相连的子节点，若子节点不符合，再问其子节点的子节点，按级别顺序(一层一层)依次访问，直到访问到目标节点。

步骤#

起始：将起点（源点，树的根节点）放入队列中
扩散：从队列中取出队头的结点**，将它的相邻结点放入队列，不断重复这一步
终止：当队列为空时，说明我们遍历了所有的能到的结点，整个图能到的点都被搜索了一遍

好了，如上已经讲解完毕深度优先搜索的思路与和广度优先搜索的思路，希望对你有所帮助！

数据结构顺序队列及链式队列

Sun, 21 Jun 2026 00:00:00 GMT

————————————本栏目旨在讨论计算机知识，欢迎交流————————————— 上一章，我们讨论了顺序栈和链式栈，这一章，我们将讲解线性结构的最后一个部分——顺序队列和链式队列。相比于栈结构的同端进出，就像原肠生物，而队列则是尾部入队和头部出队，就像后口生物一样。如图：那么，如何来实现入队和出队呢？答曰：请看VCR：但是，使用这种直观地朴素方法我们有个致命的问题——假溢出问题。在顺序栈的实现中我们的队头队尾类似于双指针滑动窗口算法，但是每次划过了之后空间不会清除，导致看起来一共占了（rear-head）个空间，但是其实远远不止这么多。前面的都没删除，很容易产生假溢出的效果并且及其占用空间。于是，循环赋值的方法应运而生。它的基本原理是：通过取余操作来覆盖删除的数值，直到队头与队尾相撞结束。那么，现在我们有两种思路：1、通过设定一个bool类型变量flag，每次通过判断来操作。2、虚空一个空间，每次入队的时候探针向前虚指，碰到了头才操作。比起第一种方法，第二种用了空间换时间的方法，效率更高。如下：

1
if ((queue->rear + 1) % MaxQueueSize == queue->front) {
2
fprintf(stderr, "Queue Full!\n");
3
return -1;
4
}
5
//如果相等，则表明队列是满的
6

7
queue->rear = (queue->rear + 1) % MaxQueueSize;
8
queue->data[queue->rear] = e;
9
//入队操作

1
if (queue->rear == queue->front) {
2
fprintf(stderr, "Queue Empty!\n");
3
return -1;
4
}
5
//如果对撞，表明队列是空了
6

7
queue->front = (queue->front + 1) % MaxQueueSize;
8
*e = queue->data[queue->front];
9
//出队操作

好了，解决了顺序结构的难点，我们可以附上全部代码了： 1、.h文件的代码：

1
#ifndef ARRAY_QUEUE_H
2
#define ARRAY_QUEUE_H
3

4
#define MaxQueueSize 5
5
#define Element int
6
typedef struct {
7
Element data[MaxQueueSize];
8
int front;
9
int rear;
10
} ArrayQueue;
11

12
void initArrayQueue(ArrayQueue *queue);
13

14
int enArrayQueue(ArrayQueue *queue, Element e);
15
int deArrayQueue(ArrayQueue *queue, Element *e);
16
#endif //ARRAY_QUEUE_H

展开收起

2、.c文件的代码：

1
#include
2
#include "arrayQueue.h"
3

4
void initArrayQueue(ArrayQueue* queue) {
5
queue->front = queue->rear = 0;
6
}//初始化
7

8
int enArrayQueue(ArrayQueue* queue, Element e) {
9
if ((queue->rear + 1) % MaxQueueSize == queue->front) {
10
fprintf(stderr, "Queue Full!\n");
11
return -1;
12
}
13

14
queue->rear = (queue->rear + 1) % MaxQueueSize;
15
queue->data[queue->rear] = e;
16

17
return 0;
18
}//入队
19

20
int deArrayQueue(ArrayQueue* queue, Element* e) {
21
if (queue->rear == queue->front) {
22
fprintf(stderr, "Queue Empty!\n");
23
return -1;
24
}
25

26
queue->front = (queue->front + 1) % MaxQueueSize;
27
*e = queue->data[queue->front];
28

29
return 0;
30
}//出队

展开收起

既然我们已经明晰了顺序队列的循环优化方法，那么我们下一步可以继续介绍链式队列的实现方式了：链式队列仍是遵循之前我们讲的逻辑结构的原理，但是对于链式队列，我们要重新构建队列结构，考虑到入队是插入的模式，相对自由，于是我们着重构建出队：以单链表的模式，出队的构建即为顺着单链表Next的指向方向来移动权当出队的操作。那么入队则为单向链式结构不停地增加新节点，形成同向出入队的效果。有了一个关于模型的思考雏形，那么我们可以试着作出逻辑图如下：下面，我们来通过代码实现它： 1、首先是.h文件功能实现的构建：

1
#ifndef LINK_QUEUE_H
2
#define LINK_QUEUE_H
3

4
#define Element int
5

6
// 链表的节点
7
typedef struct _node {
8
Element data;
9
struct _node *next;
10
} QueNode;
11

12
// 链式队列的头节点,记录队头和队尾的位置
13
//const char name 是队列的名字,cnt 记录元素个数
14
typedef struct {
15
QueNode *rear;
16
QueNode *front;
17
int cnt;
18
const char *name;
19
} LinkQueue;
20

21
LinkQueue *createLinkQueue(const char *name);
22
void releaseLinkQueue(LinkQueue *queue);
23

24
int enLinkQueue(LinkQueue *queue, Element e);
25
int deLinkQueue(LinkQueue *queue, Element *e);
26

27
#endif //LINK_QUEUE_H

展开收起

2、建立队列的函数：

1
LinkQueue* createLinkQueue(const char *name) {
2
LinkQueue* queue = malloc(sizeof(LinkQueue));
3
if (queue == NULL) {
4
fprintf(stderr, "createLinkQueue malloc failed!\n");
5
return NULL;
6
}
7
queue->name = name;
8
queue->front =queue->rear = NULL;
9
queue->cnt = 0;
10

11
return queue;
12
}

3、销毁队列函数：

1
void releaseLinkQueue(LinkQueue* queue) {
2
//如果队列存在
3
if (queue) {
4
//新建辅助节点
5
QueNode *node;
6
while (queue->front) {
7
node = queue->front;
8
queue->front = node->next;
9
//释放辅助节点
10
free(node);
11
queue->cnt--;
12
}
13
printf("queue have %d node!\n", queue->cnt);
14
//释放链式头结点
15
free(queue);
16
}
17
}

展开收起

4、出队与入队：

1
// 先有新节点，新节点应该rear的next方向插入，便于front的删除
2
int enLinkQueue(LinkQueue* queue, Element e) {
3
QueNode *node = malloc(sizeof(QueNode));
4
if (node == NULL) {
5
fprintf(stderr, "enLinkQueue new_node malloc failed!\n");
6
return -1;
7
}//如果空间申请未成功
8
node->data = e;//赋值
9
node->next = NULL;//入队后队尾指向NULL;
10
if (queue->rear) {//队尾存在
11
queue->rear->next = node;//入队操作，和上一个过程的队尾链接
12
queue->rear = node;
13
} else {
14
queue->rear = queue->front = node;//初始的时候队尾队头指向同一点
15
}
16
queue->cnt++;
17
return 0;
18
}
19

20
int deLinkQueue(LinkQueue* queue, Element* e) {
21
if (queue->front == NULL) {
22
fprintf(stderr, "queue empty!\n");
23
return -1;
24
}//空间申请未成功
25
*e = queue->front->data;//备份队头待删除元素
26
QueNode *tmp = queue->front;//辅助节点
27
queue->front = tmp->next;//更新队头为下一个
28
free(tmp);//释放空间
29
queue->cnt--;
30
if (queue->front == NULL) { // 队列中已经没有元素
31
queue->rear = NULL;
32
}
33
return 0;
34
}

展开收起

测试函数：

1
#include
2
#include "arrayQueue.h"
3
#include "linkQueue.h"
4

5
void test01() {
6
ArrayQueue stu1;
7

8
initArrayQueue(&stu1);
9

10
for (int i = 0; i name, queue->cnt);
11
while (deLinkQueue(queue, &x1) != -1) {
12
printf("\t%d", x1);
13
}
14
printf("\n");
15
releaseLinkQueue(queue);
16
}
17

18
int main() {
19
test02();
20

21
return 0;
22
}

展开收起

好了，关于队列的数据结构结构实现讲解到此完结~撒花✿✿ヽ(°▽°)ノ✿，希望能对你有所帮助！

晶体管到代码计算机底层原理揭秘

Sun, 21 Jun 2026 00:00:00 GMT

本文基于教程：https://www.youtube.com/playlist?list=PL9vTTBa7QaQOoMfpP3ztvgyQkPWDPfJez 如有疑惑，请移步观看课程视频。

一、晶体管与代码执行#

单个晶体管通常有三个引脚：集电极（collector）、发射极（emitter）和基（base）这是构成基本门电路的基础元件。在计算基础架构的最底层就是由大量这样的晶体管构成的。本质上我们可以将它看作一个开关.当基级没有提供电信号的时候集电极和发射极无法导通。当且仅当基极通入电信号的时候集电极与发射极才能导通。下面是一种经典的运用示例图：好了，在了解完晶体管（这里指三极管）的基本原理后我们来了解一下基础的逻辑门及其实现——他们分别是：与门，或门，或门，异或门。首先是非门，非门的输出是与输入相反的电信号，如图：然后就是与门，与门只有输入全为1的时候才会输出1，否则输出0，所以我们受此启发可以用串联电路来实现这一逻辑门（默认导通为1，阻塞为0）。如图：接下来是或门，或门的准则是当输入器存在1（存在一项导通）的时候，输出为1，否则为0。根据这个性质，我们可以尝试用并联的电路来模拟或门的逻辑信号，如图：最后我们来介绍异或门，他们是由前三个逻辑门组合制成的，不过在此之前我要展示这些门真正的逻辑符合：下面是异或门的实现：可以注意到，异或门只有当输入不同的时候才会输出1否则为0。这引起了我的一个有趣的思考，关于异或门，双输入其实本质上也是模拟了单输入的一根导线的二极管电路方式😂。这是异或门的逻辑门符号下面我们来介绍加法器😄，这是学习计算机组成结构中不得不品鉴的一环——半加器与全家器。首先是半加器，它含有输入及两个输出（进位输出与本位输出），实现了一位的二进制加法。如图我们可以使用一个异或门和一个与门很轻松的实现这个结构。在传统八位加法器里我们可以使用半加器作为最低位的加法元，当然也能用全加器，不过记得把进位输入的地方置0。（Tips:这里我想补充一点，在计算机体系结构中加减乘除都是以加法器实现的，比如减法器，也是将数值转换成补码相加，当然这里又要讨论有符号整数和无符号整数的相关问题，他们的机理比较复杂，这里不做详细赘述。如果感兴趣可以自行购买王道的计算机组成原理教材练习。）

为了实现多位加法计算，我们引入了全加器的概念：全加器在半加器的基础上添加了一个进位输入来处理上一个全加器的进位输出，它其实也是在半加器的基础上添加了一层异或门和与门。不过这样的设计结构能够很好的进行多位计算，最经典的就是八位加法器：当然，在八位加法器里又有一个不得不品鉴的一环——溢出处理，它是计算机组成原理课程的重难点，不过我们这里不做详细赘述，你只需知道当溢出的时候就会将左下输出置为1且引发操作系统的未定义行为错误，想要了解这个可以观看我上一篇文章的阐述。如图，是全减器的实现下面，我们来介绍解码器：这是一种能够将指令转化为计算机可识别并执行操作的设备，实际运用中他们常常被运用在区分和传输汇编码的信号上。具体而言，解码器接收一个二进制输入信号，该信号精确对应目标输出端的位置编号。其核心功能是，当输入信号被接收时，有且仅有一个输出端输出数值1，而其余所有输出端均保持数值0。当输入n个信号，我们可以控制2^n个输出也许你会疑惑：这些晶体管底层实现和操作系统底层操纵的汇编指令有什么关系吗？答案是：有，而且非常只有！因为真正计算机能理解的代码是由0和1组成的二进制指令。我们以此段举例，实现一种汇编指令的模拟：假设01开头是加载操作，00是计算操作，10则是存储操作，那么现在让我们先聚焦于计算操作：如图，每种操作码对应一种既定计算类型在CPU确认当前指令为算术运算时，运算器会接收操作码并让所有电路同时接收输入并生成各自输出，但解码器的输出端通过特殊互联设计，确保只有被选定运算对应的结果能够通过该组件。

二、晶体管与数据存储#

这一章节将要介绍基于SRAM（静态随机存取存储器）技术的存储，也就是王道书里谈到的Cache广泛应用的插电即存断电即毁的高速缓存技术。在进行讲解地址数据存储之前我们得先了解一些关于锁存器的概念——它是整个存储系统的核心原理。如图所示，WRITE ENABLE输入端口是控制锁存器状态的当它为0的时候无论DATA怎么改变，存储的信息都不会受到影响。而当WRITE ENABLE输入端口置1的时候（此时我们可以覆盖原数据来修改信息），锁存器可以受到DATA的影响来改变其状态这也是我们I/O设备向高速缓存写入写出的基础原理。然而这只是对于1bit信息的内容存储，我们知道一字节有8bit，要存储一个字节的信息，我们可以使用8个锁存器来完成。通过一个WRITE ENABLE来控制存储开关。同时这也构成了我们常说的寄存器（最简版）。然而这种工程方式的排线分布使得地址变多时走线量巨大，那么我们就得引入地址复用技术了（同样这里不过多赘述原理和一些深入的知识，如有需要请看王道书的巨难练习题）我们将地址拆成两份，每份使用一个解码器来控制“类坐标系”中的坐标来定位实现指定地址的访问。那么，该如何实现写入和输出呢？这里还是引入一个三极管，当ReadEnable被激活时（置1）集电极和发射极导通，遂输出信息且由于WriteEnable置0，信息存储不变。而当WriteEnable置1时，可写入数据更改存储单元信息。如图：此时我们使用一个类似总线的装置来定位这些锁存器，但是由于没有侦测机制导致每次激活总线会让整行整列都被激活操作，这样是错误的，于是我们加入与门进行优化，让其可以定位到精确的单个锁存器本身：如此，我们便能单独访问这块缓存上指定位置的锁存器了。开始我们现在仍在处理比特位的相互据，若要转化为字节的层面，可以将所有矩阵共享同一地址输入，这样我们就能通过相同地址同时访问各矩阵中对应的锁存器。读使能和写使能信号也应共享，因为我们需要对整个字节进行读写操作，而非单独处理某个比特位。如图，是我们使用的时候真正的存储方式：而在写程序的时候，我们使用的更多是高层抽象封装的地址，而不必考虑电路板上的真正蚀刻：这里我们引入了地址总线的概念（adressbus）。例如，当采用8位地址总线时，配合两个能分别控制16路输出的解码器，即可在存储矩阵中精确定位256个比特中的任意一位。通常来说，若地址总线具备n个输入位，系统可寻址的空间大小为2^n字节。例如，32位地址总线可寻址40亿字节，这解释了为何32位计算机最多只能支持4GB内存。

三、计算机运行程序的编写#

这一章，我们来了解学习CPU中指令的实现与运行原理。上一版快，我们讨论了IO在存储中是如何进行的，这一板块，我们要探究汇编指令在硬件上的处理过程：LOAD，STORE以及SUB和ADD。首先，我们回顾一下整体过程步骤：我们将存储器定义为按字节寻址的存储阵列，通过地址总线输入字节在存储阵列中的位置，即可选中对应字节，当选中的字节处于可读取状态时，数据总线会配合读使能信号将该字节存储的数值传输至处理器。同一组数据总线也可作为输入通道，配合写使能信号，将新数据写入指定地址的存储单元。首先我们来介绍关于LOAD和STORE。与计算操作不同，加载和储存的第一顺位是操作类型判断，第二顺位是寄存器编号，第三顺位是地址（当然，这里使用解码器来判断不同）。译码时，通常第一优先级的任务是判断操作类型（加载还是存储），第二优先级是确定涉及的寄存器编号，第三优先级则是根据寻址方式计算出内存地址。以 LOAD（加载）操作为例，它的目的是把数据从内存读到寄存器中。首先，CPU 将计算好的内存地址送上地址总线，同时激活内存的读使能信号；内存收到信号后，会把该地址中存储的数据输出到数据总线上。这个数据会被同时送到寄存器堆中所有寄存器的输入端，但此时所有寄存器都不会立即更新。接着，控制器根据指令中指定的目标寄存器编号，只激活该寄存器的写使能信号。在下个时钟沿到来时，该寄存器锁存住数据总线上的值，从而用新数据覆盖旧内容，完成加载。 STORE（存储）操作则方向相反：它会先将要存储的寄存器值送上数据总线，并把要写入的内存地址送上地址总线，随后激活内存写使能，将数据写入目标内存单元。这样，LOAD 和 STORE 就通过同样的三阶段选通（操作‑寄存器‑地址）实现了 CPU 与内存的数据交互。与LOAD和STORE不同，ADD和SUB是计算操作数，假设第一顺位为00代表计算，第二顺位代表不同的计算操作类型，第三顺位是操作所在内存地址。与 LOAD 和 STORE 这类访存指令不同，ADD 和 SUB 属于纯粹的算术逻辑运算，整个过程无需访问内存，数据只在寄存器堆和 ALU 之间流动。译码阶段依然是相同的优先级逻辑：先根据操作码判断是加法还是减法，然后提取目标寄存器编号以及两个源操作数的寄存器编号（例如 ADD R1, R2 中的 R1、R2）。随后，寄存器堆根据 R1,R2 的地址，通过译码器从对应的读端口同时送出这两个 32 位（或其他位宽）的数值，直接送入 ALU 的输入端。此时，ALU 控制单元会根据操作码产生相应的控制信号，如果是 ADD，则让 ALU 执行加法运算；如果是 SUB，则通常通过补码加法实现——将第二个操作数按位取反后与第一个操作数相加，并设置进位为 1，从而等效完成减法。经过一段组合逻辑延迟后，运算结果出现在 ALU 的输出端，而这个输出信号被连接到寄存器堆的写数据端口。最后，控制器使能目标寄存器 R1 的写使能信号，在下一个时钟上升沿将结果写入 R1，覆盖旧值。整个运算过程被压缩在一个时钟周期内完成（或者对应流水线的执行 / 写回阶段），与 LOAD 需要等待存储器读出的漫长延迟相比，ADD/SUB 的路径更短、速度更快，体现了 CPU 内部数据通路的纯粹计算能力。

四、Dram内存相关存储#

前面我们介绍了Sram，适用于Cache，这里我们介绍Dram，它更多用于建造固态内存，由于集成度更高所以更加价格亲民，不过由于其动态刷新机制，其读远快于写，而且性能略逊Sram。首先，我们来介绍电容。DRAM 是基于电容设计的一种存储结构，其每个存储单元的核心就是一个微小电容和一个晶体管。在写入数据时，DRAM 并不会一直由电源直接供电，而是通过打开晶体管，让位线上的电压对电容进行充电（存入逻辑 1）或放电（存入逻辑 0），从而将信息以电荷的形式暂存在电容里。电容一旦被充电，就会因为晶体管漏电和本身介质泄漏而开始缓慢丢失电荷。这种漏电速度相对较快，通常在几十毫秒内就会让代表 1 的电压下降到无法可靠识别的程度。因此，DRAM 必须周期性地对所有电容进行重新充电（刷新），才能保持数据不丢失。 DRAM和SRAM的对比与SRAM相同，DRAM在存储上也使用矩阵样式的地址复用技术，通过复数个解码器与拆解地址来定位锁存器进行IO操作。由于SRAM静态内存技术成本高，且集成度低（空间成本远大于dram），所以我们的固态硬盘常用dram而sram仅用于多级闪存事实上我们在读取的过程中，假设电压是0-1V的范围，那么我们的位线就就界定位为0.5V。当我们激活解码器的时候，整条线会被打开，激活栅极电容，点容有电会放电，位线会得到0.5+^v电压，电容没电的会充电位线会得到0.5-^v电压。最后输出的时候位线末端的感应放大器以位线电压0.5v为界定，高于则输出1否则为0。读取过后感应放大器将电信号原路返回。事实上在写操作的时候，我们在目标锁存器写好内容也会反向传入存储单元进行复写。事实上关于刷新操作，我们是在电容器放电到不能读取之前先把数据存到目标锁存器，然后给指定存储位充电，最后写回数值到原存储单元。由于刷新只能逐行操作，所以按理来说存储元件读写的范围是在未正在刷新的地址进行。不过不用担心，刷新是毫秒为单位的，但是读写操作是以纳秒为单位的所以影响不大。相信你也注意到了这个模型我们是以比特位单位传输的，但是我们通常使用字节来传输在日常业务中，那么怎么办呢？不要慌，现代的多路复用器可以传输总线了，也就是说我们可以把八位当作一个总线传输输出，每次也输出八位就行。当然，静态内存sram效率远高于dram，所以说无论如何他们都不能相互替换。

五、处理器是如何运行并维持正常工作状态#

这一章节，我们来介绍指令集的协同运作：关于cpu，在运行的时候通常是使用编译器翻译好的指令进行线性运行，工作台是寄存器。下面我将介绍它的运行过程：首先，load加载变量，到通用寄存器，然后add将R1寄存器的值加到R0上并存到R0，最后STR存储R0的值到0111地址然后HALT完毕。这里要强调的一点是：通常我们的数据存储是先变量后数据也就是说：好了，了解完这个之后我们进入到关于循环的实现部分：首先我们要理解JUMP这个指令的概念：JUMP是跳转指令，当生效时的操作是将地址寄存器的特定地址加载到（工作台），得以下一个地址访问是地址寄存器里记录的跳转地址。这里补充一下：每次运行一个指令的时候（无JUMP情况下）我们的地址寄存器自动加一以便下次访存的时候直接就可以找到对应位置。我们注意到，当一个8位的存储自增到255满了之后，标志位O Z N中的O会亮起，这说明溢出了。标志位OZN分别代表溢出，零和负数，他们是循环条件成立的重要角色：比如说这个简单的while循环，判断条件是a<5，但是在cpu看来就是判断”a-5“是否在N标志位成立，否则就跳出循环。下面是一些重要的JUMP系列指令：

六、时钟与CPU工作的原理#

最后我们来聊聊时钟振荡信号与CPU的控制原理。首先，我们聚焦讨论方波，因为它恰好符合计算机二进制的0/1规则。综上栏目我们已经知道了计算机运行的过程：取指，解码，然后是执行和程序计数器++。可是计算机是如何知晓应该按照这个过程循环做这些板块内容呢？答案是石英电子时钟。下方是边缘触发器的波形，上方是电平波形首先，我们要了解一下如图的逻辑电路机制，表面上看它是一个输入一个反相输入永远不可能会在AND门的前提下实现输出1的，但是我们要知道，反向门的反向操作需要纳秒级的事件这造就了一个上升沿，同时对应不久的下降沿。这就是边缘触发器的制作。同样的，我们来看SR锁存器。R写入数值，S进行复位，当SR都为0的时候锁存器存储的内容不变，这样就算存储信息了。不过不能同时SR置1，因为不能同时写入和复位而且这个时候置0会因为几纳秒的差距导致上面说的上升沿效应导致信息存储被篡改了。这时候我们引入使能的概念：只有Enable被激活后，再激活R,S才能实现复位和置位的操作，这确保了激发的安全性。这个是KJ锁存器，AND门加了两个输入保证不会同时输出一样的信号杜绝了最开始的1：1的异常情况，并且前面接入了一个边缘触发器，当上升沿期间J,K被同时触发，触发器会切换当前数值，而且此时J置位K复位。我们使用多个连在一起的JK触发器可以实现在固定往复的顺序下计数，那么这个就可以用来控制CPU按顺序处理各个阶段的操作。

洛谷P1010递归法题解

Sun, 21 Jun 2026 00:00:00 GMT

————————————本文旨在讨论计算机知识，欢迎指正——————————————

输入输出样例#
** 输入 ** 1315 输出

2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)

说明/提示#
** 【数据范围】

对于 100% 的数据，1≤n≤2×104。

1≤n≤2×104

首先，我们观察这道题，笔者看到这道题一开始也是很懵，关于如何输出这种长长的一行，但是，我们经过拆解可以发现： 2的十次方，括号内是2加2的3次方，也就是8，根据括号中叠括号的方式，我们可以尝试用递归的方式来做题：注意：2的0次方和2的一次方是特殊的，分别是最基础的奇数和偶数，其它数字都是这样合成的：于是我们得把0和1次方作为终点；那么，我们可以写出这样的函数：

1
void solve(int n)
2
{
3
for (int i = 14; i >= 0; i--)
4
{
5
if (pow(2, i)
6
#include
7
using namespace std;
8
int n;
9
void solve(int n)
10
{
11
for (int i = 14; i >= 0; i--)
12
{
13
if (pow(2, i) > n;
14
solve(n);
15
return 0;
16
}

展开收起

希望能对你有所帮助！

洛谷P1115最大字段和的前缀和做法

Sun, 21 Jun 2026 00:00:00 GMT

———————————本文旨在学习交流计算机知识，欢迎指正！———————————— 看到标题，我们可以发现，这也是一个继承性累加问题，很显然的想到滑动窗口和前缀和两个方法：首先看滑动窗口，那我们的思路就是左边是left，右边是right，而每次向右判断最大的数更新值但记录最大值，可是，如果这样做无异于每个点都要当作左点一次，时间复杂度为（n*n/2）对于数据来看，有可能会超限，和暴力无异，于是我们想到改换一种别的方法————前缀和：首先，我们记录下传入数组a和叠加前缀数组pre:

1
int n;
2
cin >> n;
3
vectora(n + 1, 0);
4
vectorpre(n + 1, 0);
5
for (int i = 1; i > a[i];
6
for (int i = 1; i
7
#include
8
#include
9
using namespace std;
10
int main()
11
{
12
int n;
13
cin >> n;
14
vectora(n + 1, 0);
15
vectorpre(n + 1, 0);
16
for (int i = 1; i > a[i];
17
for (int i = 1; i <= n; i++)pre[i] = pre[i - 1] + a[i];
18
int minner = 0;
19
int ans = 0;
20
for (int i = 1; i <= n; i++)
21
{
22
ans = max(ans, pre[i] - minner);
23
minner = min(minner, pre[i]);
24
}
25
cout << ans << endl;
26
return 0;
27
}

展开收起

希望能对你有所帮助！

洛谷P1996约瑟夫问题数据结构链表模拟法

Sun, 21 Jun 2026 00:00:00 GMT

——————————-—本文旨在讨论和交流计算机知识，欢迎指正！！！—————————

题目描述#

n 个人围成一圈，从第一个人开始报数,数到 m 的人出列，再由下一个人重新从 1 开始报数，数到 m 的人再出圈，依次类推，直到所有的人都出圈，请输出依次出圈人的编号。

输入格式#

输入两个整数 n,m。

输出格式#

输出一行 n 个整数，按顺序输出每个出圈人的编号。既然这一题要求我们输出出圈人的编号，我们用链表模拟的时候不用模拟值的数组，只用模拟首尾相连的过程即可；

1
#include
2
using namespace std;
3
const int N=1e5+9;
4
int ne[N];
5
int n,m;//初始化

首先，我们模拟首尾相连的环状结构

1
cin>>n>>m;
2
for(int i=1;i
3
using namespace std;
4
const int N=1e5+9;
5
int ne[N];
6
int n,m;
7
int main()
8
{
9
cin>>n>>m;
10
for(int i=1;i<=n;i++)
11
{
12
ne[i]=i+1;
13
}
14
ne[n]=1;
15
int pre=n;
16
for(int cnt=0;cnt<n;cnt++)
17
{
18
for(int j=0;j<m-1;j++)
19
{
20
pre=ne[pre];
21
}
22
cout<<ne[pre]<<" ";
23
ne[pre]=ne[ne[pre]];
24
}
25
return 0;
26
}

展开收起

程序与进程CPU执行的奥秘

Sun, 21 Jun 2026 00:00:00 GMT

本文基于教程：https://www.youtube.com/playlist?list=PL9vTTBa7QaQPdvEuMTqS9McY-ieaweU8M 如有疑惑，请移步观看课程视频。

**一、程序和进程#

首先我们要区别程序（program)和进程（process）的区别：程序（program）是静态的文本代码，需要通过编译或解释才能执行。执行时创建动态实体，即进程（process）。在现代计算机中，操作系统通过调度算法（如时间片轮询）管理多个进程的并发运行。同一个程序可以启动多个进程实例，每个实例有独立的内存空间；内存占用（如大小）不同，是由于运行时数据（如用户输入或文件内容）的差异，而非程序代码本身。例如，多个记事本进程打开不同文件时，内存分配因文件数据而异。同时，我们要理清第二个概念：程序执行的到底是什么？关于这一点，我的理解是程序执行本质上是CPU执行机器码的过程。对于编译型语言（如C/C++/Rust），代码经过预处理、编译、汇编和链接后生成可执行文件。该文件包含机器码（存储在内存的代码段）和初始数据（存储在数据段），机器码直接指导CPU的活动与调度。例如，使用g++编译命令g++ xxx.cpp -o xxx.exe生成的.exe文件，其机器码部分在运行时加载到代码段。而python/java类的解释性语言则完全不同，解释型语言（如Python/Java）并非完全不需要编译：Java源代码先编译为字节码，Python源代码编译为字节码，然后在虚拟机或解释器上执行。与编译型语言的关键区别在于，字节码需要运行时解释或JIT编译为机器码，这牺牲了性能以换取跨平台性和开发效率。性能开销大的原因包括解释执行延迟、动态类型检查以及内存管理（如垃圾回收），而非‘次次编译’或‘文本存储’。代码本身存储在内存的代码区，而非堆区；堆区主要用于对象分配。并且，除了TEXT段，其他段都是动态响应的。

**二、CPU执行中的中断恢复机制#

在CPU时间片轮询的过程中，我们常常会有疑惑：在有限的轮询时间里进程数据是否会有安全性泄露和运行计算错误的随机性风险。下面我将结合我的理解来聊聊这个机制。首先为了防止安全性泄露和错漏问题我们在中断前引入了类似“快照”的PCB存储机制。具体实现为：在内存中划定一篇区域用结构体去存上一个进程中断前的所有寄存器数据及相关存储元件数据，等到下次轮询的时候再恢复状态【中断发生时，CPU 会先将当前进程的寄存器上下文（程序计数器、栈指针、通用寄存器等）保存到该进程的内核栈上；随后操作系统把这些信息整理到进程控制块（PCB）中，相当于为进程拍了一张“快照”。当该进程被再次调度时，系统就从 PCB 中恢复这些寄存器值，从而继续执行】。**（此时我们将每个进程看作一个容器，进程只有在自己容器里运行，这也是多进程场景为人诟病开销大的根本原因。同时，进程不好抽象放入队列时间片轮询，故其实在队列中的一直是PCB结构体。）这被称作“上下文切换”。根据系统架构不同，PCB也不相同。同时操作系统OS也在不停的给不同进程划分合适的内存空间保证安全性。（PS:多核可以同时维护多个PCB队列)

三、操作系统OS与硬件组成HardWare的联动#

首先，我们要更正一种观点：OS也是一种广义上的软件，只不过它运行在内核层，是一种特殊的交互软件，拥有特权指令的使用权（可以理解为super管理员权限），它负责用户空间和底层硬件的交互。然后我们再来刨析OS是怎样运行且保证安全性的：首先我们要认识到一点——为了保证安全性，我们通常划分为内核模式（可调用特权指令）和用户模式。而他们的切换由一个寄存器来控制：我们在运行程序的时候通常使用的是用户空间，这意味着我们不能使用特权指令，那么我们在需要使用调用系统层面的api函数的时候就会触发中断，将进程托管给内核运行。【当用户程序需要请求操作系统服务（如读写文件、网络通信等）时，会执行一条特殊的系统调用指令（例如 syscall 或 int 0x80），主动触发一个软件中断。此时 CPU 从用户模式切换到内核模式，并把控制权转交给操作系统内核中对应的系统调用处理程序，相当于把当前进程的“托管权”交给了内核。内核完成服务后，再通过中断返回指令让进程继续在用户空间执行**】。现代系统常用将内核常驻特权模式以获得通过特权指令保持对计算机的完全掌控。图中棕色内存区域存储着中断所需的服务例程（上一个图片所述）。也就是说，我们可以梳理出一个进程处理范式：cpu轮询处理队列中的pcb模块，然而当一个新进程启动的时候，假设它遇到了中断，就将此内容抛入pcb队列，等待cpu执行。OS在次过程中控制：IO，内存和中断。同时我们要认识到：中断不仅发生在硬件，还发生在软件层面：如果你有兴趣钻研linux源码，可以发现系统api(系统调用）函数内部我们也能找到出发中断的特权指令，让程序计数器跳转至操作系统地址空间中的特定例程。同时，系统调用函数也是对于驱动层以下的抽象化接口，让我们更加易的调用硬件抽象。同时你不用担心c/cpp这类中级语言会烧坏电路，因为硬件层由操作系统调配，我们只是做逻辑上的抽象。

1
| 中断类型 | 触发源 | 处理机制 |
2
|----------------|---------------|----------------------|
3
| 硬件中断 | 外设(键盘/磁盘) | 中断控制器→中断服务例程 |
4
| 软件中断(int) | 系统调用 | 陷入内核→执行特权指令 |

综上，操作系统让调用变得易用且安全。多系统的架构适配也让它具有跨平台功能。下面我们将要探讨非抢占式或协作式操作系统与抢占式操作系统。我们之前所说的用户空间与内核空间的协作是传统的非抢占式或协作式操作系统，现代基本已经弃用。因为假如在一个程序里面卡住了死循环，进程不能进入下一步，那么下一次系统调用永远进入不了pcb队列，操作系统也就会因此卡住。现代的做法则是使用抢占式操作系统。它的结构很简单，就是在原来的基础上增添了计时器来在某些时刻强制中断一段例程进入下一步。增加了操作系统运行的鲁棒性。 Tips:现在我们聊一下知识拓展：不仅仅OS存在于内核模式，我们常见的显卡驱动和作弊检测等进程也运行在此模式中。首先关于显卡，它的出现是晚于操作系统的，故操作系统并没有对于此显卡的适配，也就是说操作系统识别不出显卡是个什么东西。所以经常是厂家编写显卡的驱动程序来告诉操作系统如何运行使用它。由于是从硬件自底向上，所以它在OS所在层运行。有趣的是这类驱动常常和os写在一块地址上，所以编写十分困难且谨慎，否则容易让整个操作系统崩溃。作弊检测软件也在OS所在层进行，因为它的职责是扫描硬件是否存在作弊行为。如果是在用户层运行，那么经过操作系统，我们不知道是否是来自键盘输入还是来自手柄输入。最后我想聊聊安全检查的运行，它也在OS所在的内核模式层运行，通过监测内存空间的以异动和是否向可疑终端发送信息来判定是否受到攻击。

四、IPC通信机制#

在进程的运行中，我们常常将其分为协作进程和独立进程。在具有并行性能的计算机通常使用拆解为模块化的例程同时并行执行，减少运行时间。同时，我们在上一节课里已经了解到：特权指令保证了进程之间不会越界，如果越界，操作系统将立即中断并终止该进程，通过强制隔离策略保证数据的安全性。但是在协作进程里我们该怎么做呢？主流的方法有共享内存和消息传递：首先我们来介绍共享内存—— 共享内存是操作系统在内存中为多个进程通信而制作的内存块。操作系统只负责创建而不负责后续的分配。故而其效率非常高。多个进程将内存映射到这一块共享内存中，并且通过系统调用进行信息的读写。但是由于缺乏操作系统的规范和维护，我们通常使用信号量这一机制协助操作来维持通信的正确性和稳定性。一个经典的例子是谷歌浏览器：我们在打开使用谷歌浏览器的时候通常会在任务管理器里发现我们开启了多个进程，这其实是谷歌对Javastrcip所带有的语言缺陷而制作的防御机制。当我们运行时，它被分为多个进程分管插件，检索，播放器等的进程。这保证了一个进程崩溃而其他组件（进程）仍继续运行。他们之间使用共享内存和信号量来通信，实现数据互通。有趣的是，共享内存+信号量其实更常用于量化交易这类高性能场所，因为它复杂且难，不过这也是为什么谷歌被称为最棒的浏览器的原因之一了。

下面，我要介绍消息传递机制（也称消息队列）了，常用的消息传递机制包括管道、套接字和远程过程调用。操作系统内核会在自身地址空间内创建队列作为“邮箱”，而进程会在这些邮箱中来取信息和发信息，你可以把它看作一个拷贝中间件。当我们需要限制消息队列的时候，常用异步代替同步机制，或使用带缓存的队列。为了实现全双工的功能，我们使用双队列来执行“邮箱”功能，使两个进程能同时互传消息且互不干扰：当然，由于消息队列处于操作系统的内存内，进程不能够对它进行直接的调用，所以操作系统为它提供了两种交互方式：send()和receive()，他们作为系统调用的中间件来运输信息（虽然会有拷贝来减低性能）。客户端和服务端常使用套接字建立连接，他们是在机器上运行的进程而且并非必须需要网络才能运行，比如本地环回就能避免网络传输。无论如何，当客户端向服务器发送请求时，IP地址标识的是承载服务器进程的机器，提供HTTP、FTP或SSH等特定服务的服务器都依赖于套接字接口，虽然消息队列实现有很多优点，但是每一次执行都有复数级的系统调用导致了开销巨大：而共享内存由于直接操作内存片段，故而没有这个开销，但是代码极其复杂。

五、关于线程及其机制（单核）#

首先，我们要介绍并发这一技术，它通常与CPU调度一起协作使用。并发是指多个进程或线程在同一时间段内交替执行，通过时间片轮询的方式共享CPU资源。这种技术使得多个任务看似同时运行，实际上是通过快速切换实现的。

时间片轮询**：每个进程被分配一个固定的时间片，时间片用完后，CPU切换到下一个进程。
上下文切换：调度器保存当前进程的状态，加载下一个进程的状态，确保切换高效。

在传统的多进程中，每个进程只有一个程序计数器这也导致了它不能使用异步协程，故只能顺序执行。此时下图灰框的时间CPU没有运作，而因此它处于阻塞状态，这很浪费。为了解决这个棘手的问题，我们构造了一个监听进程专门来处理消息，然后把他们分派给其他进程执行，大大减少执行时间，提高了执行效率，尽管造成了资源浪费，内存被大量开销：为了解决程序在进程里线性顺序运行而多进程开销巨大的问题（程序计数器一次只能处理一个任务的中断），我们引入了线程，其精髓是将程序计数器分发给进程内每个需要并发执行的内部可执行实体：这样既解决了阻塞问题又无需创建新进程。假如某个线程要进行IO操作，不会中断影响其它线程的执行：同时，线程为了保证在“中断”后下次仍继续运行，除了程序计数器之外，还同时配备专属的寄存器组、状态标志位、累加器等，本质上构成其独有的CPU环境。同时具有独有的栈空间，用来防范数据冲突。线程之间消息传递通常使用堆内存，因为它不易错，更安全。虽然我们默认多线程共享一个进程空间，但是他们仍要通过IPC进程通信来共享数据。现代操作系统常用的是动态线程操纵，尽管会增加操作系统复杂度，但是由于编译阶段无法预知运行时实际需要的线程数量，它仍是现阶段场景下的主流选择。同时当主线程结束，其它线程也会跟着结束，他们很脆弱(^_^) 在服务器中，线程通过程序计数器指向进程的TEXT区域（文本段和数据段），这意味着多个线程可以指向完全相同的可执行代码。而且多进程执行相同的一段代码是绝对安全的很多时候大家会困惑C/CPP里面为什么线程函数为什么要带指针？答曰：实际上我们传递的是线程将要执行的代码起始内存地址。

六、线程与系统控制（多核）#

多核处理器让并发并行运行或全部并行，提高了效率，以下是对比：多核建立线程并不能通过建立n个线程同时进行n个任务，他们遵循两个准则：（1）核心数量是固定的：当有N个核心时，最多可有N个线程并行执行。（2）线程竞争资源：操作系统确保在所有线程之间公平分配CPU资源。并行也分为两种：（1）数据并行性：将相同数据的子集分布在多个计算核心上，并在每个核心上执行相同的操作。（2）任务并行性：将任务（或线程）而非数据分发到多个计算核心。每个线程执行一个独特操作。不同线程可能正在对同一数据进行操作。不同的线程可能在不同数据上运行。

七：不同系统间的文件#

在生活中我们有时发现奇怪的现象：同样的程序在win上能运行但是在mac上却不能？很多人会回答是因为CPU架构不同，一个是x86，一个是arm，但是2019之前，两家都用的x86却不能够互通，这说明原因不仅仅在与处理器芯片架构，还和系统调用（systemcalls）有着密切的关系。 usermode（用户模式）不能直接控制kernelcore（内核模式）但是可以请求系统调用来通过操作系统完成读出和写入的步骤。同时，因为系统调用的不同，在编译机器码的时候，不同平台会生成不同的指令来实现相同结果，但那些额外指令在另一个操作系统中将失去意义，最终导致未定义行为而系统崩溃。除此之外，系统调用的编号不同和寄存器编号不同都会影响程序的编译，导致崩溃。但是即使这些都相同也不行，因为系统调用传递参数的方式也不同(^_^)，他们传递放置的位置也不同。最后，可执行文件的文件格式也是原因之一，因为他们格式导致了存储和调用在内存里分配的位置不同。所以说，不同系统里面的文件是不能互通的。在用户空间执行系统调用之前，会实现一次中断并切换进入内核空间。我们常用的X86-64架构在执行这项任务的时候常用systemcall，但是如何进行区分这些systemcall呢？这时候我们采用了随机分配编号的方法，为每个调用分配唯一的编号。当使用时，将对应编号写入寄存器，进行相应的行为（查询系统调用表并进行相应的系统调用）

八、基于中断的切换机制#

正如我们之前所讨论的，中断的过程是：中断触发（系统调用） → 硬件保存部分上下文 & 切换内核模式 → 软件保存完整上下文到PCB → 执行中断服务程序（定时器监督）→ 返回（恢复上下文） / 可选上下文切换**。当然这是我们前面讲述的软件实现方式，它很少用于现实，因为安全性和实用性都很差（软件开销大且效率慢），下面我将拓展探讨关于中断的一原理。中断令人难以处理的部分是——在执行中断前，寄存器程序计数器已经存放的是中断代码所在的内存地址，这代表着我们在内核模式通过特权指令难以通过被禁用的特权指令完成相应任务后由于中断信号被覆盖，难以再通过程序计数器返回上一状态。故我们常常先通过操作系统软件的栈指针来记录CPU寄存器里的值，并且在存入开始和结束的时间，修改栈指针前将其值存入内存单元，记录下栈顶指针的值，之后直接从该内存区域推送数值。

下面，我们来介绍硬件的解决方法：我们为关键寄存器（例如栈指针和程序计数器）配备独立副本，同时将寄存器划分为内核和用户两部分，这样就不用每次繁琐的进行切换了。用户寄存器处理用户级别的普通的数据，当涉及系统调用的时候，我们将使用内核寄存器来控制使用那些被禁用的特权指令达到目的。同时在这个过程中上一个模式自然的记录了重要的寄存器数据，完成执行后直接去读就好了，避免了传统栈方法的繁琐和软件层面的耗时。当时首先你得认识到硬件永远比软件要快且好，但是基于其不可变性与批量生产制造成本高昂，所以即使是最激进的操作系统内核开发者也只会将它用在自动化存储数据这种通用内容之上。

九、系统理论：操作系统的核心组件——CPU调度器#

CPU调度是操作系统采用的核心技术，它根据特定规则决定在何时将CPU资源分配给哪个任务或进程执行。这一节我们将要介绍CPU在调度中的核心机制。 CPU 调度是操作系统中最核心的组件之一，它决定了哪一个进程能够在给定的时间使用处理器。正是因为通用操作系统在设计调度策略时优先保障响应时间，我们才能在 CPU 满载运行基准测试或者渲染视频的时候，仍然流畅地拖动鼠标、播放音乐，仿佛系统毫不费力。要理解这背后的机理，需要从最基本的概念开始，逐步深入到实际系统使用的复杂调度算法。当一个程序被加载执行时，它成为一个进程，操作系统在内存中为其分配一个文本段，用来存放可执行代码。CPU 内部有一个程序计数器，也就是地址寄存器，它始终指向内存中下一条要执行的指令。所谓把 CPU 分配给某个进程，本质上就是让程序计数器指向该进程的文本段。当 CPU 被重新分配给其他进程时，操作系统会修改程序计数器的值，使它指向新进程的代码。这个切换过程叫做上下文切换，它需要保存当前进程的全部执行现场，并恢复下一个进程的现场，CPU 才能继续执行。操作系统并不直接把进程作为调度对象，而是使用进程控制块来代表一个进程。进程控制块不是进程本身，而是一个数据结构，里面记录了进程的状态、程序计数器、寄存器内容、内存管理信息等几乎所有必要的元数据。每创建一个进程，系统就生成对应的进程控制块，后续的调度、切换和回收都是围绕这些控制块展开。进程在执行过程中并不会永远占据 CPU，它的生命周期由几个状态组成。刚被创建时处于新建状态，程序文件加载完毕后进入就绪状态，等待使用 CPU。一旦被调度器选中并开始执行，就进入运行状态。程序在执行过程中经常会因为输入输出操作或者等待用户输入等事件而主动放弃 CPU，这时它会进入等待状态，直到事件完成后重新回到就绪状态。最终进程执行结束，进入终止状态。对于绝大多数进程，都是在就绪、运行和等待这三个状态中反复循环，它们交替经历 CPU 突发和 I/O 突发。CPU 突发是指进程连续使用处理器进行计算的时间段，而 I/O 突发则是进程在发起 I/O 请求之后，等待磁盘、网络或者键盘等设备响应的时间。大量的观察数据表明，绝大部分进程的 CPU 突发都非常短，只有极少数进程存在很长的 CPU 突发。这个规律对调度算法的设计有着根本性的影响。为了有效管理众多进程，调度本身由两个紧密配合的部分组成。调度器负责按照既定策略从就绪队列里挑选下一个获得 CPU 的进程；分派程序则负责执行实际的上下文切换，把选中的进程真正放到 CPU 上去运行。上下文切换的时间，也被称为调度延迟，在很长一段时间里，工程师们热衷于减少调度延迟的时间优化系统响应速度，因为调度延迟纯粹是系统开销因此分派程序必须做到尽可能快。评价一个调度算法好坏的标准有很多：CPU 利用率衡量了处理器真正用于执行用户工作的时间比例；吞吐量关注单位时间内完成的进程数量；周转时间是从进程创建到它彻底完成所经历的总时间，既包括在就绪队列里的等待，也包括 CPU 执行和 I/O 等待；等待时间则只计算进程在就绪队列中等待 CPU 的总时长；响应时间则衡量从提交请求到系统第一次给出响应之间的时间长短，它对交互式体验至关重要。最简单的调度算法是先来先服务。它使用一个先进先出的队列，进程的进程控制块按照到达顺序加入队尾，当 CPU 空闲时，就从队头取出控制块分配处理器。这个策略的最大优点是实现简单，几乎没有额外的调度开销。但它的缺陷也很明显：排在队列头部的是一个 CPU 突发很长的进程时，所有后续的短进程都只能眼巴巴地等着，形成所谓的护航效应。此时 I/O 设备处于闲置状态，因为短进程无法及时执行并发起新的 I/O 操作，而 CPU 却被长进程独占，整个系统的设备利用率和吞吐量都被拉低。更糟糕的是，在非抢占系统里，如果某个进程没有主动执行系统调用，却在一个无限循环中空转，它就会永远霸占 CPU，其他所有进程都将冻结。针对长进程阻塞短进程的问题，最短作业优先调度算法进行了改进。它不再简单地按照到达顺序分配 CPU，而是去选择下一次 CPU 突发预测长度最短的那个进程。如果两个进程的预测长度相同，则退回到先来先服务的规则。从理论上说，最短作业优先能够在给定进程集合上获得最小的平均等待时间。原因在于，让短进程先运行可以大幅缩减它们的等待时间，而长进程尽管被延后了，但它只增加了一个相对微不足道的等待时间，两者的平均下降了。然而，这个算法面临一个几乎无法克服的困难：我们根本不可能提前知道某一个进程的下一次 CPU 突发到底有多长。解决的办法是去做预测，利用进程过去的历史来估计未来。通常采用指数平均法来推算预测值：公式的主体是把上一次的实际 CPU 突发长度和上一次对它的预测值按一定比例组合起来。具体来说，有一个系数 a，取值在 0 和 1 之间。当 a 等于 1 时，预测值完全取决于最近一次实际突发；当 a 等于 0 时，则完全抛弃近期行为，只信赖最初设定的基准值。展开这个公式会发现，历史上的每一次实际突发都对当前预测有贡献，但时间距离现在越远，其权重越小，呈指数衰减。这样，预测值既能跟踪进程行为的变化，又不会因为一两次异常值而剧烈浮动。对于新创建的进程，因为没有历史数据，操作系统一般会用一个人为设定的默认值或系统平均值作为初始预测。尽管这种预测永远不可能绝对准确，但已经能为最短作业优先算法提供可用的近似值。从先来先服务和最短作业优先可以看出，非抢占式的调度在通用系统中存在天然缺陷。如果运行中的进程不主动让出 CPU，调度器就毫无办法。为了解决这个问题，现代操作系统几乎都采用抢占式调度。也就是说，即使某个进程还在运行，只要条件满足，调度器就能强制打断它，把 CPU 夺走分配给另一个进程。这种方式靠的是硬件定时器支持，当分配给进程的时间片用完时，定时器会产生一个中断，操作系统顺势执行上下文切换。正是依靠抢占，系统才能实现并发，让多个进程在微观上轮流执行，宏观上给人所有程序同时运行的错觉。不过，抢占也会带来另一个麻烦：如果调度算法总是优先某些进程，其他进程就可能长时间分不到 CPU，产生饥饿。比如在最短作业优先里，只要不断有短进程进来，长进程的预测值永远竞争不过，可能永远得不到执行。轮转调度是一种专门为分时系统设计的抢占式算法，追求的是公平。它依然使用先进先出队列，但增加了一个关键机制——时间片。每个进程被分派到 CPU 时，最多只能连续运行一个时间片的时间。如果进程在这个时间片内因为 I/O 等原因主动释放 CPU，调度器自然切换到下一个进程。如果时间片耗尽了它还没有完成当前的 CPU 突发，定时器会强行中断它，把它挂到就绪队列的末尾，然后调度队头的下一个进程。这样的轮转保证了每一个就绪进程都能定期获得一小段 CPU 时间，不存在某一个进程一直占着处理器的情况。从响应时间的角度看，如果有 n 个进程，每个进程最多等待 n-1 个时间片就能再次运行，对用户来说响应是均匀且可预测的。但轮转调度的表现严重依赖于时间片的大小。一旦时间片设置得太大，轮转调度就退化成了先来先服务，长进程能连续运行很久，其他进程长时间无响应。反过来，如果盲目地把时间片设置得极小，上下文切换就会频频发生，处理器花费在保存和恢复现场上的时间比例急剧上升，真正用来干活的 CPU 时间变少，系统的吞吐量显著下降，周转时间被拉长。需知上下文切换绝非只是简单地保存几个寄存器的值，它往往需要陷入内核态，将当前进程完整的寄存器组、程序计数器、栈指针、内存映射信息等全部保存到进程控制块中，再从另一个进程的进程控制块中恢复整套运行现场，其中还可能涉及页表切换带来的 TLB 刷新以及 CPU 高速缓存的逐渐失效。这些操作本身就要消耗数十微秒甚至上百微秒的时间。如果时间片长度与上下文切换开销处于同一数量级，甚至更小，那么 CPU 每完成短短几微秒的用户指令就会被中断一次，转而花费大量周期去执行内核中的切换代码，整个系统将陷入“切换—执行一丝—再切换”的恶性循环，有效工作比例急剧下降。因此在实践中，时间片的大小必须远大于一次上下文切换的耗时，又要让绝大多数 CPU 突发能在一个时间片内自然完成，在响应速度和整体效率之间达到平衡。轮转调度虽然公平，但它对所有进程一视同仁，这在真实系统中并不是最优解。用户正在打字或者播放视频的交互式进程需要被快速响应，而后台压缩文件或者检查更新的进程晚半秒钟根本无人在意。于是，优先级调度应运而生。系统给每个进程赋予一个代表优先级的整数值，通常数值越小表示优先级越高，但也可能反过来，这完全取决于具体实现。调度时总是选择当前就绪进程中优先级最高的那一个来运行。相同优先级的进程之间则可以结合轮转调度来保证内部的公平性。优先级调度带来的最大好处是能够按照实际需求区分对待进程，把重要的、交互性强的任务推到前面，从而在感官上大幅提升系统的流畅度。但它的风险在于饥饿：如果高优先级进程源源不断地到来，低优先级的进程就可能永远没法被选中。一种经典的应对手段叫做老化，就是让进程在就绪队列里等待的时间越长，它的优先级就慢慢往上升。哪怕初始优先级最低，只要等得足够久，它终究会变成最高优先级而得到执行。这样既保留了优先级调度的灵活性，又避免了永久阻塞。如果只用一个队列来管理不同优先级的进程，调度器在高负载下可能需要遍历整个队列才能找出优先级最高的项，效率会降低。多级队列调度进一步把进程分门别类，放入各自独立的就绪队列当中，每一个队列可以有自己的调度算法。比如，前台交互进程进入一个队列用轮转调度，后台批处理进程进入另一个队列用先来先服务。然后在这些队列之间再建立一个层级调度，常见的方式是让高优先级队列具有绝对优先权，只有当它为空时，才去调度低优先级队列中的进程。也可以按比例在不同队列间分配 CPU 时间，避免低优先级队列完全饿死。但这种多级队列有一个明显的不足：进程一创建就被分配到了某一级别的队列，并且终身不变。然而一个进程的行为是会变化的，比如邮件客户端绝大多数时间在后台空闲，偶尔被用户激活到前台时，立即就需要极高的响应速度，固定的队列分配不能满足这种动态需求。为了应对进程行为的动态变化，多级反馈队列调度把多级队列的思路往前推进了一大步。它同样设置了多个优先级的就绪队列，但进程的队列归属不是一成不变的，而是根据它在运行中实际表现出来的 CPU 使用模式动态升降。一般来说，最高优先级的队列分配的时间片最短，往下每降低一级，时间片就增长一些。所有新进程都从最高优先级队列开始。如果进程在获得 CPU 后，在时间片用完之前就主动发起 I/O 进入等待状态，这表明它很有可能是交互式的短突发进程，于是它被放回原来的高优先级队列。如果进程耗尽了分配给它的时间片还没有结束这一次 CPU 突发，系统就会抢断它，并把它降级到下一层优先级更低的队列，在那里它将获得更长时间片，以便在后台一次性完成更多的计算。这种设计把短 CPU 突发、需要快速响应的进程自然而然地留在了高层，而把那些真正需要大量计算的 CPU 密集型进程慢慢沉到底层的大时间片队列里。同时，为了防止底层进程被无限期推迟，还可以结合老化机制，在一定条件或时间后将其优先级重新提升。这样一来，多级反馈队列不需要人工去标记哪个进程更“重要”，而是让每个进程用自己的实际行为投票，自适应地实现了交互进程快速响应与后台密集计算批量执行之间的平衡。这也是为什么我们在高负载时依然感觉系统流畅的根本原因：调度器自动把绝大多数 CPU 时间让给了那些在高层排队、突发极短的交互式进程，而占用 CPU 多的渲染或编译任务默默地在底层用剩下的时间片运行，不会打断我们的操作。关于现代 CPU 调度，还需要补充几个关键事实。今天操作系统调度的实体已经不是传统意义上的整个进程，而是线程。同一个进程内部可以有一个线程专门负责用户界面，另一个线程负责后台计算，它们各自拥有独立调度资格，可以分配不同的优先级，从而让一个重度计算的应用程序也能保持界面的流畅。此外，进程在发起 I/O 后进入的等待队列也并不是一个简单的先进先出队列，实际的 I/O 子系统会有自己的 I/O 调度器，会根据设备特性优化寻道、合并请求等，这与 CPU 调度是分离的。在多核处理器环境中，调度器还要考虑进程在各个核心之间的分配与迁移，牵涉到负载均衡、缓存亲和性以及功耗管理，这些问题需要更加复杂的调度策略去应对。

十、竞态条件#

首先我们需要理解到：源代码中的大多数操作需要通过多个 CPU 指令周期才能完成预期效果。多进程则是通过系统调用实现的“可并发执行”的例程，其执行无需等待前一个进程完成即可启动（也可设置为阻塞模式，但这属于核心功能的扩展内容，暂不深入讨论）。当机器具备多核处理器且进程数量不超过核心数时，系统执行的是真正的并行并发；而在单核处理器上，则是通过操作系统在进程间进行时间片轮转调度来实现并发执行。那么我们在这里需要讲述一个例子：在实际运用中，HTTP是我们常用的报文方法，而在这种BS的端侧架构中，我们常用并发来处理客户端信息，这样可以保证消息的实时性。朴素的解决方式是定义一个全局变量并制作一个客户端存取这个全局变量并专门处理消息的逻辑。不过这会导致一个极大的错误：在8500w次的首发测试中，我们会发现一些不和谐的地方而且这些不和谐的插曲是不可预测的：那么，这是为什么呢？答案说：对于不同的计算机架构，操作系统传递消息是一块一块传递的，而并非C语言的原子化单字符传递，这样效率太低，因此，当时间片运行完之前被中断，那么剩余部分的信息块与剩余未操作完的汇编指令就会错位到另一个进程中使用，同时可能引起连锁反应，所以盲目使用竞态是危险的。有人想出用特定的寄存器存取状态来避免这种情况的产生，但是很遗憾，寄存器在被时间片中断的时候也可能会产生竞态：比如说我们在写一个计数器操作时要自增五次，但是第一次在中途中断了，程序计数器停在了11，那么后面的进程没有受影响一直加到了14，并返回时，再次遇见11，这时14变成11，4个存储次数消失了。

十一、内存理论#

在讲述这块理论之前，我们要梳理一下观点：内存是CPU直接操纵的工作台，当我们想要运行程序的时候（程序存在磁盘里），我们会先从磁盘加载程序并创建进程运行，此时cpu才能操作并调用。这里涉及到一个安全问题：当我们想线程间共享数据的时候，很有可能会导致内存信息泄露，比如说支付程序，假如可以无限制访问那么黑客可以通过另外一条进程执行加载/存储指令的代码，就能进程的地址空间读取支付数据将其复制到自身地址空间，并通过网络发送给恶意攻击者或者篡改支付缓冲区，改动支付对象谋取私利。所以，默认情况下，进程必须被隔离，并且不允许访问任何其他进程的地址空间。通常，我们使用基址寄存器（开始地址）和界限寄存器（大小）来限制访问区域，如果本进程有范围外地址被访问，则判定为恶意入侵。我们通过二进制比较器来确定范围：通过图中Read Eable和Write Enable可以很简单实现阻止非法访问的操作

最后加上审查电路，我们可以讲信息反馈给CPU,进而终止进程来抵抗这种违规行为。

下图是现代封装架构：总结一下，操作系统不仅要保存被中断进程的状态，并恢复新进程的状态，还需更新内存边界——即调整基址与界限寄存器，使其与新进程的地址空间相匹配。当所有设置但在该模式下，CPU无法修改特权寄存器。准备就绪后，操作系统会将CPU切换至用户模式，因此，进程只能使用操作系统明确分配给它的内存空间。

第一章-全连接神经网络

Sun, 21 Jun 2026 00:00:00 GMT

在深度学习领域里，我们接触的第一个基础模型就是全连接神经网络，它具有层层传递的网状结构，通过一步步精密的传递运算来得到一个综合性的结果，下面我们来介绍一下全连接神经网络的构成与相关的函数用法。

前言#

在正式开始之前，我们先要明确一个概念：在众多深度学习的内容当中，我们要把我们所要得的结果看作一个高维空间里的向量，在大模型的语义检索环境里，构建词义之间的关系常常是通过向量的偏移来完成的，例如说：对于“男人”和“女人”的语义相关度，我们得到的向量偏移到哪“皇帝”和“皇后”这两个词之间，我们可以发现他们竟然惊人的相似，这也启发了我们：在某种层面上，我们可以通过分类和复用这些向量，来达到大大节省算力并训练模型这一目的。同时，这也侧面表明了一点：向量在高维空间里面存在的的时候，我们进行运算的载体必然是矩阵，同时，我们必须认识到，这些向量在高维空间里面也就说明了他们对应了多元未知数的方程，我们要做的就是在这个高维空间里面构建一个人类思维与语义体系，并且让其函数图像尽量吻合它在我们生活中的地位。那么，我们可以总结一个简单的概念：通常的，我们可以把这些向量看作由一个个基础函数拼接而成的高级高次函数，本质上是用概率论知识来做一个曲线拟合，只是说我们常用的元变成了矩阵来处理而已。

（PS:在计算机的存储中，图片的信息也是拟合为数字标注的深浅不一程度的颜色组成的矩阵：代表性的有单通道的灰度【只有一层】，和三通道的RGB【通过深浅不一的红黄蓝三原色来模拟电脑各种图案】）

全连接神经网络原理#

好啦，在介绍完这些基础概念后，我们来正式讲解全连接网络的构建：

如图所示，这是一个经典的全连接神经网络图，左侧输入端（五个神经元的上一层）是输入层，右侧五个神经元的下一步是输出层，而中间的六层神经网络则是隐藏层。我们常常把图片抽象化为矩阵来放入输入层，通过隐藏层的层层逻辑运算，输出一个预测的结果。

正如前言介绍概念所以说，神经网络是由不同权重的简单函数求和一层层累加而来的结果，每一个神经元都是代表一个特殊的和为1的权重部分，同时，在训练的时候，难免会产生宏观层面上的偏移来使结果偏离我们的预测值，这个时候，我们就需要一个偏置来帮助我们将结果拉回正轨：

在预测结果求和之后，我们可以看到，在神经网络中我们又引入了“激活函数“这一全新概念：这是因为，正如我们所讲，神经网络类似链式结构，层层相扣如网一般，这样代表着我们需要严密且大量的计算才能让多个简单的线性函数**达到一个稳定的且符合预测的值，而随着神经网络层数堆砌的深入，会出现过拟合的现象，导致我们的结果还没有训练到可控误差范围内，而高维向量已经经过极点向其他方向发生偏移，所以我们需要加入一个合适的“激活函数”（非线性）帮助我们缩小训练层数，更快更好的输出结果。下面，我将介绍几种主流的激活函数：

激活函数#

Sigmod函数：#

Sigmod函数是最基础的激活函数，但是由于其导数峰值小，仅存在一个象限中，同时这导致的增速慢训练量大的问题同时也体现了优化调整费时费力的缺陷。同时在反向传播的时候求导，平缓的波形部分会更加平缓，多次反向传播后变化率近似于0.

Tanh函数#

Tanh函数相比于Sigmod函数峰值更高而且对称分布，可以有效显示更大范围的数据，同时导数图峰值跟高，更易训练。

ReLU函数#

ReLU函数变化率在一定范围内是一个定值，故不存在梯度消失的风险。但是一旦离开这个范围，变化率趋于0，若出现训练偏移，易造成神经元死亡

Leaky ReLU函数#

Leaky ReLU函数通过运用不同变化率去除了神经元死亡的风险，但是同时也带来了正负输出值难以区别辨认的问题。

除此之外，还有许多种类的“激活函数”，每种函数都有其特殊的优缺点，我们应该因地制宜的去灵活使用他们。

前向传播#

在神经网络中一层层计算并向前传递求值的过程叫做前向传播。在其中我们可以每层用不同的合适的激活函数来拟合。

**损失函数#

损失函数更像是一种概率论的概念，求得一个相对准确的拟合位置。在这里要特别强调一点：公式开头除以的2是为了后驱反向传播求导更加简单完成设立的，其本质上模拟状态，是统计学知识。

梯度下降法#

如故事所言，梯度下降法就是找一条最快的还原“来时路”的一条求导路径。

这个公式在w（权重）和b（偏置）上都有运用，a是学习率（最优步长）。

通过反向传播，输出值比第一次更加接近理想值/真实值。

以上就是第一章全连接神经网络的基本概况，欢迎交流！

第三章--卷积神经网络下

Sun, 21 Jun 2026 00:00:00 GMT

在上一章中，我们介绍了卷积神经网络的图像识别原理，通道构成和计算方式，这一张我们接着上一讲的内容，继续讲解相关知识：填充，特征图计算公式，池化和多通道运算。

填充操作#

在介绍填充操作之前，我们先回顾一下上一章最后的内容：步幅。步幅是卷积核在特征图中的移动“速度”。那么，在多次卷积运算过后，我们的特征图会变得越来越小，直至“消失”。那么，如果最后的结果是一个n11的矩阵的话，我们所做的运算就没有任何意义了，于是，我们需要一种操作来使矩阵在每次运算过后保持原有的大小，以控制图的形状——那么，填充的方法应运而生：

如图，假设这是一个经过一次卷积运算过后的矩阵我们为了维持一个范围内稳定的矩阵大小，我们常常采用在这一矩阵外围一圈填充‘0’的方法（‘0’的厚度与卷积核-1的厚度对冲来尽量维持厚度）。这样，在下一次卷积运算中，我们的矩阵就可以稳定在一个范围内稳定大小：

特征图计算#

相关特征图的计算，我们可以使用以下的公式：

其中，OH代表输出的特征图高度，P是填充的单边厚度，H是输入特征图高度，FH是卷积核的高度。同理，OW则是输出特征图宽度，以此类推，可以算出宽度方向的数据。

池化层操作#

池化是卷积神经中的精髓，我们在这里仅介绍两种经典池化操作——平均池化和最大池化。在正式开始之前，我们先介绍一下感受野的概念：感受野是矩阵中某一子矩阵的称呼，它的计算类似卷积核，只不过FH和FW分别为感受野的长和宽。如图：

平均池化：

感受野中的数字求和(∑)再均摊求平均值并放入对应的矩阵答案里。

最大池化：

取感受野中最大的一个数字(MAX)并放入对应的矩阵答案里。

在池化的过程中，我们的目的是缩小矩阵，获取最有代表性的特征值并把他们放在一个新的矩阵里面，在这个过程中我们会特化一些重要参数，并且会损失一些边缘参数。

多通道运算#

对于多通道运算，我们需要记住一个性质：卷积核的个数和通道数相等。一堆特征图和其对应的卷积核进行相乘再相加的运算过后，再把多层特征图对应叠加为新的特征矩阵。

在正式的计算中，我们的多通道用C表示。

这里的多个卷积核代表着不同权重，最后叠加出的图层再次叠加，最后呈现一个特征矩阵。矩阵运算之后我们下一步就是分类和回归了，这个时候就要引入我们第一章讲的激活函数，进行下一步的拟合训练。

到此，卷积神经网络介绍完毕~

第二章卷积神经网络上

Sun, 21 Jun 2026 00:00:00 GMT

这一章，我们将要介绍卷积神经网络。在深度学习领域里，相比于全连接神经网络，卷积神经网络是一种更加高效的形式呢，同时在结构上卷积神经网络更加适用于图像的识别，区别于全连接神经网络每次只能操一维向量，卷积神经网络可以一次性传入图片（经卷积核优化计算），更加适用于图片领域。

图像的认识#

图片的构成原理#

在讲解卷积神经网络之前，我们先要梳理一下图像的概念：所谓图像，就是用深浅不一的同色色块拼接起来再多层覆盖形成的产物。我们先从灰度图像开始讲起：

如图所示，左侧是我们的视觉域所看到的图像，而右侧则是计算机眼里的图像，我们可以观察到——它是由多个数字组成的数组矩阵，这些[0-255]的数字表示像素点的深浅，把它们拼接起来再映射对应的颜色程度，就组成了我们所看到的黑白图片。此时，只有一种颜色，我们称之为单通道。

讲完了灰度图像的概念，现在我们讲讲我们日常里最常用的RGB图像。为了显示出多种颜色，同时我们也要符合计算机显像原理（计算机显示器的内部由红绿蓝三色组成），RGB图像应运而生。我们现在看到的RGB图像是通过把三个单通道的红绿蓝图像叠在一起实现的，如上图所示（单通道图片原理与灰度相同，显然这里的RGB图片是三通道图片）

通道的的概念#

此时，许多同学可能有疑惑：既然通道是图片组成的图层，那为什么我们浏览的代码所显示的channel有时候的数值远大于3（例如2565,1025），RGB可以组成所有颜色为何要如此多此一举？那么你我们需要做一个区分——此处代码所指向的通道并非是只能图层，而是经过卷积核处理过后的特征值。

全连接神经网络具有的问题#

在全连接神经网络中，计算常常为一维矩阵，所以我们的处理方式是把图像裁剪拼接成一个一维矩阵进行训练，最后再拆开为训练图。但这种方法会造成数据偏移从而导致图像失真，具体方法如图所示：

这个时候我们在想，是否有一种方法能够直接进行图像训练，而不用繁杂而吃力不讨好的全连接预处理呢？于是卷积神经网络应运而生。

卷积神经网络的运算原理：#

运算方法#

我们将卷积核看作是一个由多个权重w组成的矩阵，而输入则选定一个子矩阵以固定步幅移动并与卷积核上权重相乘再相加所得的特征值，（有时到最后一步之前，每个输出块要加上一个偏置b）。

对于此类卷积神经网络的反向传播运算，仍是更新权重w:

w=w-a*(d(J)/dw);

b=b-a*(d(J)/dw);

y=h(wx+b);

步幅：#

如图，对于44的图像特征值矩阵，步幅代表矩阵的子矩阵每次移动的幅度。如图所示，步幅为2，答案为22矩阵，若每次只移动一位，则步幅为1，答案为3*3矩阵。

以上就是卷积神经网络（上）的内容了，我们下期再见——👋

计算机组成原理绪论

Sun, 21 Jun 2026 00:00:00 GMT

这一栏目，我们开始讲解有关计算机组成原理的知识，旨在梳理和提炼这一繁杂课程。本章笔者将会从计算机基本的组成和运行原理来整理这一绪论。首先，我们来认识一下主体结构：

1.CU控制器：相当于主控台，控制其他元件的行为逻辑。

2.ALU运算器：用于进行CU控制器发布的任务进行运算。

3.寄存器：寄存器用于临时存储CPU正在处理或即将处理的数据、指令和地址，访问速度远高于内存（RAM），存放“正在处理”的数据。

4.cache高速缓存：是位于 CPU 和主内存（RAM）之间的一种高速、小容量的存储器，其主要作用是缓解 CPU 与主存之间速度不匹配的问题**，从而提高计算机系统的整体性能，存放 CPU 最近或最可能使用的内存数据和指令，速度高，但低于寄存器。存储器：存储数据的地方，关于存储我们还可以分为以下几层：

顶层，最接近CPU：越快、成本高、容量小——寄存器、高速缓存Cache** → 常用的数据/指令
下一层：主存储器（主存/内存）慢一些，成本低一些，容量大一些 —— **易失性存储介质（开机时加载的数据，断电后数据丢失）
第三层：虚拟内存/磁盘缓存
底层：硬盘（机械硬盘，固态硬盘SSD）最慢、成本最低、容量最大 —— **永久性存储介质接下来是八大规则：

面向摩尔定律的设计**：指出在一个芯片上集成的晶体管数量每18到24个月就会翻一番。（目前已经被废除）使用抽象简化设计**：使用抽象用来表示不同的设计层次，高层次的看不见低层次的细节，只能看见一个简化的模型。每个模块只用专注于自己眼下本身的模块。加速大概率事件**：是优先关注那些对系统性能影响最大的操作或组件，并对其进行优化。通过集中资源和精力在这些关键点上，我们可以更有效地提升系统的整体性能和效率。通过并行来提高性能**：这里着重介绍一下：并行和并发，并发是单核处理器同时处理多件任务，类似一个人在多个饭菜面前一盘吃一口（交替执行），并行是多核处理器同时处理多项任务，类似每个人吃饼，一人一块。通过流水线来提高性能**：流水线（Pipeline）是一种经典的并行处理技术，它将一个复杂的计算任务拆分成多个连续且相对独立的阶段，并让这些阶段像工厂流水线一样依次执行。如图所示：通过预测来提高性能**：预测技术通过预测未来的指令或数据，提前进行预取和预处理，从而减少等待时间和提高处理速度。这一点常用深度学习和机器学习相关的知识解释优化存储器层次结构**：旨在解决不同存储器设备在速度、容量和价格之间的矛盾。这种层次结构通过将不同类型的存储器按照其特性和成本效益组织成多个层次，从而实现了高效的数据访问和管理。通过冗余提高可靠性**：是通过增加额外的硬件组件来提高系统的可靠性和容错能力。

好了，我们第一章绪论介绍完毕！

链表最终章双向链表及其应用

Sun, 21 Jun 2026 00:00:00 GMT

———————————本文旨在交流探讨计算机知识，欢迎交流指正———————————— 上一章，我们介绍了链表的循环扩展，但是，单向链表毕竟是单向查询的，就算是经过循环来查找，终究是效率偏低，下面，我们来介绍一种工程项目中运用更加广泛的一种链表结构：双向链表——：根据此结构，我们可以发现，虽然代码复杂度增加了，但是由于此结构是双向的，操作更加便捷，下面，我将演示各模块内容：首先，是结构的构建：

1
typedef int Element;
2
typedef struct _node {
3
Element val;
4
struct _node *next;
5
struct _node *prev;
6
} DNode, DList;
7

8
/* 使用一个带头节点的双向循环链表，头节点让用户来管理，提供初始化接口 */
9
void initDList(DList *header);
10
void releaseDList(DList *header);
11

12
// 实现头插、尾插
13
void insertDListHeader(DList *header, Element val);
14
void insertDListRear(DList *header, Element val);
15
// 显示链表
16
void showDList(const DList *header);
17
// 删除一个元素
18
void delDList(DList *header, Element e);

展开收起

注：此为.h头文件里的内容，若先用头文件封装再放在.c文件里面使用，最后在main.c文件里面测试，很好的保证了产品内容的安全性与代码便捷性。 1、这一次，为了让代码更加简洁规范，我们使用static的模式构建加入和删除两大基本模块：

1
//next是已知的待插入位置节点的下一个节点；
2
//prev是已知的待插入节点的上一个节点（前置节点）；
3

4
//插入
5
static void addDNode(DNode *new_node, DNode *prev, DNode *next) {
6
next->prev = new_node;//待插入节点下一个节点的上一个节点是新节点；
7
new_node->next = next;//新节点的下一个是上一个节点；
8
new_node->prev = prev;新节点上一个是前置节点
9
prev->next = new_node;前置节点下一个是新节点
10
}
11

12
//删除
13
static void delDNode(DNode *prev, DNode *next) {
14
next->prev = prev;//某节点下一个节点的前一个是某节点上一个节点；
15
prev->next = next;//某节点上一个节点的下一个是某节点下一个节点；
16
}

展开收起

2、然后，我们再在此基础上完成增删改查的基本操作：

1、初始化：

1
void initDList(DList* header) {
2
 header->val = 0;//初始化头结点的数值域为0
3
 header->next = header->prev = header;//头结点的前置节点和后置节点都初始化指向头结点
4
}

2、增添操作：

1
void insertDListHeader(DList* header, Element val) {
2
 DNode *new_node = malloc(sizeof(DNode));//malloc申请空间建立一个新节点
3
 new_node->val = val;//新节点赋值；
4
 addDNode(new_node, header, header->next);//函数操作
5
 ++header->val;
6
}
7
//头插法;
8
void insertDListRear(DList* header, Element val) {
9
 DNode *new_node = malloc(sizeof(DNode));
10
 new_node->val = val;
11
 addDNode(new_node, header->prev, header);
12
 ++header->val;
13
}
14
//尾插法；

3、删除操作

1
void delDList(DList* header, Element e) {
2
 // 1. 找到这个元素，就可以删除，不需要再找到前置节点
3
 DNode *pos = header->next;
4
 while (pos != header && pos->val != e) {
5
 pos = pos->next;
6
 }
7
 // 2. 找到没有？
8
 if (pos != header) { // 找到
9
 delDNode(pos->prev, pos->next);
10
 pos->next = pos->prev = NULL;
11
 free(pos);
12
 --header->val;
13
 } else {
14
 printf("Not find %d element!\n", e);
15
 }

展开收起

4、展示函数（若对工程有疑问和对const有疑问可以看本专栏的第一篇内容）

1
void showDList(const DList* header) {
2
 DNode *pos = header->next;
3
 printf("show: ");
4
 while (pos != header) {
5
 printf("\t%d", pos->val);
6
 pos = pos->next;
7
 }
8
 printf("\n");
9
}
10
//简单的循环打印，不过多赘述；

5、最后，是销毁链表的函数：

1
void releaseDList(DList* header) {
2
 DNode *pos = header->next;
3
 DNode *tmp = NULL;
4
 while (pos != header) {
5
 tmp = pos;
6
 delDNode(pos->prev, pos->next);
7
 pos = pos->next;
8
 free(tmp);
9
 --header->val;
10
 }
11
}
12
//逐个销毁

最后附上各文件代码： 1、doubleList.h:

1
#ifndef DOUBLE_LIST_H
2
#define DOUBLE_LIST_H
3

4
typedef int Element;
5
typedef struct _node {
6
Element val;
7
struct _node *next;
8
struct _node *prev;
9
} DNode, DList;
10

11
/* 使用一个带头节点的双向循环链表，头节点让用户来管理，提供初始化接口 */
12
void initDList(DList *header);
13
void releaseDList(DList *header);
14

15
// 实现头插、尾插
16
void insertDListHeader(DList *header, Element val);
17
void insertDListRear(DList *header, Element val);
18
// 显示链表
19
void showDList(const DList *header);
20
// 删除一个元素
21
void delDList(DList *header, Element e);
22

23
#endif //DOUBLE_LIST_H

展开收起

2、doubleList.c

1
#include "doubleList.h"//doubleList.h文件封装的函数名
2
#include
3
#include
4

5
static void addDNode(DNode *new_node, DNode *prev, DNode *next) {
6
next->prev = new_node;
7
new_node->next = next;
8
new_node->prev = prev;
9
prev->next = new_node;
10
}
11

12
static void delDNode(DNode *prev, DNode *next) {
13
next->prev = prev;
14
prev->next = next;
15
}
16

17
void initDList(DList* header) {
18
header->val = 0;
19
header->next = header->prev = header;
20
}
21

22
void releaseDList(DList* header) {
23
DNode *pos = header->next;
24
DNode *tmp = NULL;
25
while (pos != header) {
26
tmp = pos;
27
delDNode(pos->prev, pos->next);
28
pos = pos->next;
29
free(tmp);
30
--header->val;
31
}
32
}
33

34
void insertDListHeader(DList* header, Element val) {
35
DNode *new_node = malloc(sizeof(DNode));
36
new_node->val = val;
37
addDNode(new_node, header, header->next);
38
++header->val;
39
}
40

41
void insertDListRear(DList* header, Element val) {
42
DNode *new_node = malloc(sizeof(DNode));
43
new_node->val = val;
44
addDNode(new_node, header->prev, header);
45
++header->val;
46
}
47

48
void showDList(const DList* header) {
49
DNode *pos = header->next;
50
printf("show: ");
51
while (pos != header) {
52
printf("\t%d", pos->val);
53
pos = pos->next;
54
}
55
printf("\n");
56
}
57

58
void delDList(DList* header, Element e) {
59
// 1. 找到这个元素，就可以删除，不需要再找到前置节点
60
DNode *pos = header->next;
61
while (pos != header && pos->val != e) {
62
pos = pos->next;
63
}
64
// 2. 找到没有？
65
if (pos != header) { // 找到
66
delDNode(pos->prev, pos->next);
67
pos->next = pos->prev = NULL;
68
free(pos);
69
--header->val;
70
} else {
71
printf("Not find %d element!\n", e);
72
}
73
}

展开收起

3、main.c

1
#include
2
#include "doubleList.h"
3

4
DList stu_table;
5

6
int main() {
7
initDList(&stu_table);
8

9
for (int i = 0; i < 5; ++i) {
10
// insertDListHeader(&stu_table, i + 100);
11
insertDListRear(&stu_table, i + 100);
12
}
13
insertDListHeader(&stu_table, 60);
14
insertDListHeader(&stu_table, 80);
15
showDList(&stu_table);
16
printf("====================\n");
17
delDList(&stu_table, 102);
18
showDList(&stu_table);
19
releaseDList(&stu_table);
20
printf("num: %d\n", stu_table.val);
21
showDList(&stu_table);
22
return 0;
23
}

展开收起

————————————希望能对你有所帮助！！！————————————————

链表的实现与介绍

Sun, 21 Jun 2026 00:00:00 GMT

——————————————本文旨在交流计算机知识，欢迎指正————————————— 首先，我们回顾一下上一期讲的顺序表：顺序表是一种物理结构上连续的，一整块连续空间的逻辑表，但是，试想一下，如果每次我们都是申请在一块整块空间里面的顺序表，但是我们并不知道堆空间里面我们malloc一块空间之后我们并不知道它的存储样式，假设我们申请了两段空间，但是这两块空间之间只有两个单位，但是我们要新存下四个单位的顺序表，那么这两个单位的空间显然装不下我们的顺序表，我们需要另外申请一块新的空间去存它，但是这些夹着的碎片化空间就会造成浪费，无法使用：于是，我们这时候需要一种新的结构去存储，来避免这种空间浪费的情况，链式存储结构应运而生：这样，我们就能理论上节约内存了；（PS: 事实上，由于操作系统的存在，我们存储的只是在虚拟内存上，而它真实的内存其实映射到我们的物理内存上并非是如此的，于是对于顺序表操作系统给我们分配的物理内存其实并非真正连续的，我们这里讨论的其实只是无操作系统下关于内存的合理化分配）下面，我们来详细讲讲关于链表的知识：首先我们给出链表的图形化结构：我们的链表包含一个头节点，一个尾部节点和数个中间节点，头结点的前驱是空，尾节点的后继也是空，中间节点都拥有前驱与后继。关于每一个节点，我们将其分为两个部分：1、数据域 2、地址域；数据域存储该节点应该存储的数值，地址域指向下一个地址，然后我们通过地址域来访问下一个值。

这样，我们就构成了一份链式存储结构；于是，下面我们来尝试写一下代码：

首先，和顺序表一样，我们先来定义链表的节点结构：

1
#ifndef COMMON_H
2
#define COMMON_H
3
typedef int Element_t;
4
// 1. 定义链表的节点结构
5
typedef struct _node{
6
Element_t val;//数据域
7
struct _node *next;//存储下一个节点地址的地址域
8
} node_t;
9

10
#endif //COMMON_H

第二步，我们来写链表头结点的定义及函数的定义（如果对这里有所不明白的地方请翻到我的上一篇文章查看.h文件与.c文件的关系）：

1
#ifndef CHAIN_LIST_H
2
#define CHAIN_LIST_H
3
#include "common.h"
4

5
// 2. 定义带头指针的链表头结构
6
typedef struct {
7
node_t *header;
8
int count;
9
} ChainList_t;
10

11
// 3. 链表头放到数据区，放到全局变量
12
void initChainList(ChainList_t *table);
13

14
void destroyChainList(ChainList_t *table); // 销毁该链表的元素区域，头不管
15

16
int insertChainListHeader(ChainList_t *table, Element_t val);//头插法
17

18
int insertChainListPos(ChainList_t *table, int pos, Element_t val);//按位插入
19

20
int deleteChainListElement(ChainList_t *table, Element_t val);//按值删除
21

22
void showChainList(const ChainList_t *table);//显示链表
23
#endif //CHAIN_LIST_H

展开收起

第三步，我们开始正式写函数啦：（一）初始化函数

1
void initChainList(ChainList_t* table) {
2
table->count = 0;//表头不计入元素个数
3
table->header = NULL;//表头指向NULL
4
}

（二）销毁链表函数

1
void destroyChainList(ChainList_t *table) {
2
// 创建虚拟头节点，方便统一处理所有节点
3
node_t dummy;
4
dummy.next = table->header;
5
// 从虚拟头节点开始遍历链表
6
node_t *p = &dummy;
7
node_t *tmp;
8
// 逐个释放链表中的所有节点
9
while (p->next) {
10
tmp = p->next; // 保存当前要删除的节点
11
p->next = tmp->next; // 从链表中移除该节点
12
free(tmp); // 释放节点占用的内存
13
--table->count; // 更新链表节点计数
14
}
15

16
// 输出链表剩余节点数
17
printf("LinkList have %d node!\n", table->count);
18
// table->header = NULL;
19
}

展开收起

（三）头插法

1
int insertChainListPos(ChainList_t* table, int pos, Element_t val) {
2
node_t dummy;
3
dummy.next = table->header;
4

5
// 1. 判断边界值
6
if (pos  table->count) {
7
printf("insert pos invalid!\n");
8
return -1;
9
}
10
// 2. 找到pos - 1索引的节点首地址
11
node_t *p = &dummy;
12
int index = -1;
13
while (index next;
14
++index;
15
}
16
node_t *new_node = malloc(sizeof(node_t));
17
new_node->val = val;
18
new_node->next = p->next;
19
p->next = new_node;
20
++table->count;
21

22
table->header = dummy.next;
23
return 0;
24
}

展开收起

（四）、删除操作

1
int deleteLinkListElement(LinkList_t* table, Element_t val)
2
{
3
node_t *p = &table->head;//引入辅助节点
4
while (p->next!=NULL)
5
{
6
if (p->next->val == val)break;//如果当前辅助节点存储的值val等于删除目标，退出循环
7
p = p->next;//辅助节点不断向后遍历
8
}
9
if (p->next == NULL)//判断是否有该值
10
{
11
return -1;
12
}
13
node_t *tmp = p->next;
14
p->next = tmp->next;
15
free(tmp);
16
table->count--;//记录链表节点减1
17
return 0;
18
}

展开收起

（五）、展现函数

1
void showChainList(const ChainList_t* table) {
2
node_t *p = table->header;
3
printf("link list: %d\n", table->count);
4
while (p) {//如果p存在
5
printf("%d\t", p->val);
6
p = p->next;
7
}
8
printf("\n");
9
}

（六）、主函数（测试函数）

1
// 带头节点的单向链表测试
2
int test01() {
3
LinkList_t* table = createLinkList();
4
if (table == NULL) {
5
return -1;
6
}
7
for (int i = 0; i < 10; ++i) {
8
insertLinkListHeader(table, i + 100);
9
}
10
insertLinkListPos(table, 3, 300);
11
showLinkList(table);
12
printf("========================\n");
13
deleteLinkListElement(table, 105);
14
showLinkList(table);
15

16
releaseLinkList(table);
17
return 0;
18
}
19

20
int main() {
21
test01();
22
return 0;
23
}

展开收起

锵锵~到这里就要收尾啦！希望这篇文字对你有所帮助！

附录对于头结点单向链表的优化方法

Sun, 21 Jun 2026 00:00:00 GMT

————————————本文旨在交流学习计算机知识，欢迎交流讨——————————— 上一章，我们浅显的讨论了链表的结构，本文在上一章的链表的基础上做出了些许优化，可配合食用。回到正题，我们已经了解链表的结构，它是一种非连续空间存储的线性表，主要依靠地址域访问下一个元素并通过遍历操作进行增删改查。如图，这是我们上一章所介绍的链表结构：我们的惯用操作：

1
//单向链表的插入，删除（先找到节点p）：
2

3
//插入：
4
newnode->next=p->next;
5
p->next=newnode;
6
//删除：
7
node_new temp;
8
temp=p->next;
9
p->next=p->next->next;
10
free(temp);

看着这幅图，我们不禁想到一个问题：我们真的需要这个头节点吗，是否有些看起来不整齐且结构不一致？于是，我们考虑到：也许我们可以用指针标记header的位置，然后再在每一次的函数接口里面新建一个头结点，用完即删，这样或许看起来更加的整齐和高效。如图所示：这时，我们引入dummy节点，并将其放入栈，dummy节点充当第一个节点。

1
void insert(link*header,element val)
2
{
3
node_t dummy;
4
dummy->next=header;//header为我们的指针（因为简化了头结点，我们只传入指针）
5
node_t *p=&dummy;//p为遍历指针，从dummy开始遍历；
6
while(p->next)
7
{
8
p=p->next;
9
}
10
header=dummy->next;//还原操作；
11
}

下面，我们重写一下代码：定义链表结构：

1
typedef int Element_t;
2
struct node{
3
Element_t val;
4
struct node *next;
5
}node_t;
6
//节点的结构体；
7

8
typedef struct {
9
node_t *header;
10
int count;
11
} List_t;
12
//链表结构体（包括头结点和数量）；

初始化链表：

1
void initList(List_t *table)
2
{
3
table->count=0;
4
table->header=NULL;
5
)

从最基础的展现函数开始：

1
void shouList(const List_t *table){
2
node_t p=table->header;
3
printf("List :");
4
while(p)
5
{
6
printf("%d\t",p->val);
7
p=p->next;
8
}
9
printf("\n");
10
}

这里如果不知道const为什么要放在形参里的可以看看我的第一篇文章，里面有详细解答。然后就是增删改查的经典案例了：从增开始：

1
int insertListHeader(List_t* table,Element_t val)
2
{
3
node_t dummy;
4
dummy.next=table->header;
5

6
node_t *p=&dummy;//临时头结点dummy及临时过渡中间容器p；
7
node_t *new_node=malloc(sizeof(node_t));
8

9
if(new_node==NULL)
10
{
11
printf("ERROR\n");
12
)
13
//朴素的增加操作；
14
new_node->val=val;
15
new_node->next=p->next;
16
p->next=new_node;
17
++table->count;
18

19
table->header=dummy->next;
20
return 0;
21
}

展开收起

然后这是按位插入操作：

1
int insertListPos(List_t* table,int pos,Element_t val)
2
{
3
if(postable->count)
4
{
5
printf("the pos is not a truly place\n");
6
}
7
node_t dummy;
8
dummy.next=table->header;
9
node_t* p=&dummy;
10
int index=-1;//计数器；
11
while(indexnext;
12
++index;
13
}//遍历查找
14
node_t *new_node=malloc(sizeof(node_t));
15
new_node->next=p->next;
16
p->next=new_node;
17
++table->count;
18
table->header=dummy.next;
19
return 0;
20
}

展开收起

删除操作：

1
int deleteList(List_t* table,Element val)
2
{
3
node_t dummy;
4
dummy.next=table->header;
5

6
node_t* p=&dummy;
7
while(p->next&&p->val!=val)
8
{
9
p=p->next;
10
}
11
if(p->next==NULL)
12
{
13
printf("404 NOT FOUND\n");
14
return 0;
15
}
16
node_t temp=malloc(sizeof(node_t));
17
temp=p->next;
18
p->next=p_next_next;
19
free(temp);
20
--table->count;
21
table->header=dummy->next;
22
return 0;
23
}

展开收起

最后的最后就是销毁链表了： ###关于销毁链表，其原理就是按位遍历并按位删除。###

1
void destroyList(List_t *table) {
2
node_t dummy;
3
dummy.next = table->header;
4

5
node_t *p = &dummy;
6
node_t *tmp;
7
while (p->next) {
8
tmp = p->next;
9
p->next = tmp->next;
10
free(tmp);
11
--table->count;
12
}
13
printf("LinkList have %d node!\n", table->count);
14
// table->header = NULL;
15
}

展开收起

以上就是附录内容，欢迎指正！

顺序表的实现与介绍及部分工程思想的思考

Sun, 21 Jun 2026 00:00:00 GMT

——————————本文旨在讨论和探究计算机知识，欢迎指正———————————— 首先，我们来聊聊什么是线性表：线性表，顾名思义，是一种具有线性结构的数据排布形式，是一个类似数组的东西，在逻辑上一个接一个有序的整块链接，区别于链表的无序分布链接。如图，我们可以得出，顺序表是一条线一样的结构，环环相扣，存在唯一的第一个元素（表头），也存在唯一的最后一个元素（表尾）。除了表头和表位，每个元素都有一个前驱和后继。特别的，在c/c++里面，我们的数组就是一个很好的顺序结构，但是它是静态的，无法扩容和插入，这是因为数组是在栈空间里面实现的，所谓栈空间，就是申请后编译器自动分配的空间，这个空间是有限的，无法进行扩容，但是好在方便申请。而我们今天讨论的就是在堆空间上实现的动态顺序结构：所谓堆空间，就是程序员操作的空间，你可以在里面实现各种结构变化，扩容，插入等等… 如图：下面，让我们开始顺序表的实现吧！首先，我们要定义表头：类似数组的结构，我们的顺序表是要在堆里面申请一块连续的空间。那么，这个空间的开始地址就很重要了。回顾数组，例如我们定义：

1
int a[3]={0,1,2};
2
printf("%d",a+1);
3
//这时，会输出1的答案，那么a其实就是数组a的最开始的地址，类比表头

有趣的是，我们在使用c++的STL工具时，vectorvc所定义的就是一个表头：

这里是我们定义的表头的结构体： 1、element 是一种重命名后的变量形式，它的好处在于我们typedef后如果某天发现数据存储形式错误，我们可以直接改element 而不是在每段每段的程序里面找和抠，极大减少了工作量。同时，Element_t也是工程里面常用的一种定义模式，“_t”有种正确规范的意味。 2、pos是我们动态的“数据个数”，也是“下一个是第几个数据”，方便定位，极大优化了查找效率。 3、capacity 是顺序表空间的容量个数，表征最多存的数量，扩容的时候常用。代码实现：

1
typedef struct {
2
Element_t *data; // 存储表中数据空间的首地址
3
int pos; // 指向数据空间的待插入的位置，也是空间里数据个数的表示
4
int capacity; // 表中目前最大的存储容量
5
} SEQTable_t;

下面，我们讲讲工程思想：一般的，我们在写代码的时候，总是一股脑的把所有函数和代码放在一个文件里面，但是这样对多文件编程和重复调用很不友好，我们得每次使用都在子函数里面在写一遍，很麻烦且容易错，下面本文将简单介绍一下常用方法：

关于多文件编程，我们可以做到如下几点，来使得函数在同一个文件夹内协同作用：

以上是用clion软件为例，在CMakeLists.txt中的add_executable()里面加上你希望一起需用的文件名，就可以使用了；当然，这里我们的前导是文件打开的文件夹的名字：

add_executable**：这是 CMake 的内置命令，作用是告诉 CMake 要创建一个可执行文件。
seqTable：此为可执行文件的名称，编译完成后，在构建目录下会生成名为 seqTable（Windows 系统下是 seqTable.exe）的可执行文件。
01_seqTable/main.c：表示源文件的路径，这里指明使用 01_seqTable 目录下的 main.c 文件来编译生成可执行文件。

如果你要使用中文，但是你用的是Windows系统，记得把UFT-8改为GBS国标，由于编译方式的不同，会出现乱码。（Linux和Mac不会有这种问题） 2、头文件的类编写：如果在一个文件夹下我们进行头文件.h的编写，那么下次使用（在文件夹内）我们就可以直接用头文件里面的东西了，而不用在main.c文件里面再写一遍。有些人可能会想一个疑问：既然.h文件里面可以编写结构体而且能直接被.c使用，为什么不在.h的文件里面编写函数，这样不是更方便吗？回答：我们不要把.h和.c看成两部分，也不要只认为.h只在.h的目录下实现。因为——.h只要能被编译器读到，那这个.c就可以被正常编译，所以.h放哪里都可以，只是要告诉编译器这个.h在哪里。一般像gcc有-I选项，VC那块可以右键属性添加查找头文件路径的。 .h相当于是一个显性目录的作用，.c是我具体实现的代码，我可能不想公开给别人，但是别人想用我的函数，我就告诉他我函数的申明，然后我把.c编译成动态库给他。就像printf那样，你根本就不知道咋实现的，但是可以轻松使用它。我们在#include “a.h“的时候，没有前缀，直接写a.h就表示在当前目录下查找是否有这个文件，只要头文件能找到，就可以直接用函数了。这是一个顺序表的.h文件的实现：

1
//
2
// Created by 水木 on 25-5-30.
3
//
4

5
#ifndef SEQ_TABLE_H
6
#define SEQ_TABLE_H
7

8
//定义一个数据空间存储类型
9
typedef int ElemType_t;//这里尾部加上_t指的规范的重命名数据类型；
10

11
typedef struct {
12
ElemType_t *data;//首地址
13
int pos;//待插入位置
14
int capacity;//最大存储容量
15
}SEQTable_t;
16

17
//表头在堆上申请，提供给其他函数使用，需要释放的接口；
18
SEQTable_t *createSeqTable(int n);//申请内存
19
void releaseSeqTable(SEQTable_t *table);//释放内存
20

21
int pushbackSeqTable(SEQTable_t* table, ElemType_t val);//尾插法
22

23
static int enlargeSeqTable(SEQTable_t *table);//扩容
24

25
int insertPosSeqTable(SEQTable_t *table, int index, ElemType_t value);//中间插入
26

27
int findSeqTable(const SEQTable_t* table, ElemType_t val);//找寻函数
28

29
void deleteSeqTable(SEQTable_t* table,ElemType_t val);//删除函数
30

31
void ShowSeqTable(const SEQTable_t *table);//此时用静态变量
32

33
#endif //SEQ_TABLE_H

展开收起

下面，我们回到顺序表的实现上来：首先，我们实现申请表头的函数:

1
SEQTable_t *createSeqTable(int n) {
2
SEQTable_t* table = NULL;
3
table = malloc(sizeof(SEQTable_t));
4
if (table == NULL) {
5
fprintf(stderr,"SeqTable malloc defeat!\n");//申请失败，释放表头
6
return NULL;
7
}
8
table->data = malloc(sizeof(ElemType_t)* n);
9
if (table->data==NULL) {
10
fprintf(stderr,"SeqTable data malloc defeat!\n");
11
free(table);//申请结构体内数据数组空间失败，释放表头
12
return NULL;
13
}
14
table->pos=0;//初始化pos；
15
table->capacity=n;//初始化capacity
16
return table;
17
}

展开收起

有了表头，就要有释放函数：

1
void releaseSeqTable(SEQTable_t *table) {
2
//如果有表头空间就释放
3
if (table) {
4
//如果有数据空间就释放
5
if (table->data) {
6
free(table->data);
7
}
8
free(table);
9
}
10
}

下面，我们来实现增删改查：首先，是增：

1
//这里使用static有好处，是静态继承的，只会在内部改变，不会因为外界干扰而紊乱，增加安全性
2
static int enlargerTable(SEQTable_t *table) {
3
// 1. 再申请一个新空间，初始化申请的空间
4
Element_t *tmp = malloc(sizeof(Element_t) * table->capacity * 2);
5
if (tmp == NULL) {
6
printf("enLargerTable malloc failed!\n");
7
return -1;
8
}
9
// 2. 拷贝老内容到新空间，for循环一个个拷贝，直接空间拷贝
10
memcpy(tmp, table->data, sizeof(Element_t) * table->pos);//string.h下的函数memcpy(空间名,赋值位置,赋值个数*单位大小=总体积)
11
// 3. 更新表头，释放老空间
12
table->capacity *= 2;//两倍扩容是一个习惯性行为
13
free(table->data);//释放原空间
14
table->data = tmp;//将原空间指针指向现有空间
15

16
return 0;
17
}
18
//特别的，空间扩容是先创建一个副本再copy上去，最后释放空间，为防止空间泄露，所以不在原来空间上扩容（可能原来空间的下面几个空间已经被分配给其他板块，如果在原空间上强项扩容可能导致其他版块数据丢失，程序崩溃）
19

20
int pushbackSeqTable(SEQTable_t* table, ElemType_t val) {
21
if (table == NULL) {
22
fprintf(stderr,"SeqTable malloc defeat\n");//排除表头不存在的时候增
23
return -1;
24
}
25
//这里是集成了扩容函数enlaegeSeqTable(table)的增添，如果满了的条件下就增，否则跳过不判断，扩容函数返回0的时候是扩容成功所以&&满足true的时候输出扩容失败：
26
if (table->pos>=table->capacity&&enlaegeSeqTable(table)) {
27
printf("badbad,cant enlarge place!\n");
28
return -1;
29
}
30
table->data[table->pos]=val;//赋值，扩容成功
31
++table->pos;//pos右移，指向下一个
32
return 0;
33
}

展开收起

其次，是删和查的实现：

1
int findSEQTable(const SEQTable_t *table, ElemType_t val) {
2
for (int i=0;ipos;++i) {
3
if (table->data[i]==val) {
4
return i;
5
}
6
}
7
return -1;
8
}//删查一体，查找到了才能删；
9

10
int deleteSeqTable(SEQTable_t* table, Element_t value) {
11
// 1. 查找value在数据结构中的索引位置
12
int index = findSeqTable(table, value);
13
//未找到则输出“Not find %d element!”
14
if (index == -1) {
15
printf("Not find %d element!\n", value);
16
return -1;
17
}
18
// 2. 删除这个元素，把[index + 1, pos) 搬移覆盖到，把后一个给前一个
19
for (int i = index + 1; i pos; ++i) {
20
table->data[i - 1] = table->data[i];
21
}
22
--table->pos;
23
return 0;
24
}

展开收起

最后，是改的实现（插入）：

1
int insertPosSeqTable(SEQTable_t* table, int index, Element_t value) {
2
// 1. 空间有效性的判断
3
if (index  table->pos) {
4
printf("index Invalid!\n");
5
return -1;
6
}
7
// 顺序表进行扩容
8
if (table->pos >= table->capacity && enlargerTable(table)) {
9
printf("....\n");
10
return -1;
11
}
12
// 2. 搬移数据为新数据预留位置 从后往前 data[i + 1] = data[i];
13
// [pos-1, index] 使用for --操作
14
for (int i = table->pos - 1; i >= index; --i) {
15
table->data[i + 1] = table->data[i];
16
}
17
table->data[index] = value;
18
++table->pos;
19

20
return 0;
21
}

展开收起

噢，对了，还有一个展现函数：

1
void showSeqTable(const SEQTable_t* table) {
2
if (table == NULL) {
3
return;
4
}//没有表，没有展现的
5

6
for (int i = 0; i pos; ++i) {
7
printf("%d\t", table->data[i]);
8
}//制表符\t，看起来更整齐
9

10
// deleteSeqTable(table, )
11
printf("\n");
12
}

下面，是我们的测试函数，在main.c里面测试：

1
void test01() {
2
SEQTable_t *table01=createSeqTable(10);
3
if (table01==NULL) {
4
return;
5
}
6
for (int i=0;i<5;i++) {
7
pushbackSeqTable(table01,100+i);
8
}
9
for (int i=5;i<10;i++) {
10
insertSeqTable(table01,i-2,100-i);
11
}
12
showSeqTable(table01);
13
releaseSeqTable(table01);
14
}
15

16
int main() {
17
test01();
18
return 0;
19
}

展开收起

顺序表的总结：希望对您有所帮助！ ——————————————————欢迎指正————————————————————

Firefly 代码块示例

Sat, 03 Jan 1970 00:00:00 GMT

在这里，我们将探索如何使用 Expressive Code 展示代码块。提供的示例基于官方文档，您可以参考以获取更多详细信息。

表达性代码#

语法高亮#

语法高亮

常规语法高亮#

1
console.log('此代码有语法高亮!')

渲染 ANSI 转义序列#

Terminal window展开收起

1
Standard ANSI colors:
2
- Dimmed:      Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
3
- Foreground:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
4
- Background:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
5
- Reversed:    Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
6

7
8-bit colors (showing colors 160-171 as an example):
8
- Dimmed:      160  161  162  163  164  165  166  167  168  169  170  171 
9
- Foreground:  160  161  162  163  164  165  166  167  168  169  170  171 
10
- Background:  160  161  162  163  164  165  166  167  168  169  170  171 
11
- Reversed:    160  161  162  163  164  165  166  167  168  169  170  171 
12

13
24-bit colors (full RGB):
14
- Dimmed:      ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
15
- Foreground:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
16
- Background:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
17
- Reversed:    ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
18

19
Font styles:
20
- Default
21
- Bold
22
- Dimmed
23
- Italic
24
- Underline
25
- Reversed
26
- Strikethrough

展开收起

编辑器和终端框架#

编辑器和终端框架

代码编辑器框架#

my-test-file.js

1
console.log('标题属性示例')

src/content/index.html

1
<div>文件名注释示例</div>

终端框架#

Terminal window

1
echo "此终端框架没有标题"

PowerShell 终端示例

1
Write-Output "这个有标题!"

覆盖框架类型#

1
echo "看，没有框架!"

PowerShell Profile.ps1

1
# 如果不覆盖，这将是一个终端框架
2
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
3
New-Alias tail Watch-Tail

文本和行标记#

文本和行标记

标记整行和行范围#

1
// 第1行 - 通过行号定位
2
// 第2行
3
// 第3行
4
// 第4行 - 通过行号定位
5
// 第5行
6
// 第6行
7
// 第7行 - 通过范围 "7-8" 定位
8
// 第8行 - 通过范围 "7-8" 定位

选择行标记类型 (mark, ins, del)#

line-markers.js

1
function demo() {
2
  console.log('此行标记为已删除')
3
  // 此行和下一行标记为已插入
4
  console.log('这是第二个插入行')
5

6
  return '此行使用中性默认标记类型'
7
}

为行标记添加标签#

labeled-line-markers.jsx

1
<button
2
  role="button"
3
  {...props}
4
  value={value}
5
  className={buttonClassName}
6
  disabled={disabled}
7
  active={active}
8
>
9
  {children &&
10
    !active &&
11
    (typeof children === 'string' ? <span>{children}</span> : children)}
12
</button>

在单独行上添加长标签#

labeled-line-markers.jsx展开收起

1
<button
2
  role="button"
3
  {...props}
4

5
  value={value}
6
  className={buttonClassName}
7

8
  disabled={disabled}
9
  active={active}
10
>
11

12
  {children &&
13
    !active &&
14
    (typeof children === 'string' ? <span>{children}</span> : children)}
15
</button>

展开收起

使用类似 diff 的语法#

1
此行将标记为已插入
2
此行将标记为已删除
3
这是常规行

1
--- a/README.md
2
+++ b/README.md
3
@@ -1,3 +1,4 @@
4
+this is an actual diff file
5
-all contents will remain unmodified
6
 no whitespace will be removed either

结合语法高亮和类似 diff 的语法#

1
function thisIsJavaScript() {
2
  // 整个块都会以 JavaScript 高亮显示，
3
  // 并且我们仍然可以为其添加 diff 标记！
4
  console.log('要删除的旧代码')
5
  console.log('新的闪亮代码！')
6
}

标记行内的单独文本#

1
function demo() {
2
  // 标记行内的任何给定文本
3
  return '支持给定文本的多个匹配项';
4
}

正则表达式#

1
console.log('单词 yes 和 yep 将被标记。')

转义正斜杠#

Terminal window

1
echo "Test" > /home/test.txt

选择内联标记类型 (mark, ins, del)#

1
function demo() {
2
  console.log('这些是插入和删除的标记类型');
3
  // return 语句使用默认标记类型
4
  return true;
5
}

自动换行#

自动换行

为每个块配置自动换行#

1
// 启用换行的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// wrap=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

配置换行的缩进#

1
// preserveIndent 示例（默认启用）
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// preserveIndent=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

可折叠部分#

可折叠部分


5 collapsed lines
1
// 所有这些样板设置代码将被折叠
2
import { someBoilerplateEngine } from '@example/some-boilerplate'
3
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'
4

5
const engine = someBoilerplateEngine(evenMoreBoilerplate())
6

7
// 这部分代码默认可见
8
engine.doSomething(1, 2, 3, calcFn)
9

10
function calcFn() {
11
  // 您可以有多个折叠部分
3 collapsed lines
12
  const a = 1
13
  const b = 2
14
  const c = a + b
15

16
  // 这将保持可见
17
  console.log(`计算结果: ${a} + ${b} = ${c}`)
18
  return c
19
}
20

4 collapsed lines
21
// 直到块末尾的所有代码将再次被折叠
22
engine.closeConnection()
23
engine.freeMemory()
24
engine.shutdown({ reason: '示例样板代码结束' })

展开收起

行号#

行号

为每个块显示行号#

1
// 此代码块将显示行号
2
console.log('来自第2行的问候!')
3
console.log('我在第3行')

// 此块禁用行号
console.log('你好?')
console.log('抱歉，你知道我在第几行吗?')

更改起始行号#

5
console.log('来自第5行的问候!')
6
console.log('我在第6行')

Firefly 布局系统详解

Sat, 03 Jan 1970 00:00:00 GMT

📖 概述#

Firefly 提供了灵活的布局系统，允许您根据内容需求和个人喜好自定义博客的视觉呈现方式。布局系统主要包括侧边栏布局和文章列表布局两个维度，它们相互配合，共同决定了页面的整体结构。

本文将详细介绍 Firefly 的各种布局模式、它们的特点、使用场景，以及不同布局组合的效果。

左侧边栏+列表布局

右侧边栏+网格布局

左侧边栏+三列网格布局

双侧边栏+列表布局

双侧边栏+网格布局

双侧边栏+网格瀑布流布局

一、侧边栏布局系统#

侧边栏是博客页面的重要组成部分，用于展示导航、分类、标签、统计信息等辅助内容。Firefly 支持两种侧边栏布局模式。

1.1 单侧边栏模式#

左侧边栏 (position: “left”)#

左侧边栏布局

右侧边栏 (position: “right”)#

右侧边栏布局

特点#

侧边栏固定在页面其中一侧
文章阅读区域体验更佳，更宽敞
更加简约，没有那么紧凑

适用场景#

传统博客风格
强调导航和分类的博客
需要突出用户资料的个人博客
内容为主，辅助信息次之的场景

Tip

可以通过showBothSidebarsOnPostPage配置是否在文章详情页显示双侧边栏

当position为left或right时开启此项后，文章详情页将显示双侧边栏，主页等其他页面保持单侧边栏

适用在只想用单侧栏，但在文章详情页想用对侧栏的目录等组件的场景

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "left", // 左侧边栏
4
  showBothSidebarsOnPostPage: true, // 是否在文章详情页显示双侧边栏
5
};

1.2 双侧边栏模式 (position: “both”)#

特点#

左右两侧同时存在侧边栏
主内容区域位于中间
最大化利用屏幕空间
可以展示更多辅助信息
适合宽屏显示器

布局结构#

双侧边栏+列表布局

双侧边栏+网格布局

适用场景#

宽屏桌面端浏览
信息密集型博客
需要展示大量辅助内容
专业性强的技术博客

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "both", // 双侧边栏

二、文章列表布局系统#

文章列表是博客首页和归档页的核心内容，Firefly 提供两种展示方式，并支持多种网格配置。

2.1 列表模式 (defaultMode: “list”)#

特点#

单列纵向排列
显示文章封面图
展示更多文章摘要
适合深度阅读

列表布局结构#

列表模式布局

优点#

✅ 视觉冲击力强，封面图吸引眼球
✅ 可以展示更多文章信息（摘要、标签等）
✅ 适合图片内容丰富的博客
✅ 移动端友好，单列更易阅读
✅ 兼容所有侧边栏配置（单侧、双侧）

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "list", // 列表模式
4
    allowSwitch: true,   // 允许用户切换
5
  },
6
};

2.2 网格模式 (defaultMode: “grid”)#

特点#

自适应列数，根据浏览器宽度自动调整
紧凑布局，信息密度高
适合快速浏览

自适应网格#

网格模式通过 columnWidth 配置卡片的最小宽度（单位 px），浏览器会根据容器可用宽度自动计算能容纳多少列。

网格布局

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "grid",
4
    allowSwitch: true,
5
    grid: {
6
      masonry: true,      // 开启瀑布流
7
      columnWidth: 320,   // 卡片最小宽度(px)，浏览器自动计算列数
8
    },
9
  },
10
};

2.3 瀑布流布局 (Masonry)#

Firefly 的网格模式内置了智能瀑布流布局支持，解决了网格布局中因图文混合文章导致的卡片高度不一致导致的空白问题。

瀑布流布局

智能排版：自动将卡片放置到最短的列，最大化利用垂直空间。
消除空白：通过绝对定位精确计算每个卡片的位置，让卡片紧贴上方卡片，消除垂直方向的空白间隙。
自适应列数：瀑布流同样根据 columnWidth 和容器宽度动态计算列数，无需固定配置。
配置灵活：您可以在 siteConfig.ts 中通过 postListLayout.grid.masonry 选项自由开启或关闭此功能。

三、布局组合指南#

Firefly 允许您自由组合侧边栏和文章列表布局。以下是各种组合的效果说明。

侧边栏模式	文章列表模式	推荐度	适用场景
单侧边栏	列表模式	⭐⭐⭐⭐⭐	摄影、设计、生活类博客，强调图片和沉浸感
单侧边栏	网格模式	⭐⭐⭐⭐⭐	技术、笔记类博客，平衡阅读与检索效率
双侧边栏	列表模式	⭐⭐⭐⭐⭐	需要展示大量侧边栏信息的站点
双侧边栏	网格模式	⭐⭐⭐⭐⭐	极客风格，追求最高信息密度

四、响应式布局行为#

Firefly 的布局系统具有智能的响应式设计，会根据屏幕尺寸自动调整。

为了保证最佳阅读体验，系统会在屏幕变窄时自动调整布局：

网格列数自动减少：网格模式的列数由 columnWidth 和容器宽度自动决定，屏幕越窄列数越少。
列表模式 -> 网格模式：当屏幕宽度小于 380px（超小屏设备）时，列表模式会自动切换为网格模式，以保证卡片内容的可读性。
双侧边栏 -> 单侧边栏：当屏幕宽度小于 1280px 时，会根据tabletSidebar配置显示单侧边栏，隐藏其中一个侧边栏，文章目录导航会切换成浮动目录导航。

五、常见问题#

Q1: 如何调整网格列数？#

A: 通过 columnWidth 配置卡片最小宽度即可。值越小，同等宽度下列数越多；值越大，列数越少。浏览器会自动根据可用宽度计算最佳列数。

六、总结#

Firefly 的布局系统给予了您更大的自由度，您都可以通过简单的配置实现。

我们建议您根据自己的内容类型和目标读者的设备偏好，尝试不同的组合，找到最适合您的博客形态。

Firefly 文章加密

Fri, 02 Jan 1970 00:00:00 GMT

这是一篇密码保护的示例文章，用于演示文章加密功能。

KaTeX 数学公式示例

Fri, 02 Jan 1970 00:00:00 GMT

本文展示了 Firefly 主题对 KaTeX 数学公式的渲染支持。

行内公式 (Inline)#

行内公式使用单个 $ 符号包裹。

例如：欧拉公式 eiπ+1=0e^{i\pi} + 1 = 0eiπ+1=0 是数学中最优美的公式之一。

质能方程 E=mc2E = mc^2E=mc2 也是家喻户晓。

块级公式 (Block)#

块级公式使用两个 $$ 符号包裹，会居中显示。

∫−∞∞e−x2dx=π\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}∫−∞∞e−x2dx=πx=−b±b2−4ac2ax = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}x=2a−b±b2−4ac

复杂示例#

矩阵 (Matrices)#

(abcd)(αβγδ)=(aα+bγaβ+bδcα+dγcβ+dδ)\begin{pmatrix} a & b \\ c & d \end{pmatrix} \begin{pmatrix} \alpha & \beta \\ \gamma & \delta \end{pmatrix} = \begin{pmatrix} a\alpha + b\gamma & a\beta + b\delta \\ c\alpha + d\gamma & c\beta + d\delta \end{pmatrix}(acbd)(αγβδ)=(aα+bγcα+dγaβ+bδcβ+dδ)

极限与求和 (Limits and Sums)#

∑n=1∞1n2=π26\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}n=1∑∞n21=6π2lim⁡x→0sin⁡xx=1\lim_{x \to 0} \frac{\sin x}{x} = 1x→0limxsinx=1

麦克斯韦方程组 (Maxwell’s Equations)#

∇⋅E=ρε0∇⋅B=0∇×E=−∂B∂t∇×B=μ0J+μ0ε0∂E∂t\begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \\ \nabla \cdot \mathbf{B} &= 0 \\ \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \\ \nabla \times \mathbf{B} &= \mu_0\mathbf{J} + \mu_0\varepsilon_0\frac{\partial \mathbf{E}}{\partial t} \end{aligned}∇⋅E∇⋅B∇×E∇×B=ε0ρ=0=−∂t∂B=μ0J+μ0ε0∂t∂E

化学方程式 (Chemical Equations)#

\ceCH4+2O2−>CO2+2H2O\ce{CH4 + 2O2 -> CO2 + 2H2O}\ceCH4+2O2−>CO2+2H2O

符号	代码	渲染结果
Alpha	`\alpha`	α\alphaα
Beta	`\beta`	β\betaβ
Gamma	`\Gamma`	Γ\GammaΓ
Pi	`\pi`	π\piπ
Infinity	`\infty`	∞\infty∞
Right Arrow	`\rightarrow`	→\rightarrow→
Partial	`\partial`	∂\partial∂

MDX 格式文章示例

Fri, 02 Jan 1970 00:00:00 GMT

Tip

Firefly 支持 MDX 和 Markdown 两种类型的文章，你可以在文章中混合使用两种格式，如果没有特别复杂内容和需求，推荐使用 Markdown 格式就够了。

Markdown 和 MDX 的区别#

Markdown (MD) 是一种轻量级标记语言，允许用户使用纯文本格式编写文档，然后将其转换为格式化的HTML。它因其简洁易用的语法而广受欢迎，特别适合编写文档和博客文章。
MDX 是一种扩展了 Markdown 语法的格式，允许在 Markdown 文档中无缝地插入 JSX 代码。通过 MDX，用户可以在文档中嵌入 React 组件，从而实现更丰富的交互性和动态性。

特性	Markdown	MDX
基础语法	支持 (CommonMark)	支持 (CommonMark)
HTML 标签	支持	支持 (作为 JSX)
组件导入	不支持	支持 (import)
动态数据	不支持	支持 (JS 表达式)
样式定制	有限 (class/style)	灵活 (className/CSS-in-JS)

使用组件#

这是一个图标组件：

1
import { Icon } from 'astro-icon/components'
2

3
<div class="flex items-center gap-2 my-4">
4
  <Icon name="fa7-solid:rocket" class="text-4xl text-red-500" />
5
  <span>火箭发射！</span>
6
</div>

火箭发射！

使用 JSX#

你也可以直接写 HTML/JSX：

1
<div className="p-4 bg-blue-100 dark:bg-blue-900 rounded-lg my-4">
2
  这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。
3
</div>

这是一个自定义样式的 div 块，使用了 Tailwind CSS 类。

简单的变量导出#

1
export const year = new Date().getFullYear()
2

3
今年是 {year} 年。

今年是 2026 年。

更多信息，请查看 MDX 文档

Markdown 扩展功能

Thu, 01 Jan 1970 00:00:00 GMT

GitHub 仓库卡片#

您可以添加链接到 GitHub 仓库的动态卡片，在页面加载时，仓库信息会从 GitHub API 获取。

CuteLeaf

Firefly

Waiting for api.github.com...

00K

Waiting...

使用代码 ::github{repo="CuteLeaf/Firefly"} 创建 GitHub 仓库卡片。

1
::github{repo="CuteLeaf/Firefly"}

提醒框(Admonitions)配置#

Firefly 采用了 rehype-callouts 插件，支持了四种风格的提醒框主题：GitHub、Obsidian、VitePress 和 Docusaurus。您可以在 src/config/siteConfig.ts 中进行配置：

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  // ...
3
  rehypeCallouts: {
4
    // 选项: "github" | "obsidian" | "vitepress" | "docusaurus"
5
    theme: "github",
6
  },
7
  // ...
8
};

注意：更改配置后需要重启开发服务器才能生效。

以下是各个主题支持的类型列表，每个主题风格和语法不同，可根据喜好选择。

1. GitHub 主题风格#

这是 GitHub 官方支持的 5 种基本类型。

GitHub

基本语法

1
> [!NOTE] NOTE
2
> 突出显示用户应该考虑的信息。
3

4
> [!TIP] TIP
5
> 可选信息，帮助用户更成功。
6

7
> [!IMPORTANT] IMPORTANT
8
> 用户成功所必需的关键信息。
9

10
> [!WARNING] WARNING
11
> 关键内容，需要立即注意。
12

13
> [!CAUTION] CAUTION
14
> 行动的负面潜在后果。
15

16
> [!NOTE] 自定义标题
17
> 这是一个带有自定义标题的示例。

展开收起

2. Obsidian 主题风格#

Obsidian 风格支持非常丰富的类型和别名。

点击展开 Obsidian 语法列表

1
> [!NOTE] NOTE
2
> 通用的笔记块。
3

4
> [!ABSTRACT] ABSTRACT
5
> 文章的摘要。
6

7
> [!SUMMARY] SUMMARY
8
> 文章的总结（同 Abstract）。
9

10
> [!TLDR] TLDR
11
> 太长不看（同 Abstract）。
12

13
> [!INFO] INFO
14
> 提供额外信息。
15

16
> [!TODO] TODO
17
> 需要完成的事项。
18

19
> [!TIP] TIP
20
> 实用技巧或提示。
21

22
> [!HINT] HINT
23
> 暗示（同 Tip）。
24

25
> [!IMPORTANT] IMPORTANT
26
> 重要信息（Obsidian 风格通常使用类似的图标）。
27

28
> [!SUCCESS] SUCCESS
29
> 操作成功。
30

31
> [!CHECK] CHECK
32
> 检查通过（同 Success）。
33

34
> [!DONE] DONE
35
> 已完成（同 Success）。
36

37
> [!QUESTION] QUESTION
38
> 提出问题。
39

40
> [!HELP] HELP
41
> 寻求帮助（同 Question）。
42

43
> [!FAQ] FAQ
44
> 常见问题（同 Question）。
45

46
> [!WARNING] WARNING
47
> 警告信息。
48

49
> [!CAUTION] CAUTION
50
> 注意事项（同 Warning）。
51

52
> [!ATTENTION] ATTENTION
53
> 引起注意（同 Warning）。
54

55
> [!FAILURE] FAILURE
56
> 操作失败。
57

58
> [!FAIL] FAIL
59
> 失败（同 Failure）。
60

61
> [!MISSING] MISSING
62
> 缺失内容（同 Failure）。
63

64
> [!DANGER] DANGER
65
> 危险操作警告。
66

67
> [!ERROR] ERROR
68
> 错误信息（同 Danger）。
69

70
> [!BUG] BUG
71
> 报告软件缺陷。
72

73
> [!EXAMPLE] EXAMPLE
74
> 展示一个例子。
75

76
> [!QUOTE] QUOTE
77
> 引用一段话。
78

79
> [!CITE] CITE
80
> 引证（同 Quote）。
81

82
> [!NOTE] 自定义标题
83
> 这是一个带有自定义标题的示例。

展开收起

Obsidian

3. VitePress 主题风格#

VitePress 风格提供了一套现代化的、扁平的默认样式。目前仅包含与 GitHub 一致的 5 种 基础类型。

点击展开 VitePress 语法列表

1
> [!NOTE] NOTE
2
> 对应 GitHub 的 Note。
3

4
> [!TIP] TIP
5
> 对应 GitHub 的 Tip。
6

7
> [!IMPORTANT] IMPORTANT
8
> 对应 GitHub 的 Important。
9

10
> [!WARNING] WARNING
11
> 对应 GitHub 的 Warning。
12

13
> [!CAUTION] CAUTION
14
> 对应 GitHub 的 Caution。
15

16
> [!TIP] 自定义标题
17
> VitePress 风格同样支持自定义标题。

展开收起

VitePress

4. Docusaurus 主题风格#

Docusaurus 风格提供了一套现代化的提醒框样式，支持 5 种类型。

点击展开 Docusaurus 语法列表

支持以下类型的提醒框：note tip info warning danger

1
:::note
2
突出显示用户应该考虑的信息，即使在快速浏览时也是如此。
3
:::
4

5
:::tip
6
可选信息，帮助用户更成功。
7
:::
8

9
:::info
10
一般信息。
11
:::
12

13
:::warning
14
由于潜在风险需要用户立即注意的关键内容。
15
:::
16

17
:::danger
18
行动的负面潜在后果。
19
:::
20

21
:::tip[自定义标题]
22
可选信息，帮助用户更成功。
23
:::

展开收起

Docusaurus

剧透#

您可以为文本添加剧透。文本也支持 Markdown 语法。

内容被隐藏了哈哈！

1
内容 :spoiler[被隐藏了 **哈哈**]！

图片画廊网格 (Image Grid)#

您可以使用 [grid] 和 [/grid] 标签将多张图片纵向并排展示。这对于展示照片画廊或对比图非常有用。系统会自动根据包裹在其中的图片数量（最多支持并排展示4张）以响应式网格进行布局。

自动补齐图片高度： 同一排中如果有高度、大小或者比例不一的图片，会像「九宫格画廊相册」一样自动撑满。较短或不协调的图片会自动使用 object-cover 进行完美中心裁剪补充视野。图片边框水平彻底对齐无缝隙，但被裁剪后，只有点击图片通过灯箱才能查看完整图片，所以建议尽量避免使用长宽比例不一致的图片在同一排中。

图注恒定底端对齐： 不论上面的图片长宽如何变化，在同一行的所有图像解释文字（图注）都会对标到一条完美的水平基线上了。

示例图片一

示例图片二

基本语法

1
[grid]
2
![示例图片一](./images/firefly1.avif)
3
![示例图片二](./images/firefly2.avif)
4
![示例图片二](./images/firefly3.avif)
5
[/grid]

Markdown Mermaid 图表

Thu, 01 Jan 1970 00:00:00 GMT

Markdown 中 Mermaid 图表完整指南#

本文演示如何在 Markdown 文档中使用 Mermaid 创建各种复杂图表，包括流程图、时序图、甘特图、类图和状态图。

流程图示例#

流程图非常适合表示流程或算法步骤。

graph TD A[开始] --> B{条件检查} B -->|是| C[处理步骤 1] B -->|否| D[处理步骤 2] C --> E[子过程] D --> E subgraph E [子过程详情] E1[子步骤 1] --> E2[子步骤 2] E2 --> E3[子步骤 3] end E --> F{另一个决策} F -->|选项 1| G[结果 1] F -->|选项 2| H[结果 2] F -->|选项 3| I[结果 3] G --> J[结束] H --> J I --> J

时序图示例#

时序图显示对象之间随时间的交互。

sequenceDiagram participant User as 用户 participant WebApp as 网页应用 participant Server as 服务器 participant Database as 数据库 User->>WebApp: 提交登录请求 WebApp->>Server: 发送认证请求 Server->>Database: 查询用户凭据 Database-->>Server: 返回用户数据 Server-->>WebApp: 返回认证结果 alt 认证成功 WebApp->>User: 显示欢迎页面 WebApp->>Server: 请求用户数据 Server->>Database: 获取用户偏好 Database-->>Server: 返回偏好设置 Server-->>WebApp: 返回用户数据 WebApp->>User: 加载个性化界面 else 认证失败 WebApp->>User: 显示错误消息 WebApp->>User: 提示重新输入 end

甘特图示例#

甘特图非常适合显示项目进度和时间线。

gantt title 网站开发项目时间线 dateFormat YYYY-MM-DD axisFormat %m/%d section 设计阶段需求分析 :a1, 2023-10-01, 7d UI设计 :a2, after a1, 10d 原型创建 :a3, after a2, 5d section 开发阶段前端开发 :b1, 2023-10-20, 15d 后端开发 :b2, after a2, 18d 数据库设计 :b3, after a1, 12d section 测试阶段单元测试 :c1, after b1, 8d 集成测试 :c2, after b2, 10d 用户验收测试 :c3, after c2, 7d section 部署生产环境部署 :d1, after c3, 3d 发布 :milestone, after d1, 0d

类图示例#

类图显示系统的静态结构，包括类、属性、方法及其关系。

classDiagram class User { +String username +String password +String email +Boolean active +login() +logout() +updateProfile() } class Article { +String title +String content +Date publishDate +Boolean published +publish() +edit() +delete() } class Comment { +String content +Date commentDate +addComment() +deleteComment() } class Category { +String name +String description +addArticle() +removeArticle() } User "1" -- "*" Article : 写作 User "1" -- "*" Comment : 发表 Article "1" -- "*" Comment : 拥有 Article "1" -- "*" Category : 属于

状态图示例#

状态图显示对象在其生命周期中经历的状态序列。

stateDiagram-v2 [*] --> 草稿草稿 --> 审核中 : 提交审核中 --> 草稿 : 拒绝审核中 --> 已批准 : 批准已批准 --> 已发布 : 发布已发布 --> 已归档 : 归档已发布 --> 草稿 : 撤回 state 已发布 { [*] --> 活跃活跃 --> 隐藏 : 临时隐藏隐藏 --> 活跃 : 恢复活跃 --> [*] 隐藏 --> [*] } 已归档 --> [*]

饼图示例#

饼图非常适合显示比例和百分比数据。

pie title 网站流量来源分析 "搜索引擎" : 45.6 "直接访问" : 30.1 "社交媒体" : 15.3 "推荐链接" : 6.4 "其他来源" : 2.6

总结#

Mermaid 是在 Markdown 文档中创建各种类型图表的强大工具。本文演示了如何使用流程图、时序图、甘特图、类图、状态图和饼图。这些图表可以帮助您更清晰地表达复杂的概念、流程和数据结构。

要使用 Mermaid，只需在代码块中指定 mermaid 语言，并使用简洁的文本语法描述图表。Mermaid 会自动将这些描述转换为美观的可视化图表。

尝试在您的下一篇技术博客文章或项目文档中使用 Mermaid 图表 - 它们将使您的内容更加专业且更易理解！

Markdown PlantUML 图表

Thu, 01 Jan 1970 00:00:00 GMT

Markdown 中 PlantUML 图表指南#

PlantUML 是一种使用纯文本描述图表的工具。你只需要写一段结构化语法，就可以生成时序图、类图、用例图、活动图等常见工程图。

它特别适合写在技术博客和项目文档里：

图表和正文一起版本管理，便于协作与审阅
修改图只需要改文本，适合频繁迭代
能和 Markdown 无缝结合，保持文档统一

在 Firefly 中，plantuml 代码块会在构建阶段编码并生成服务器 SVG 地址，页面端再根据亮暗主题自动切换图源，并支持缩放、拖拽和全屏交互。

如果你想快速上手，可以记住这个最小模板：

活动图示例#

状态图示例#

用例图示例#

组件图示例#

部署图示例#

ER 图示例#

时序图示例（登录与刷新令牌）#

C4 风格容器图示例#

Markdown 教程

Thu, 01 Jan 1970 00:00:00 GMT

这是一个展示如何编写 Markdown 文件的示例。本文档汇总了核心语法与常见扩展（GFM）。

块级元素
- 段落与换行
- 标题
- 引用
- 列表
- 代码块
- 分割线
- 表格
内联元素
- 链接
- 强调
- 行内代码
- 图片
- 删除线
杂项
- 自动链接
- 反斜杠转义
内联 HTML

块级元素#

段落与换行#

段落#

HTML 标签：<p>

使用一个或多个空行分隔段落。（仅包含空格或制表符的行也视为空行。）

代码：

1
This will be
2
inline.
3

4
This is second paragraph.

预览：

This will be inline.

This is second paragraph.

换行#

HTML 标签：<br />

在行末添加两个或更多空格来产生换行。

代码：

1
This will be not
2
inline.

预览：

This will be not
inline.

标题#

Markdown 支持两种标题样式：Setext 与 atx。

Setext#

HTML 标签：<h1>，<h2>

使用等号 (=) 表示 <h1>、使用短横线 (-) 表示 <h2>，数量不限，作为“下划线”。

代码：

1
This is an H1
2
=============
3
This is an H2
4
-------------

预览：

This is an H1#

This is an H2#

atx#

HTML 标签：<h1>，<h2>，<h3>，<h4>，<h5>，<h6>

在行首使用 1-6 个井号 (#)，对应 <h1> 至 <h6>。

代码：

1
# This is an H1
2
## This is an H2
3
###### This is an H6

预览：

This is an H1#

This is an H2#

This is an H6#

可选：你可以在行尾“闭合” atx 标题。末尾的井号数量不必与开头一致。

代码：

1
# This is an H1 #
2
## This is an H2 ##
3
### This is an H3 ######

预览：

This is an H1#

This is an H2#

This is an H3#

引用#

HTML 标签：<blockquote>

Markdown 使用邮件风格的 > 作为引用符号。若手动换行并在每行前加 >，显示效果最佳。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4
>
5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
> id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

Markdown 允许“偷懒”：在一个硬换行段落中，只在第一行前加 > 即可。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4

5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

引用可以嵌套（引用中的引用），通过增加 > 层级实现。

代码：

1
> This is the first level of quoting.
2
>
3
> > This is nested blockquote.
4
>
5
> Back to the first level.

预览：

This is the first level of quoting.
This is nested blockquote.
Back to the first level.

引用内可包含其他 Markdown 元素，包括标题、列表与代码块。

代码：

1
> ## This is a header.
2
>
3
> 1.   This is the first list item.
4
> 2.   This is the second list item.
5
>
6
> Here's some example code:
7
>
8
>     return shell_exec("echo $input | $markdown_script");

预览：

This is a header.#

This is the first list item.

This is the second list item.

Here’s some example code:
1
return shell_exec("echo $input | $markdown_script");

列表#

Markdown 支持有序（数字）与无序（圆点）列表。

无序列表#

HTML 标签：<ul>

无序列表可使用 星号 (*)、加号 (+) 或 短横线 (-)。

代码：

1
*   Red
2
*   Green
3
*   Blue

预览：

Red
Green
Blue

等价于：

代码：

1
+   Red
2
+   Green
3
+   Blue

或者：

代码：

1
-   Red
2
-   Green
3
-   Blue

有序列表#

HTML 标签：<ol>

有序列表使用数字加英文句点：

代码：

1
1.  Bird
2
2.  McHale
3
3.  Parish

预览：

Bird
McHale
Parish

注意：像下面这样可能会“意外触发”有序列表：

代码：

1
1986. What a great season.

预览：

What a great season.

你可以用反斜杠转义 (\) 句点：

代码：

1
1986\. What a great season.

预览：

1986. What a great season.

列表中的缩进内容#

列表项里的引用#

在列表项内放置引用，需要将 > 符号整体缩进：

代码：

1
*   A list item with a blockquote:
2

3
    > This is a blockquote
4
    > inside a list item.

预览：

A list item with a blockquote:

This is a blockquote inside a list item.

列表项里的代码块#

在列表项内放置代码块，需要缩进两层——8 个空格或两个 Tab：

代码：

1
*   A list item with a code block:
2

3
        <code goes here>

预览：

A list item with a code block:
```
1
<code goes here>
```

嵌套列表#

代码：

1
* A
2
  * A1
3
  * A2
4
* B
5
* C

预览：

A
- A1
- A2
B
C

代码块#

HTML 标签：<pre>

将代码块中的每行缩进至少4 个空格或1 个制表符。

代码：

1
This is a normal paragraph:
2

3
    This is a code block.

预览：

This is a normal paragraph:

1
This is a code block.

代码块会一直持续，直到遇到未缩进的行（或文末）。

在代码块内，与号 (&) 和尖括号 (< >) 会自动转为 HTML 实体。

代码：

1
    <div class="footer">
2
        &copy; 2004 Foo Corporation
3
    </div>

预览：

1
<div class="footer">
2
    &copy; 2004 Foo Corporation
3
</div>

下文的“围栏代码块”和“语法高亮”属于扩展语法，你也可以用它们来书写代码块。

围栏代码块#

使用成对的反引号围起来（如下所示），就不需要四空格缩进了。

代码：

1
Here's an example:
2

3
```
4
function test() {
5
  console.log("notice the blank line before this function?");
6
}
7
```

预览：

Here’s an example:

1
function test() {
2
  console.log("notice the blank line before this function?");
3
}

语法高亮#

在围栏代码块后添加可选的语言标识，即可启用语法高亮（参见支持语言列表）。

代码：

1
```ruby
2
require 'redcarpet'
3
markdown = Redcarpet.new("Hello World!")
4
puts markdown.to_html
5
```

预览：

1
require 'redcarpet'
2
markdown = Redcarpet.new("Hello World!")
3
puts markdown.to_html

分割线（水平线）#

HTML 标签：<hr /> 一行中放置三个或以上的短横线 (-)、星号 (*) 或下划线 (_)。符号之间允许有空格。

代码：

1
* * *
2
***
3
*****
4
- - -
5
---------------------------------------
6
___

预览：

表格#

HTML 标签：<table>

这是扩展语法。

用竖线 (|) 分隔列，用短横线 (-) 分隔表头，使用冒号 (:) 指定对齐方式。

两侧的竖线 (|) 与对齐可选。用于表头分隔时，每列至少需要 3 个短横线。

代码：

1
| Left | Center | Right |
2
|:-----|:------:|------:|
3
|aaa   |bbb     |ccc    |
4
|ddd   |eee     |fff    |
5

6
 A | B
7
---|---
8
123|456
9

10

11
A |B
12
--|--
13
12|45

预览：

Left	Center	Right
aaa	bbb	ccc
ddd	eee	fff

A	B
123	456

A	B
12	45

内联元素#

链接#

HTML 标签：<a>

Markdown 支持两种链接样式：行内链接与引用式链接。

行内链接#

行内链接格式：[文本](URL "标题")

标题可选。

代码：

1
This is [an example](http://example.com/ "Title") inline link.
2

3
[This link](http://example.net/) has no title attribute.

预览：

This is an example inline link.

This link has no title attribute.

如果引用同一站点的本地资源，可以使用相对路径：

代码：

1
See my [About](/about/) page for details.

预览：

See my About page for details.

引用式链接#

可以预定义链接引用。定义格式：[id]: URL "标题"

标题同样可选。引用时使用：[文本][id]

代码：

1
[id]: http://example.com/  "Optional Title Here"
2
This is [an example][id] reference-style link.

预览：

This is an example reference-style link.

说明：

方括号中包含链接标识（不区分大小写，可在左侧缩进最多三格空格）；
随后是冒号；
再跟一个或多个空格（或 tab）；
然后是链接 URL；
URL 可选地用尖括号包裹；
可选地跟随标题属性，用引号或圆括号包裹。

以下三种定义等价：

代码：

1
[foo]: http://example.com/  "Optional Title Here"
2
[foo]: http://example.com/  'Optional Title Here'
3
[foo]: http://example.com/  (Optional Title Here)
4
[foo]: <http://example.com/>  "Optional Title Here"

如果使用空的方括号，则链接文本本身会作为名称。

代码：

1
[Google]: http://google.com/
2
[Google][]

预览：

Google

强调#

HTML 标签：<em>，<strong>

Markdown 使用 星号 (*) 或 下划线 (_) 表示强调。一个分隔符对应 <em>；两个分隔符对应 <strong>。

代码：

1
*single asterisks*
2

3
_single underscores_
4

5
**double asterisks**
6

7
__double underscores__

预览：

single asterisks

single underscores

double asterisks

double underscores

但如果两侧有空格，则会被视作普通字符而非强调语法。

你可以使用反斜杠进行转义：

代码：

1
\*this text is surrounded by literal asterisks\*

预览：

*this text is surrounded by literal asterisks*

行内代码#

HTML 标签：<code>

用反引号 (`) 包裹。

代码：

1
Use the `printf()` function.

预览：

Use the printf() function.

若行内代码中需要包含反引号字符，可使用多重反引号作为定界符：

代码：

1
``There is a literal backtick (`) here.``

预览：

There is a literal backtick (`) here.

行内代码两侧的定界符允许包含空格（开头一个、结尾一个），方便在代码起始或结尾放置反引号字符：

代码：

1
A single backtick in a code span: `` ` ``
2

3
A backtick-delimited string in a code span: `` `foo` ``

预览：

A single backtick in a code span: `

A backtick-delimited string in a code span: `foo`

图片#

HTML 标签：<img />

Markdown 的图片语法与链接类似，支持行内与引用两种方式。

行内图片#

行内图片语法：![替代文本](URL "标题")

标题可选。

代码：

1
![Alt text](/path/to/img.jpg)
2

3
![Alt text](/path/to/img.jpg "Optional title")

预览：

Alt text

说明：

一个感叹号 !；
后接方括号，放置图片的替代文本；
再接圆括号，内含图片 URL/路径，及可选的标题（引号包裹）。

引用式图片#

引用式图片语法：![替代文本][id]

代码：

1
[img id]: https://s2.loli.net/2024/08/20/5fszgXeOxmL3Wdv.webp  "Optional title attribute"
2
![Alt text][img id]

预览：

Alt text

删除线#

HTML 标签：<del>

这是扩展语法。

GFM 增加了删除线语法。

代码：

1
~~Mistaken text.~~

预览：

Mistaken text.

杂项#

自动链接#

Markdown 支持一种便捷写法来创建“自动链接”（URL 与邮箱地址）：只需用尖括号将其包住即可。

代码：

1
<http://example.com/>
2

3
<address@example.com>

预览：

http://example.com/

address@example.com

GFM 会自动识别标准 URL 并转换为链接。

代码：

1
https://github.com/emn178/markdown

预览：

https://github.com/emn178/markdown

反斜杠转义#

Markdown 允许使用反斜杠来转义那些本用于 Markdown 语法的特殊字符，使其按字面显示。

代码：

1
\*literal asterisks\*

预览：

*literal asterisks*

以下字符可通过反斜杠转义以按字面量输出：

Code:

1
\   backslash
2
`   backtick
3
*   asterisk
4
_   underscore
5
{}  curly braces
6
[]  square brackets
7
()  parentheses
8
#   hash mark
9
+   plus sign
10
-   minus sign (hyphen)
11
.   dot
12
!   exclamation mark

内联 HTML#

对于 Markdown 语法未覆盖的标记，直接使用原生 HTML 即可。无需特别声明从 Markdown 切换到 HTML，直接写标签就行。

代码：

1
This is a regular paragraph.
2

3
<table>
4
    <tr>
5
        <td>Foo</td>
6
    </tr>
7
</table>
8

9
This is another regular paragraph.

预览：

This is a regular paragraph.

Foo

This is another regular paragraph.

请注意：在块级 HTML 标签内不会处理 Markdown 语法。

与块级标签不同，在行内级标签内会处理 Markdown 语法。

代码：

1
<span>**Work**</span>
2

3
<div>
4
    **No Work**
5
</div>

预览：

Work

**No Work**

***

在文章中嵌入视频

Thu, 01 Jan 1970 00:00:00 GMT

只需从 YouTube 或其他平台复制嵌入代码，然后将其粘贴到 markdown 文件中。

1
---
2
title: 在文章中嵌入视频
3
published: 2023-10-19
4
// ...
5
---
6

7
<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>