这几天刷抖音，看到了个新的玩意儿。拉链表，所以打算学习一下。

二、什么是拉链表及其实现

1. 一个带历史数据的信息表。
2. 表里要有两个字段，startTime、endTime、status(可选)。
3. startTime：记录数据的生成时间，这里完全可以在数据库设置上默认值，插值时间就是startTime。
4. endTime：记录数据的失效时间，默认应该是一个无限大的时间，例如9999-12-31。当数据失效，作为历史记录时，应该改为当前时间。
5. status：记录该行数据是否为历史数据，但是我觉得这个字段可有可无，用endTime的9999-12-31值作为判断也可以。

三、应用场景

1. 用户信息变更：城市、等级、手机号
2. 商品价格变更：不同时期价格
3. 员工组织关系变更：部门、岗位
4. 风控/审计：需要追踪某时点数据
5. 数仓维度表（SCD2）：最常见

大多数情况下，这个思想应用在数仓和数据分析的场景，一般业务的情况下使用较少。

1
2
3
4
5
6
7
8
9
10
11

-- 查询当前生效数据
select * from A where endTime = '9999-12-31'

-- 查询历史数据
select * from A where startTime >= '#{开始时间}' and endTime <= '#{结束时间}'

-- 修改操作
-- 先关闭数据
UPDATE A SET endTime = '2026-6-6' WHERE user_id = 1001 AND endTime = '9999-12-31';
-- 插入新数据
INSERT INTO A (……) VALUES ( ……, DATE '2024-03-01', DATE '9999-12-31');

四、扩展

Slowly Changing Dimensions即缓慢变化维（SCD）

维度表中的属性会随着时间慢慢变化，但这种变化不是高频实时的，需要考虑是否保留历史。

SCD解决了当维度属性变化时，如何管理旧值、新值和历史版本。

SCD的三种类型：

• Type 1：直接覆盖，新值直接覆盖旧值，不保留历史。
• Type 2：新增版本，不覆盖旧记录，而是保留旧版本，再插入一条新版本。【拉链表属于这个类型】
• Type 3：保留有限历史，保留当前值和上一个值，但不保留完整历史。

缓慢变化维，就是“维度数据会变，而我们要设计一种方式处理这种变化”。

拉链表不用代理键，最大的问题不是“不能做”，而是“很难做对、很难长期稳定地做对”。

现在是北京时间2026年2月14日，凌晨0点0分，很久没更新博客了，倒不是没有什么新的东西去更新。是真的太忙，忙着换工作，忙着改BUG。

25年年底，我下定决心，回济南，回到老东家，再续我的前缘……

世界很大，我要去看看！

2025年，我去了深圳、香港、嘉兴、杭州、舟山。

去深圳和香港，是早就计划好的，是我每年旅游计划的一部分。说实话，真的没感觉出香港到底好在了哪里，感觉跟大陆的一线城市，基本上是一样，不同点就是消费高，金融环境比较宽松。

嘉兴、杭州、舟山，是计划外，因为5月跳槽到了苏州。在苏州的时候，顺便跟同事去这些地方转了转，待的时间都不是很久，所以也没啥可说的，附几张照片把。

我党一大的会议进行处，嘉兴南湖的一条游船。很有纪念意义！共产主义万岁！

杭州西湖附近的西泠印社，我对篆刻印章特别喜欢，虽然自己不会篆刻，但是在博物馆，必看的东西就是各种印章哈哈哈哈哈。

突然想起一句话，写这吧：使我有洛阳二顷田，安能佩六国相印。

这也是西湖附近的一个塔，好像是雷峰塔？记不清了，只拍了个照片，没上去，记得当时需要门票来着。

南湖革命纪念馆，我党历史展览，学到了很多。大家有机会也可以去参观参观。

海盐县，当时想去海边玩，同事开车带着一块去了海盐县。临走之前，发现这个地方很不错，就拍了张照片留念。

运动

今年找到了自己喜欢的运动，羽毛球！

你打吧，一打一个不吱声。嘎嘎累，嘎嘎爽。体重降没降不知道，累是真的累。

在苏州跟同事，经常下班去打一小时的球，买了入门级球拍，的幸的均衡之刃（回济南的时候，可能落在了火车上，自己坐火车去兰州了哈哈哈哈）。

回济南又买了一把均衡之刃，真是很好用。第三把均衡之刃了。

千幸万幸不如的幸，跟我的杀球去说吧。🐶

回济南打的第一场球，认识了一个老哥，实力不凡（对我来说）。三个人，一口气打了俩小时，到了第二天，依旧没缓过来，累的半死。

投资

今年没怎么操作股票和基金，贵金属也没买。主要是换了两次工作，导致自己很忙，没时间去搞这个，也就放下了一段时间。

技术进步

技术进步，有，但是不多。

主要是在苏州，第一次接触到了微服务架构，对这东西彻底祛魅了。小公司、小体量软件，纯粹自找难受。

对于互联网巨头来说，确实可以提高开发速度，解耦等等的好处。但是对于一般体量的公司或者软件，纯粹是脱了裤子放屁，不管是维护还是开发，都搞得人很难受。

在苏州，也接触了项目管理，这东西倒不是很难搞，纯粹的操心哈哈哈哈哈。跟进展、协调部门资源、跟客户沟通等等，都得操心，得举一反三，多思考才行。

回到济南，依旧是微服务项目，但是软件体量大，明显能感觉出来，对开发速度等方面，有不小的提升。

再就是AI方面，多少的了解了一些机器学习的东西，接触到了一个很神奇的技术，三维重建。就是对一个物体拍几个不同方向的照片（需要标定板），通过机器学习的模型，把他重建成3d模型。

大语言模型方面，自己搞了个文档提取的Demo，用的Qwen系列的模型，向量转换、基座模型都是Qwen3。其实我一直不看的小参数量的大语言模型，但是这次用了8B的超乎我的想象，只要是提示词做好了，指哪打哪！

人生的坎

2025年，这一年就是在折腾，不停的折腾。换工作、分手、又回老东家。

一开始，满怀希望的去了苏州，但实际到了以后，发现。

一个组6个人（包含我），10W个心眼子，各怀鬼胎，难搞的一批。大部分时间不是在做技术，而是扯皮，处理背后捅的刀子。人心隔肚皮，真的是吃一堑长一智，也算是在苏州这半年没白待。再就是真的很闲，我才20多岁啊，正式闯的年纪，再不跑，就被时代的车轮碾压了。

到了苏州，因为长时间异地，又不能月月去找对象，所以被分手了，也算是和平分手。大路朝边，各走一边。每个人都有自己的路要走，祝福！我也有我的新生活要开始。（各位读者，感觉给我推姐姐，我要跟姐姐谈恋爱。哈哈哈哈哈哈哈哈哈。）

后面，跟之前的同事交流，找了老东家的领导，确定要回济南，然后再续前缘哈哈哈哈。但是跟苏州这边，提离职，真的给我搞懵了。先是苏州的领导，对我一顿贬低，再就是想卡我离职，说是交接不好，就要让董事长的影响力，让我无法入职下家哈哈哈哈哈哈。开玩笑，哥们最不怕威胁，大不了鱼死网破，都别好🐶。最后交接也算顺利，顺利离职，开启我的新职业生涯哈哈哈哈哈哈。

总的来说，都是小砍，轻轻松松迈过去哈哈哈哈。

明年展望

今年，技术要继续提升，务必把Vue拾起来，全方位发展，把全干工程师的门槛迈过去。再就是公司的低代码框架，尽快把知识库建立起来，为后续开发打下良好的基础。

投资也要有进展！缠论要看，债基要学！钱这个东西，你不理他，他不理你。做好投资，也是资产自己产仔的一个好路线。

婚恋方面，先缓缓吧，一切随缘（我再提一下，我想跟姐姐谈恋爱哈哈哈哈）

运动也不能停，羽毛球向天王丹哥看齐，多学学练，菜就多练哈哈哈哈哈。

最后

最后，放一句，教员的金句，镇镇文章！

“在危险环境中表示绝望的人，在黑暗环境中看不见光明的人，只是懦夫和机会主义者。”

放一张作者的帅照，哈哈哈哈哈哈哈哈。

2026年2月14日，出租房记。

1. 延迟双删：缓存与数据库一致性问题的公认解决方案，也是面试高频考点，在各类技术八股文中均有重点提及。
2. 租约机制：多见于分布式场景的大厂方案，更适配高并发、大规模架构。对于流量较小的内部 ERP 等系统，通常无需缓存设计，因此极少采用。
3. 版本号对比机制：同样是大厂常用方案，核心通过数据自带的版本号标识，直观判断数据新旧，进而保障数据一致性。

二、延迟双删

2.1 什么是延迟双删

通过两次缓存删除操作，最大限度降低缓存与数据库的数据不一致风险

1. 首次删除：更新数据库前，先删除缓存数据。

   作用：避免更新时，请求命中缓存，读取到旧数据

2. 数据库更新：更新数据库中的数据。

3. 延迟后第二次删除：等待几秒(具体时间，根据业务需要调整)后，将缓存中的数据再次删除。

   作用：解决首次删除后，数据库更新完成前的并发问题。即有并发请求，旧数据被重新写入缓存的问题

2.2 优缺点

优点：

1. 实现成本低。
2. 兼容性强，支持常见的缓存、数据库。
3. 覆盖并发窗口，降低缓存与数据库的不一致性概率。

缺点：

1. 可能存在缓存击穿的问题。
2. 延迟删除时间难以把控。
3. 依赖异步任务的可靠性。（一般情况下，延迟删除通过定时任务、消息队列实现，如发生故障，难以保证第二次删除）
4. 无法满足强一致性的要求。

2.3 适用

1. 中小型规模
2. 并发量较小，数据库能承受短时的缓存击穿。
3. 无复杂的分布式架构

三、租约机制

3.1 什么是租约机制

简单的说，就是多个请求查询缓存，只有第一个请求可以获取到令牌后写入缓存。

1. 缓存中不存在查询的数据时，多个并发请求中，只给第一个颁发“令牌”。
2. 拿到令牌后，才允许其查询数据库，写入缓存。其他请求，要么等待，要么放弃。

3.2 有缺点

优点：

1. 防止并发出现混乱，不会出现旧数据覆盖新数据的问题。
2. 轻量化，依靠Redis Lua脚本实现。
3. 令牌过期时间可灵活设置。

缺点：

1. 实现比延迟双删复杂，需要用Lua脚本实现令牌的生成、验证、删除，令牌过期、请求排队也需要考虑。
2. 存在等待期，未获取到令牌的请求，要么等现有令牌过期，要么放弃，极端情况下部分用户可能需要等待。
3. 缓存服务依赖度高，令牌的实现在缓存中，缓存一旦宕机，就可能出现租约机制失效的问题。

3.3 适用

1. 大流量分布式系统
2. 并发写多的业务
3. 可接受等待的业务

四、版本号对比机制

4.1 什么是版本号对比机制

给每条数据，添加一个时间戳字段或版本号字段。

写缓存是，先判断版本号的新旧，新版本存入，旧版本丢弃。

4.2 优缺点

优点：

1. 性能好，直接对比版本号，无需排队等待。
2. 数据一致性，根据版本号，可防止旧数据覆盖新数据的问题。
3. 实现较简单，无需考虑令牌的生成、过期等逻辑。
4. 无锁设计，不会出现锁竞争、死锁等问题。

缺点：

1. 版本号生成逻辑出现问题，会导致数据更新异常。
2. 无法解决缓存击穿问题。
3. 版本号存储占用空间。

4.3 适用

1. 超大规模的高并发系统。
2. 读多写少、数据更新频繁的业务。
3. 需要“强一致性”优先级高于“防止缓存击穿”

五、总结

作者对作品享有人身权和财产权

人身权：发表权、署名权、修改权、保护作品完整权

财产权：使用权、获得报酬权

知识产权具有法定的保护期：

发明专利20年、新型实用专利和外观专利10年。

作品发表权：作者终生及其死后50年。

商标：有效期10年，可以无限续。

二、专利地域性

外国人在我国领域外使用中国专利局授权的发明专利，不侵犯我国专利权。

参加国际公约的国家和我国保护相关国家的专利。

三、计算机软件著作权

著作权法（中华人民共和国著作权法）、计算机软件保护条例

计算机软件著作权的客体：计算机程序、有关文档。

计算机程序包括：源程序、目标程序

计算机文档包括：程序设计说明书、流程图、用户手册等。

著作权法规定，软件作品享有两类权益：人身权（精神权利）、财产权（经济权利）。计算机软件保护条例规定，著作权人享受发表权、开发者身份权（署名权，不受开发者的消失而丧失，无时间限制）。

财产权包括：使用权、复制权、修改权、发行权、翻译权（从一种编程语言翻译成另一种编程语言）、注释权、信息网络传播权、出租权、使用许可权、获得报酬权、转让权。

**软件著作权的保护期：自开发完成之日起50年。**保护期满后除开发者身份权以外，其他权利终止，软件进入公有领域。

计算机软件著作权人，单位终止或公民死亡，无合法继承人时，除开发者身份权外，其他权利进入公有领域。

四、职务作品

公民在单位任职期间，为执行本单位工作任务开发的计算机软件作品。

公民单位任职期间所开发的软件，如果是执行本质工作的结果，即针对本质工作中明确制定的开发名表所开发的，或者是从事本质工作活动所遇见的结果或自然的结果，则软件的著作权归属该单位。

如果雇员主要使用了单位的设备，按照保护条例，不能属于雇员个人享有。

归属原则（计算机软件保护条例）：符合以下三个，才算非职务作品

• 所开发的软件作品不是执行起本职工作的结果。
• 开发的软件作品与开发者单位中从事的工作内容无直接联系。
• 开发的软件作品未使用单位的物质技术条件。

五、委托开发

接受他人委托开发的软件，其著作权的归属由委托者和受委托者签订书面合同约定，无书面合同或者合同未明确约定的，其著作权由受托人享有。

六、商业秘密权

不为公众所知悉的、能为权利人带来经济利益、具有实用性并经权利人采取保密措施的技术信息、经营信息

七、专利申请

一份专利申请文件只能就一项发明创造提出专利申请，即“一份申请一项发明”

两个或两个以上的人分别就同样的发明创造申请专利的，专利权授给最先申请人。

八、商标权

商标保护期10年，可以无限续期。

在期限满6个月内，提出续期申请，每次续期10年，续期次数不限。

九、商标注册

同时申请，先调解两个申请人谁让步，不让步，抽签决定。

十、其他

游戏规则和方法、计算机算法，不能申请专利。

合理使用指可以不经著作权人许可，不需支付报酬，使用其作品。

为说明某一问题，在学术论文中需要引用某些资料必须是已发表的作品，但只能限于介绍、评论作品，只要不构成自己作品的主要部分，可适当引用资料，而不必征得原作者的同意，不需要向他支付报酬。

国务院颁布的《计算机软件保护条例》，不适用或不受著作权法保护的是(14)。(2013 年下半年)

我国法律法规的规定必须使用注册商标的是烟草类商品，

近期在开发过程中发现，设备相关数据的某个字段偶尔出现 null 值，并非每次必现。该问题主要发生在任务刚执行完成，设备立即调用接口获取数据时。初步判断与数据写入和读取的时序有关，存在一定的竞争条件。

二、排查

2.1 初步怀疑异常回滚

最初怀疑是任务执行过程中发生异常并触发事务回滚，导致字段未能正确写入而为 null。但通过查阅近期 ELK 日志，未发现相关异常记录，排除了因异常回滚导致数据缺失的可能性。

2.2 字段填充

随后将排查重点转向该字段的填充方法。考虑到数据写入时机问题，怀疑是否存在事务传播机制不当，导致部分数据在事务未完成前就被提前写入数据库，后续流程继续执行，从而引发字段为null的异常。

2.3 检查事务注解与调用方式

在相关方法中发现其使用了 @Transactional(rollbackFor = Exception.class) 注解，该注解仅用于异常时回滚，并未强制开启新事务（即 propagation = REQUIRES_NEW），因此不会导致数据提前提交。

进一步检查发现，该方法内部存在 this. 方式的自调用，可能因为 Spring AOP 代理机制导致事务失效？尝试改为通过 service Bean 引用进行外部调用后，问题依然存在。

2.4 XXL-JOB 反射调用与事务管理

这里就猛的想起，XXL-JOB好像是通过反射进行定时调用的。立马Google确认， 确定是通过反射进行调用的。那么就基本确定，很有可能是XXL-JOB执行器反射，导致方法不受Springboot的事务管理。

上图原文链接：https://www.cnblogs.com/yejg1212/p/14794098.html

三、解决：

在定时任务类和方法上加上@Transactional注解，经过多轮测试，null值不再出现。

四、问题点：

4.1 为啥事务失效？

@Transactional 是通过 Spring AOP 来实现的。只有方法是通过 Spring 容器生成的代理对象 调用时，事务切面才会生效。如果方法不是通过代理调用（比如直接 new 出来的对象，或者直接在同一个类里this自调用），事务就不会生效。

XXL-JOB 调度任务时，是通过 反射调用你标注的方法。 所以说，它并不是通过 Spring AOP 代理对象去调用的，而是直接调用你 @Component 类里的那个方法。

4.2 为啥加了 @Transactional 就生效了？

当给方法加上 @Transactional，Spring 在启动时会发现这个方法需要事务切面，会为整个类生成一个代理对象。

XXL-JOB 在执行任务时，仍然是通过 Spring 容器中的 bean 去拿这个类，但此时拿到的已经是代理对象。当 XXL-JOB 通过反射调用这个代理对象的方法时，Spring AOP 的事务切面就会拦截到，事务开始生效。

4.3 正确的解决方式

因为项目上存在重构分支和开发分支，后期打算将重构分支切为生产，所以目前临时添加@Transactional解决掉问题。

实际上， 执行器方法应该只做参数校验、任务调度、开始结束日志等。实际的业务逻辑，应当放入service中，使用@Transactional管理事务。

1.1 基本概念

静态查找表：顺序查找、折半（二分）查找、分块查找

动态查找表：二叉排序树、平衡二叉树、B树、哈希表

静态查找表：

• 查找某个特定的数据元素是否在查找表中。
• 检索某个特定的数据元素的各个属性。

动态查找表：

• 在查找表中插入一个数据元素
• 在查找表中删除一个数据元素

1.2 顺序查找

适用于顺序存储和链式存储。

平均查找长度：$\frac{n+1}{2}$

1.3 折半查找

折半查找的必要条件：顺序存储，有序。

最坏的比较次数：$\lfloor \log_2 n \rfloor + 1$

平均查找长度：$\log_2(n+1) - 1$

折半查找过程与关键字比较的次数即为被查找结点在树中的层数。

我自己在这提一下，如果不考虑查找的元素不存在的问题，斐波那契查找更快（基于Java8开发过程中发现的）。

折半查找的比对顺序有以下几种可能：

1. 大大大大大……（越来越大）
2. 小小小小小……（越大越小）
3. 大小大小大……（大小间隔）
4. 小大小大小……（小大间隔）

二、哈希表

2.1 定义

核心思想是：把查找关键字的值，通过一个函数计算，直接得到它应该存放在哪里。

具有相同哈希数值的关键字，对于该哈西函数来说称为同义词。

2.2 哈希函数构造与处理冲突

哈希函数构造方法：直接定址法、数字分析法、平方取中法、折叠法、随机数法、除留余数法

H(Key) = Key % m = 地址

m取接近n(元素个数)但是大于n的质数。

开放定址法：

1. 线性探测法：如果该位置已被占用（无论是因为另一个键值对还是之前因冲突而移动至此的键值对），则按顺序检查下一个位置（即 (h(key) + 1) % table_size`）
2. 二次探测再散列：如果该位置已被占用，则按照二次函数的规律，探测 (h(key) + 1²) % m, (h(key) + 2²) % m, (h(key) + 3²) % m`, …，直到找到一个空位置为止。
3. 随机探测再散列：如果位置被占用，则使用一个伪随机数生成器（PRNG）来决定下一个探测的位置。这个生成器的种子通常与当前的 key 相关，以确保对于同一个 key，探测序列是确定且可重现的。

2.3 处理冲突拓展和装填因子

链地址法：

哈希表的填装因子定义为：α = $\frac{表中装入的记录数}{哈希表的长度}$

α越小，发生冲突的可能性越小。

三、排序

3.1 直接插入排序

🌰：你手里有一副乱序的牌，现在你要把它们从小到大排好。你从左到右一张一张看：

1. 第一张牌，不用排，自己就是“有序”的。
2. 拿第二张牌，跟第一张比一下，小就插到前面，大就放后面。现在前两张是有序的。
3. 拿第三张牌，从右往左一个个比，把它插到正确的位置，让前三张有序。
4. 继续这样，每拿一张新牌，都把它插入到前面已排序部分的正确位置。

3.2 希尔排序

🌰：整理书架上的书（按高度排序）：

1. 先每隔几本排一次（大间隔）比如每隔 4 本书为一组
2. 缩小间隔，比如每隔 2 本一组
3. 最后，间隔为1，做一次普通插入排序

3.3 计数排序

假设你有一堆小朋友的年龄，范围是 0 到 5 岁，想把他们按年龄从小到大排序。

1. 数一数每个年龄有多少人，拿一个表格（数组），从 0 开始，数每个年龄出现的次数：
2. 按顺序把年龄写出来。从年龄 0 开始，写 1 个 0，写 2 个 1，写 1 个 2，写 2 个 3……以此类推。

3.4 简单选择排序

每次从剩下的数里，挑出最小的那个，放到前面。

1. 在所有数 [5, 2, 4, 1, 3] 中找最小的
2. 在剩下的 [2, 4, 5, 3]` 中找最小的
3. 在剩下的 [4, 5, 3]` 中找最小的
4. 在剩下的 [5, 4]` 中找最小的

3.5 堆排序

1. 建立大顶堆
2. 将大的权值向后排（重复此步骤）

3.6 冒泡排序

一排站在一起的高矮不一的学生（比如5个人），把他们按照从矮到高的顺序重新排列。

1. 从最左边开始：让第1个和第2个学生比身高。 如果左边（第1个）比右边（第2个）高，就让他们交换位置（让高的去右边）。
2. 向右移动：接着让第2个和第3个学生比身高，同样，如果左边的比右边高就交换。
3. 一直比到最后：继续这个过程，一直比到最后一对（第4个和第5个学生），最高的那个学生一定会被排到最右边
4. 重复这个过程：现在，最高的学生已经就位了。我们忽略最后一个位置（因为他已经排好了）。

3.7 快速排序

想象你有一堆杂乱无章的书，你需要把它们按照高度从矮到高排列。

1. 挑一本“标杆”书：从书堆里随便拿起一本书（比如正中间那本），这本书的高度就是我们的“标杆”。

2. 分区操作（核心！）：现在，你开始整理剩下的书：

   • 创建一个 “矮个子区”（左边），创建一个 “高个子区”（右边）

   • 然后，你一本一本地拿起剩下的书，和手里的“标杆”书比身高：如果比“标杆”矮，就扔到 “矮个子区”。如果比“标杆”高，就扔到 “高个子区”。

3. 递归排序：现在你有了三堆书：

   • 左边的一堆 “矮个子”（它们都比标杆矮，但内部顺序是乱的）
   • 中间的一本“标杆”（它现在已经在了最终正确的位置上！）
   • 右边的一堆 “高个子”（它们都比标杆高，但内部顺序也是乱的）右边的一堆 “高个子”（它们都比标杆高，但内部顺序也是乱的）

4. 对左右两堆重复：对左边的“矮个子区”和右边的“高个子区”分别重复步骤1-3（再为它们选新的“标杆”，再分区）。

5. 合并：当每一堆小书堆都只剩下0本或1本书时（0或1本书本身就有序，不需要再排），把所有排好序的小书堆从左到右（矮区 + 标杆 + 高区）合并起来，整个序列就有序了。

3.8 归并排序

有两叠已经按从小到大排好序的扑克牌（比如一叠是[3, 8, Q]，另一叠是[5, 9, K]），合并成一叠新的有序牌。

1. 总是比较最上面的牌：你看两叠牌最上面的一张，左边是3，右边是5。
2. 拿出小的那张：3比5小，所以你拿出左边的3，放到新牌堆里。
3. 继续比较：现在左边最上面是8，右边还是5。5比8小，所以你拿出右边的5，放到新牌堆（现在是[3, 5]）。
4. 重复直到完：继续这个过程（比较8和9，拿8；比较Q和9，拿9；最后把Q和K依次拿出）。
5. 最终：你得到了一个全新的、有序的牌堆：[3, 5, 8, 9, Q, K]。

3.9 排序算法总结

• 带“递归/分治”的：快排、归并。
• 带“插入”的：直接插入（基础）、希尔（改进版）。
• 名字即方法：选择、冒泡。
• 用数据结构的：堆排序。

算法时间复杂度：以算法中基本操作重复执行的次数（简称频度）作为算法的时间度量。

加法规则：多项相加，保留最高阶项，并将系数化为1

乘法法则：多项相乘都保留，系数化为1

加法乘法混合规则：先小括号 再乘法规则 最后加法规则

二、时间复杂度

例子：

• O(1)：
• O(log₂n)：
• O(n)：
• O(nlog₂n)：
• O(n²)：
• O(n³)：

三、空间复杂度

T(n) = n² = O(n²)

四、渐进符号

1. 渐进上界
   • 符号: O
   • 含义: f(n) 的增长速度至多与 g(n) 一样快（或更慢）。它给出了函数 f(n) 的一个上界。常用于描述算法的最坏情况时间复杂度。
   • 类比: f(n) ≤ g(n) (在渐进意义上)。
2. 渐进下界
   • 符号: Ω
   • 含义: f(n) 的增长速度至少与 g(n) 一样快（或更快）。它给出了函数 f(n) 的一个下界。常用于描述算法的最好情况时间复杂度。
   • 类比: f(n) ≥ g(n) (在渐进意义上)。
3. **渐进紧致界 **
   • 符号: Θ
   • 含义: f(n) 的增长速度精确地与 g(n) 一样快。它同时是 f(n) 的上界和下界，因此是一个紧致界。当算法的最好情况和最坏情况复杂度相同时，常用 Θ 来描述其平均情况或精确的时间复杂度。
   • 类比: f(n) = g(n) (在渐进意义上)。

五、递归式时间、空间复杂度

时间复杂度 = 递归的次数 x 每次的时间复杂度 (每次递归时间复杂度不变的情况下)

空间复杂度 = ？？？？

这一章讲的不是很清晰，学的也不是很透彻，待定吧

六、递归式主方法

T(n) = aT(n/b) + f(n)

例子：

七、线性结构与线性表定义

特点：数据元素之间呈现一种线性关系，即元素“一个接一个排列”。

线性表：顺序存储、链式存储。

非空线性表特点：

• 存在唯一的一个称为“第一个”的元素。
• 存在唯一的一个称为“最后一个”的元素。
• 除第一个元素外，序列中的每个元素均只有一个直接前驱
• 除最后一个元素外，序列中的每个元素均只有一个直接后继。

7.1 线性表的顺序存储

顺序存储是指，一组地址连续的存储单元依次存储线性表中的数据元素。

优点：可以随机存取表中元素。

缺点：插入、删除都需要移动元素。

插入一个新元素需要移动的元素个数期望值为：n/2

删除元素时需要移动的元素个数期望值为：(n-1)/2

7.2 顺序表的插入、删除、查找时间复杂度

7.3 顺序表的链式存储

数据域用于存储元素的值，指针域用于存储元素的直接前驱或直接后继的位置信息。

各个数据元素的节点的地址并不要求是连续，因此存储数据元素的同时，必须存储元素的逻辑关系。

若元素的结点只有一个指针域，称为线性链表（单链表）

7.4 单链表的插入、删除、查找时间复杂度

7.5 循环单链表、双链表

循环单链表：尾结点的指针域指向头结点。

双链表：两个指针域，分别指向前驱和后继。

八、栈相关

8.1 栈的顺序存储

先进后出

基本运算：

1. 初始化栈：创建一个空栈
2. 判栈空：当栈为空时返回真，否则返回假
3. 入栈：将元素x加入栈顶，并更新栈顶指针
4. 出栈：将元素从栈中删除，并更新栈顶指针。
5. 读站定元素：返回栈顶元素的值，但不修改栈顶指针

8.2 栈的链式存储

九、队列相关

9.1 队列的顺序存储与循环队列

先进先出。允许插入元素的一端为队尾，允许删除元素的一段为队头。

由于队列的元素插入和删除分别再两端进行，因此设置队头指针和队尾指针。

运算：

1. 初始化队列：创建一个空的队列。
2. 判队空：当队列为空时返回真，否则返回假。
3. 入队：将元素加入到队列的队尾，并更新队尾指针。
4. 出队：将队头元素从队列中删除，并更新队头指针。
5. 读队头元素：返回队头元素的值，但不修改队头指针。

循环队列

9.2 队列的链式存储与双端队列

队列的链式存储

十、串相关

特殊的线性表，元素为字符。

基本概念：

1. 空串：长度为零称为空串，空串不包含任何字符。
2. 空格串：由一个或多个空格组成的串。空格在计算长度是也要将其计算在内。
3. 子串：串中任意长度的连续字符构成的序列称为子串。空串是任意串的子串。
4. 串相等：两个串长度相等，且对应序号的字符相同。
5. 串比较：比较两个串大小时，以字符的ASCII码作为依据。

10.1 串的模式匹配与朴素模式匹配

最好：O(m)

最坏：O(nm)

平均：O(n+m)

10.2 手算next数组值

串的前缀：包含第一个字符并且不包含最后一个字符的子串

串的后缀：包含最后一个字符并且不包含第一个字符的子串

第i个字符的next值 = 从1 ~ i-1 串中最长相等前后缀长度 + 1

特殊情况：next[1] = 0

**手算步骤（以模式串 **ABABC 为例）

模式串：P = "ABABC"

我们逐位计算 next[i]：

1. i = 0: 子串A

• 没有真前后缀 → next[0] = 0

2. i = 1: 子串AB

• 前缀：A
• 后缀："B"
• 无相等前后缀 → next[1] = 0

3. i = 2: 子串 ABA

• 前缀："A", "AB"
• 后缀："A", "BA"
• 相等的有："A"（长度1）
• 最长相等真前后缀长度 = 1 → next[2] = 1

4. i = 3: 子串 ABAB

• 前缀："A", "AB", "ABA"
• 后缀："B", "AB", "BAB"
• 相等的有："AB"（长度2）
• 最长 = 2 → next[3] = 2

5. i = 4: 子串 ABABC

• 前缀："A", "AB", "ABA", "ABAB"
• 后缀："C", "BC", "ABC", "BABC"
• 没有相等的前后缀 → next[4] = 0

✅ 最终next数组：

👉 所以：next = [0, 0, 1, 2, 0]

✅总结：手算next数组口诀

逐位看子串，拆分前和后，

找最长相等，记长度为next。

单字符为0，无匹配也为0，

前后缀不重叠，才是“真”前后。

十一、数组相关

11.1 一维数组

L：元素大小

LOC：数组首地址

内存中：a[0] a[1] a[2] a[3] a[4] a[5]

某个元素在内存中实际地址的公式：

下标从0开始： a_i = LOC + i x L

下标从1开始： a_i = LOC + (i-1) x L

11.2 二维数组

N：行 M：列

L：元素大小

LOC：数组首地址

a[0][0] a[0][1] a[0][2]

a[1][0] a[1][1] a[1][2]

按行优先：a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2]

按列优先：a[0][0] a[1][0] a[0][1] a[1][1] a[0][2] a[1][2]

某个元素在内存中实际地址的公式：

按行优先存储，下标从0开始：a_i,j =LOC + (i x M + j) x L

按行优先存储，下标从1开始：a_i,j =LOC + [(i - 1) x M + (j - 1)] x L

按列优先存储，下标从0开始：a_i,j =LOC + (j x N + i) x L

按列优先存储，下标从1开始：a_i,j =LOC + [(j - 1) x M + (i - 1)] x L

十二、矩阵相关

12.1 对称矩阵

123A_0,0A_0,1A_0,3

234A_1,0A_1,1A_1,3

345A_2,0A_2,1A_2,3

A_i,j = A_j,i

左下三角区 + 主对角线

对称矩阵按行存储下三角区和主对角线并且下标从0(A0.0)开始

当(i ≥ j)时：A_i,j = $\frac{i(i+1)}{2}+j+1$

当(i ≤ j)时：A_i,j = $\frac{i(j+1)}{2}+i+1$

对称矩阵按行存储下三角区和主对角线并且下标从1(A1.1)开始

当(i ≥ j)时：A_i,j = $\frac{i(i-1)}{2}+j$

当(i ≤ j)时：A_i,j = $\frac{j(j-1)}{2}+i$

12.2 三对角矩阵

三对角矩阵按行存储并且下标从0(A_0,0)开始：A_i,j = 2i + j + 1

三对角矩阵按列存储并且下标从1(A_1,1)开始：A_i,j = 2i + j - 2

12.3 稀疏矩阵

顺序存储：三元组顺序表

链式存储：十字链表

十三、树相关

13.1属性结构与树的定义

非线性结构

树是n(n≥0)个结点的有限集合，n=0时称为空树。

有且仅有一个结点称为根。

树的定义是递归的，由若干颗子树构成，子树又由更小的子树构成。

13.2 树的基本概念

• 双亲、孩子：结点的子树称为该节点的孩子，该节点是子结点的双亲。
• 兄弟：具有相同双亲的结点互为兄弟。
• 结点的度：结点的子树的个数。
• 叶子结点：终端结点，度为0的结点。
• 内部结点：也称为分支节点或非终端结点。度不为0，除了根节点外，分支结点也称为内部结点。
• 结点的层次：根为第一层，根的孩子为第二层，以此类推。
• 树的高度（深度）：树的最大层次。

13.3 树的性质

1. 树的结点总数 = 树所有结点的度数之和 + 1
2. 度为m的树中第i层，最多有m^i-1个结点（i ≥ 1）
3. 高度为h的m次树，最多有$\frac{m^h - 1}{m - 1}$
4. 具有n个结点、度为m的树，最小高度为$\left\lceil \log_m \left( n(m-1) + 1 \right) \right\rceil$（上取整）

13.4 二叉树的定义

二叉树结点的子树，要区分左子树和右子树。（即使结点只有一棵树的时候也要明确指出）

二叉树的结点最大的度为2

13.5 二叉树的性质

1. 二叉树第i层(i ≥ 1)上最多有2^i-1个结点
2. 高度为h的二叉树最多有2^h-1个结点
3. 对于任何一棵二叉树，度为0的结点数等于度为2的结点数+1
4. 具有n个结点的完全二叉树的高度为$\left\lfloor \log_2 n \right\rfloor + 1$或$\left\lceil \log_2 (n+1) \right\rceil$

13.6 满二叉树与完全二叉树

满二叉树：深度为k的二叉树，有2^k-1个结点。叶结点只能出现在最底层，且非叶结点的度都为2

完全二叉树：从根到最后一层从左到右依次填满的结构。

满二叉树是完全二叉树的一个特例。

13.7 二叉树顺序存储

编号为i的结点：i=1，该节点为根节点，无双亲；i>1，则该结点的双亲结点为$\left\lfloor \frac{i}{2} \right\rfloor$

完全二叉树适合使用顺序存储，一般二叉树不宜采用顺序存储。

最坏的情况下，一个深度为k且只有k个结点的二叉树（单支树）需要2^k-1个存储单元

13.8 二叉树链式存储

二叉链表：n个节点，有n+1个空指针域

三叉链表：n个节点，有n+2个空指针域

13.9 二叉树遍历

1. 先序遍历：根左右

===> 遍历结果：ABDGCEF

2. 中序遍历：左根右

===> 遍历结果：BDGAECF

3. 后续遍历：左右根

===> 遍历结果：GDBEFCA

4. 层序遍历：一层一层，从左到右

===> 遍历结果：ABCDEFG

13.10 根据遍历构造二叉树

先序遍历：ABDGCEF

中序遍历：BDGAECF

后续遍历：GDBEFCA

层次遍历：ABCDEFG

以上加粗的为根节点，可以从先序、后序、层次中找到。

先序、后序是确定根的位置，中序确定根的子结点。

🌰****例子1：

• 先序：ABDGCEF
• 中序：BDGAECF
• 

🌰****例子2：

• 后序：GDBEFCA
• 中序：BDGAECF
• 

🌰例子3：

• 层次遍历：ABCDEFG
• **中序：**BDGAECF
• 

13.11 平衡二叉树

二叉树中的任意一个结点的左右子树高度之差的绝对值不超过1

叶子结点满足平衡二叉树的条件要求

完全二叉树是平衡二叉树

13.12 二叉排序树的定义

根节点的关键字 > 左子树所有结点的关键字，

根节点的关键字 **< **右子树所有结点的关键字，

左右子树也是一颗二叉排序树

中序遍历得到的序列是有序序列。

13.13 二叉排序树的构造

例子：

23 31 17 19 11 27 13 90 61

13.14 最优二叉树（哈夫曼树）定义和概念

带权路径长度最短的树。

路径：一个结点到另一个结点之间的通路。

路径上的分支数目称为路径长度。

树的带权路径长度：所有叶子结点的带权路径长度之和，计为WPL

WPL = 2x2 + 4x2 + 5x2 + 7x2 = 36

被乘数：是叶子结点的关键字

乘数：是根结点到该叶子结点的路径长度。这里从图中可以看出全是2

最优二叉树（哈夫曼树）的三个核心性质：

1. 给定一组具有确定权值的叶子结点，构造出的二叉树中带权路径长度（WPL）最小。
2. 只有度为0或2，没有度为1
3. 总结点数为：2n-1

13.15 最优二叉树构造

最优二叉树不唯一，但是WPL是唯一的。

构造规则：

1. 从前往后找2个权值最小
2. 小的在左边，大的在右边
3. 计算出权值，放入数组末尾
4. 权值相同时从前往后
5. 回调第一步。

🌰例子：{18、32、4、8、12、26}

1. 选4和8。
2. 选12和12。
3. 选18和24。
4. 选32和26。
5. 合并

13.16 哈夫曼编码定义

等长编码：对每个字符编值相同长度的二进制编码。

哈夫曼编码：一种根据字符出现频率构建最优前缀码的变长编码技术，用于数据压缩。

a：45 b：13 c：12 d：16 e：9 f：5		a：0 b：101 c：100 d：111 e：1101 f：1100

13.17 哈夫曼编码压缩比.

• 哈夫曼编码所需长度：1x40 + 3x10 + 3x20 + 3x16 + 3x14 = 220
• 等长编码所需长度：3x(40+10+20+16+14) = 300 （五个字符，等长编码，就需要3个二进制位代表一个值。）

压缩比：$1 - \frac{\text{哈夫曼编码所需长度}}{\text{等长编码所需长度}}$ =$1 - \frac{220}{300}$ ≈ 0.27

13.18 线索二叉树定义【应该是了解即可】

13.19 二叉树类别

1. 满二叉树
2. 完全二叉树
3. 平衡二叉树
4. 排序二叉树
5. 最优二叉树

十四、图相关

14.1 图形结构与图的定义

图中，任意两个结点之间都可能存在直接关系。所以，图中一个结点的前驱结点和后继结点的数目是没有限制的。

图G是有集合V和E狗策划给你的二元组，记作G=(V，E)。

V是图中顶点的非空有限集合，E是图中边的有限集合。

14.2 有向图和无向图

有向图：图中每条边都是有方向的，顶点的关系用<V_i，V_j>表示，V_i到V_j有一条有向边，V_i是起点称为弧尾，V_j是终点称为弧头

无向图：每条边都是没方向的。顶点的关系用<V_i，V_j>表示，但是没有方向上的区别。

14.3 完全图

无向完全图：无向图若有n个顶点，每个顶点与其他n-1个顶点之间都有边。共有$\frac{n(n-1)}{2}$条边。

有向完全图：有向图中，任意来个那个不同的顶点，都有方向相反的两条弧存在。共有n(n-1)条边。

14.4 顶点的度

度：仅无向图存在。当前结点存在的弧的个数。

出度：仅有向图存在。从当前结点指向其他结点的弧的个数

入度：仅有向图存在。从其他结点指向当前结点的弧的个数

14.5 路径

回路（环）：第一个顶点和最后一个顶点相同的路径

简单路径：路径中不包含重复的顶点。若一条路径上除了Vp和Vq可以相同外，其余顶点均不相同。

🌰****例子：

• 简单路径：A → B → C → D（无重复顶点，起点 ≠ 终点）
• 简单回路：A → B → C → A（起点 = 终点，其余顶点不重复）

14.6 连通图与强连通图

连通图：无向图中任意两个顶点都是联通的。

最少：n-1

最多：$\frac{n(n-1)}{2}$

强连通图：有向图中任意两个顶点都有互相联通的路径。

最少：n

最多：n(n-1)

14.7 邻接矩阵

无向图的邻接矩阵是对称的。

无向图：

• 非零元素个数 = e 个
• 顶点V_i的度是邻接矩阵第i行（或列）中值不为0的元素个数

有向图：

• 非零元素个数 = 2e 个
• 第i行（或列）中值不为0的元素个数是顶点V_i的出度
• 第j列中值不为0的元素个数是顶点V_j的入度

14.8 邻接表

无向图：表节点个数 = e = 邻接矩阵非零元素个数

14.9 稠密图和稀疏图

稀疏图：边的数量 远少于 顶点可能连接的最大边数。（可能图中大部分顶点之间没有直接连接。）

稠密图：边的数量 接近 顶点可能连接的最大边数。（可能图中大部分顶点之间都有边相连。）

14.10 网

边（或弧）带权值的图称为网。

14.11 图的遍历

1
2
3
4
5

    A
   / \
  B   C
 /   / \
D   E   F

深度优先算法：

• 定义：从一个起点出发，沿着一条路径尽可能深入地走到底，直到无法继续为止，然后回溯，再尝试其他分支。
• 遍历顺序可能是：A → B → D → C → E → F

广度优先算法：

• 定义：从起点开始，先访问所有距离为1的邻居，再访问距离为2的邻居，逐层向外扩散。
• 遍历顺序可能是：A → B → C → D → E → F

14.12 深度优先遍历

遍历顺序： V1、V2、V5、V4、V3 或 V1、V3、V2、V4、V5

14.13 深度遍历、广度遍历的时间复杂度

深度优先搜索DFS：

• 使用递归的思想进行遍历
• 邻接矩阵时间复杂度：O(n²)
• 邻接表时间复杂度：O(n+e)

广度优先搜索BFS：

• 使用队列的思想进行遍历
• 邻接矩阵时间复杂度：O(n²)
• 邻接表时间复杂度：O(n+e)

14.14 拓扑排序

AOV网的特点：

• 顶点：每个顶点代表一个活动。
• 有向边：有向边(A,B)(A,B)表示活动A需要在活动B开始前完成，即A是B的前提条件。
• 无环：为了确保所有活动可以被合理排序并最终完成，AOV网不能包含有向环。如果AOV网中存在环，则意味着某些活动之间存在循环依赖，导致无法进行有效的调度和执行。

AOV网进行拓扑排序：

1. 在AOV网选择一个入度为0的顶点，输出它。
2. 在网中删除该顶点，以及该顶点有关的所有弧。
3. 重复上述步骤，知道网中不存在入度为0的顶点为止。

低级语言：机器语言、汇编语言

高级语言：Java、C、C++、PHP、Python、Delphi、PASCAL

语言之间的翻译形式：汇编、解释、编译

高级语言编写的源程序，需要对应的解释程序或编译程序对其进行翻译。

解释程序（解释器）：

• 翻译程序是不产成独立的目标程序。
• 解释程序和源程序都要参与到程序的运行过程中。

编译程序（编译器）：

• 翻译时将源程序翻译成独立保存的目标程序。
• 机器上运行的是与源程序等价的目标程序。
• 源程序和编译程序都不参与目标程序的运行过程。

二、程序设计语言基本成分

基本控制结构：顺序、选择、重复（循环）

数据类型的作用：

• 便于合理分配存储单元
• 便于对参与表达式计算的对象进行检查
• 便于规定数据对象的取值范围以及能进行的运算

变量有对应的存储单元，常量没有。

三、传值调用与传地址调用

函数定义的基本形式：

函数调用：

值调用：

• 将实参的值传递给形参，实参可以是变量、常量、表达式
• 不可以实现形参和传参双向传递数据的效果。

引用调用：

• 将实参的地址传递给形参，形参必须有地址，实参不能是常量、表达式。
• 可以实现形参和实参间的双向传递数据的效果，即改变形参的值同时也改变实参的值

四、编译、解释程序翻译阶段

编译方式：

• 词法分析、语法分析、语义分析、中间代码生成、代码优化、目标代码生成
• 中间代码生成和代码优化不是必要，即前三步完成后可直接生成目标代码

解释方式：

• 词法分析、语法分析、语义分析

编译器和解释器都不可省略词法分析、语法分析、语义分析，且顺序不可变

五、符号表

不断收集、记录和使用源程序中一些相关符号的类型和特征等信息，并将其存入符号表。

记录源程序中各个字符的必要信息，以辅助语义的正确性检查和代码生成。

六、词法分析

输入：源程序

输出：记号流

主要作用：分析构成程序的字符，以及字符按照构造规则构成的符号是否符合程序语言的规定。

七、语法分析

输入：记号流

输出：语法树（分析树）

主要作用：对各条语句的结构进行合法性分析，分析程序中的句子结构是否正确。

八、语义分析

输入：语法树（分析树）

主要作用：进行类型分析和检查。

不能发现程序中所有的语义错误，只能发现静态语义错误。动态语义错误只能在运行是发现。

九、目标代码生成

该阶段的工作与机器密切相关。

寄存器的分配处于目标代码生成阶段。

十、中间代码生成

常见的中间代码：后缀式、三地址码、三元式、四元式和树（图）等形式

特征：

• 与具体机器无关（不依赖于具体机器）
• 可以将不用的高级程序语言翻译成同一种中间代码。
• 中间代码可跨平台

因为与机器无关，使用中间代码有利于进行与机器无关的优化处理和提高编译程序的可执行性。

十一、正规式

词法分析的工具

十二、有限自动机

词法分析的工具，能正确识别正规集

确定的有限自动机（DFA）：对每个状态来说识别字符后转移的状态是唯一的

不确定的有限自动机（NFA）：对每个状态来说识别字符后转移的状态是不唯一的

判断依据：看看每个状态（就是哪个小圆圈）是不是存在多个指向别的状态的箭头（指向自己的不算）。

十三、上下文无关文法

广泛用于各种程序设计语言的语法规则。

大写字母为非终结符，小写字母为终结符。

十四、中缀、后缀表达式装换

中缀式转后缀式，优先级相同，从左向右。

十五、语法树中序、后续遍历

中序遍历->中缀式

后序遍历->后缀式

中序：左根右

后序：左右根

• 例：1-2x(3+4)/5
• 

十六、杂题

1. 反编译是编译的逆过程，不能把可执行文件还原成高级语言源代码，只能转换成功能上等价的汇编程序。

2. 脚本语言是动态语言，动态语言都是解释型语言。

3. 变量存储的是内存单元地址时，成为指针变量。对指针变量进行算术运算，可以使其指向其他元素。

4. 链表中的结点空间需要程序员根据需要申请和释放，因此数据空间应该采用堆存储分配策略。

5. 可视化程序设计是以“所见即所得”的编程思想为原则

6. 编译时变量分配存储单元所用地址是逻辑地址，运行时映射成物理地址。

7. 程序运行时，用户内存空间分为代码区、静态数据区、栈区、堆区。栈区、堆区属于动态数据区，常量在静态数据区。

8. 语法分析方法，根据产生语法树的方向：

9. 自顶向下分析法：递归下降分析法、预测分析法。

10. 自底向上分析法：算符优先分析法、LR分析法、移进-规约分析法。

11. 用户可命名的对象：变量、函数、数据类型

12. 编程语言分类

13. 函数式编程语言：Lisp

14. 逻辑式编程语言：Prolog

15. 过程式、面向对象：Python

16. 面向对象：Java、C++

17. 语法制导翻译是静态语义分析方法。

18. 栈区由系统进行管理，堆区由程序员进行管理。

19. C或C++代码生成可执行文件的过程：预处理->编译->汇编->链接

20. Java特征：采用即时编译。对象在堆空间分配。自动垃圾回收。

21. Python中：

22. 列表（list）是可变、有序、可重复的序列结构

23. 元组（tuptle）、字符串（str）是不可变的

24. 集合（set）去重的

25. Python深度学习模型：TensorFlow、PyTorch、Keras

26. Python 绘图库：Matplotlib

• 计算机基本硬件系统：运算器、控制器、存储器、输入设备、输出设备
• 运算器、控制器等部件集成后成为中央处理器，是硬件系统的核心。
• CPU的功能：
  • 控制器：程序控制、操作控制、时间控制
  • 运算器：数据处理

二、运算器

• 运算器：由算数逻辑单元（ALU）、累加寄存器、数据缓冲寄存器、状态条件寄存器组成。
• 运算器的主要功能：
  • 算数运算：加、减、乘、除、附加运算。
  • 逻辑运算、逻辑测试：与、或、非、零值测试、两个值的比较。
• 算数逻辑单元（ALU）：重要组成部件，负责处理数据（算数运算、逻辑运算）。
• 累加寄存器（AC）：通用寄存器，为ALU提供一个工作区。运算结果存储在累加器中。
• 数据缓冲寄存器（DR）：CPU和内存、外部设备之间数据传送的中转站。
• 状态条件寄存器（PSW）:标志，进位、溢出、0标志、负标志、中断、方向。

三、控制器

要保证程序的正确执行，还要能处理异常事件。

• 指令寄存器（IR）：执行指令先从内存取到缓冲寄存器，再送入IR暂存。
• 程序计数器（PC）：具有寄存信息、计数两种功能。存储CPU要执行的下一条指令的地址。大多数情况都是顺序执行，所以修改过程只是简单的加1。
• 地址寄存器（AR）：保持当前CPU所访问的内存地址。
• 指令译码器（ID）：指令包含操作码和地址码。对指令中的操作码进行分析解释。

四、计算机基本单位

最小的数据单位：b

最小的存储单位：byte

五、十进制、二进制

• 十进制：0—9
• 二进制：0—1
• 八进制：0—7
• 十六进制：0—9 + A—F

按位展开求和：n进制—>十进制

• 将二进制 1011 转换为十进制 为🌰
• 

除n取余法：十进制—>n进制

• 将十进制 23 转换为二进制 为🌰
• 
• 

六、八进制、十六进制

1位十六进制数 = 4位二进制数

1位八进制数 = 3位二进制数

七、进制加减法

n进制加法：逢n进1

n进制减法：借1当n

八、原码、反码、补码、移码

原码：最高位是符号位，0表示正号，1表示负号，其余的n-1位表示数值的绝对值。

• 0有两种表示形式：[+0] = 0 0000000，[-0] = 1 0000000

反码：最高位是符号位，0表示正号，1表示负号。正数的反码与原码相同，负数的反码是负原码绝对值求反。

• 0有两种表示形式：[+0] = 0 0000000，[-0] = 1 1111111

补码：最高位是符号位，0表示正号，1表示负号。正数的补码与反码、原码相同，负数的补码是负反码末位加1。

• 0有唯一值：[+0] = 0 0000000

移码：补码的符号位取反。

特性：[[X]_补]_补 = [X]_原

九、浮点数

当机器字长为n时，定点数的补码和移码可表示2ⁿ个数，而原码和反码只能表示2ⁿ-1个数（0的表示占用了两个编码）。

一个二进制数N的浮点表示法为N = 2^E ✕ F，E为阶码，F为尾数。用阶码和尾数表示的数成为浮点数。

对阶：小阶向大阶对其，浮点数向右移。

浮点数中，数值范围由阶码决定，数值精确度由尾数决定。格式化就是将尾数限定在区间[0.5,1]

浮点数的阶码（包括1位阶符）用R位的移码表示，尾数（包括1位数符）用M位的补码表示，则这种浮点数能表示的数值范围：最大正数 最小负数

十、寻址

立即寻址：操作数包含在指令中。

直接寻址：操作数存在内存单元中，指令直接给出操作数所在存储单元的地址。

寄存器寻址：操作数放在寄存器中，指令给出存放操作数寄存器名。

寄存器间接寻址：操作数存放在内存单元中，操作数所在的存储单元的地址在某个寄存器中。

间接寻址：指令中直接给出操作数地址的地址。

速度(由快到慢)：立即寻址>寄存器寻址>直接寻址>寄存器间接寻址>间接寻址

以下两个无需掌握

相对寻址：指令地址码给出一个偏移量，操作数地址等于本条指令的地址加上偏移量。

变址寻址：操作数地址等于变址寄存器的内容加偏移量。

十一、奇偶校验码

在编码中增加一位校验位，使编码中1的个数位奇数（奇校验）或偶数（偶校验），从而使码距变为2。

对于奇校验，可以检测出奇数个出错的编码。偶校验是偶数个出错的编码。无法纠错。

常用奇偶校验码：水平奇偶校验码、垂直奇偶校验码、水平垂直校验码。

十二、海明码

码距等于2具有检索能力，码距大于等于3具有纠错能力。

利用奇偶性来检测和纠错的校验方法。

在数据位之间的特定位置插入k个校验位，扩大码距来实现检错、纠错。

公式：2^k-1 ≥ n+k （数据位是n位，校验位是k位）

十三、CRC循环冗余校验码

可以检错，但不能纠错。

利用生成多项式，为k个数据位产生r个校验位来进行编码，编码长度为k+r

求CRC编码时，采用的是模2运算。

十四、RISC和CISC

十五、流水线

总用时：第一条指令的执行时间 + (n-1) ✕ 最长段的时间

加速比：不用流水线的时间/采用流水线的时间

操作周期：最长时间段

吞吐率：最长时间段的倒数

十六、存储器

按位置分类：

• 内存（主存）：SRAM（静态随机存储器）
• 外存（辅存）：磁盘、磁带、光盘等。DRAM（动态随机存储器）需周期性刷新。
• 

工作方式分类：

• 读写存储器（RAM）：既能读取又能写入。
• 只读存储器：ROM(固定只读存储器)、PROM(可编程的只读存储器)、EPROM(可擦除可编程的只读存储器)、EEPROM(电擦除可编程的只读存储器)、闪速存储器(介于EPROM、EEPROM之间，以块为单位存储，取代ROM，不能代替主存)

访问方式分类：

• 按地址访问存储器
• 按内容访问存储器

按寻址方式分类：

• 随机存储器(RAM)
• 顺序存储器(SAM)
• 直接存储器(DAM)

级联存储器是一种按内容访问的存储器

虚拟存储器由主存、辅存构成。

十七、Cache

高速缓存主要是存放最活跃的程序和数据。

位于CPU和主存之间。

对于程序员来说是透明的。

部分用来存放主存的部分拷贝（副本）信息。

Cache与主存的映射是由硬件自动完成的。

替换算法：（目标是使Cache尽可能提高命中率，Cache越大，命中率越高）

• 随机替换算法：
• 先进先出算法：
• 近期最少使用算法：
• 优化替换算法：

地址映像方法：

• 直接映像：主存的块和Cache的块对应关系是固定的。
• 全相联映像：允许主存中的任意块放入Cache的任意块中。
• 组相联映像：主存和Cache都分组，组是一一对应的，但是组内的数据是任意存放的。
• 冲突：直接映像 > 组相联映像 > 全相联映像

十八、中断

中断向量：提供中断服务程序的入口地址。

中断响应时间：从中断发出开始 到 进入中断服务程序 的时间

保存现场：用于中断处理完，返回执行源程序。

十九、输入输出（IO）控制方式

1. 程序查询方式
   1. CPU和IO只能串行工作。CPU需要一直轮询。CPU利用率低
   2. 一次只能读写一个字
   3. 由CPU将数据放入内存
   4. 图例：
2. 中断驱动方式：
   1. IO由中断信号猪肚报告IO操作已完成。
   2. CPU和IO可并行工作。CPU利用率高。
   3. 由CPU将数据放入内存。
   4. 图例：
3. 直接存储器方式（DMA）：
   1. CPU和IO可并行工作。
   2. 仅在传送数据块的开始结束时，才需要CPU干预。
   3. 由外设直接将数据放入内存。
   4. 一次读写的单位为“块”。
   5. 图例：

二十、总线

总线分类：数据总线、地址总线、控制总线（口令：数地控）

常见总线：

• ISA总线：
• EISA总线：
• PCI总线：内总线，并行传输
• PCI-E总线：点对点串行链接
• 前端总线：
• RS-232C:
• SCSI总线：并行外总线
• SATA：
• USB：
• IEEE-1394：高速串行外总线
• IEEE-488:

二十一、加密技术与认证技术

窃听——加密

篡改——摘要

假冒、否认——数字签名、数字证书

1. 对称加密：加解密只有一把密钥（私钥用于加密）

   1. 特点：密钥分发存在缺陷。加密解密速度快。适合加密大量明文。

2. 非对称加密：加密、解密分别有自己的密钥（公钥用于加密）

   1. 公钥加密只能私钥解密，私钥加密只能公钥解密。
   2. 使用接收方公钥加密明文，可实现防窃听效果。
   3. 密钥分发无缺陷。加解密速度慢。

3. 混合加密：

4. 摘要：把明文进行hash算法，得到的摘要同密文一块发送。接收方解密后的明文，进行Hash得要摘要对比。

5. 数字签名：

   1. 发送方用私钥对摘要进行签名（加密）。得到的数字签名放入密文，一同发送。
   2. 接收方用发送方的公钥对数字签名验证（解密）。

数字证书：

• 用户向CA（权威）机构申请数字证书。
• 将个人信息和公钥发送给CA机构。
• CA机构颁发数字证书给用户。
• 数字证书用CA的私钥进行签名（加密）。
• 用CA的公钥验证（解密）数字证书，得要用户的公钥。

二十二、加密算法

对称加密（私钥、私有密钥加密）（共享密钥加密算法）：

• DES
• 3DES
• RC-5
• IDEA
• AES
• RC4

非对称加密：

• RSA
• ECC
• DSA

摘要算法：

• Hash算法
• MD5
• SHA-1安全散列算法

二十三、可靠性公式

串联：

• 
• R = R₁ R₂ … R_N

并联：

• 
• R = 1 - (1-R₁) (1-R₂ ) … (1-R_N)

二十四、补充

汇编语言中 程序员 可以访问 程序计数器

寄存器的位数取决于指令字长。

计算机分级存储的主要目的是为了解决 存储容量、成本和速度之间的矛盾 的问题。

计算机中CPU对其访问速度最快的是 通用寄存器。

**VLIW **是 超长指令字

算术左移指令相当于对操作数乘以2

CPU根据** 指令周期的不同阶段** 来区分内存中以二进制编码形式存放的指令和数据。

平均CPI = （比例 × CPI ）相加

运算速度MIPS = CPU主频 / 平均CPI

在B站看到的zst2001博主的软考中级的讲解很不错。所以打算整理一下笔记。本文为后续文章的索引。

二、索引

1. 计算机系统【软考zst2001专辑笔记】001计算机系统
2. 程序设计语言【软考zst2001专辑笔记】002程序设计语言
3. 数据结构-上卷【软考zst2001专辑笔记】003数据结构-上卷
4. 数据结构-下卷【软考zst2001专辑笔记】004数据结构-下卷
5. 知识产权【软考zst2001专辑笔记】005知识产权

[!NOTE]

本文非原创，原文由Sagyam Thapa创作

原文链接：https://blog.sagyamthapa.com.np/interactive-guide-to-rate-limiting

This article is not original. The original text was created by Sagyam Thapa

The original link: https://blog.sagyamthapa.com.np/interactive-guide-to-rate-limiting

介绍

限流是每个后端应用程序中的必备策略。它可以防止一个用户过度使用资源并降低其他用户的服务质量。以下是速率限制的一些好处：

1. 它呈现资源匮乏
2. 降低服务器托管成本
3. 提供针对 DDoS 的基本保护

我制作了四个交互式应用程序，让您尝试常见的速率限制算法。

令牌桶

工作原理

桶中保存固定数量的令牌

令牌以固定速率添加到存储桶中

当收到请求时：

• 如果令牌可用，则会将其从存储桶中删除并允许请求。
• 如果没有可用的令牌，则请求将被拒绝或延迟。

如果令牌可用，则允许偶尔进行短暂的并发

我创建了一个应用程序 ，让您玩转漏桶算法。

漏水桶

工作原理

将其视为以固定速率泄漏的桶

传入请求将添加到存储桶中

请求以恒定速率处理（或“泄漏”）

如果新请求到达时存储桶已满，则会丢弃该请求

平滑连拍；以稳定的速率输出请求

我制作了一个应用程序 ，让您玩转漏桶算法。

固定窗口

工作原理

时间被划分为固定大小的窗口（例如，1 分钟）

计数器跟踪当前窗口中每个客户端/IP 的请求数

如果计数超过限制，则进一步的请求将被拒绝，直到下一个窗口

简单高效，但允许在结束/开始时出现突发流量峰值

我创建了一个应用程序 ，让您使用固定窗口算法。

滑动窗口

工作原理

保留每个请求的时间戳日志

当收到请求时，将检查日志以计算在过去 X 秒内发出的请求数

如果低于限制，则允许并记录请求;否则，它将被拒绝

我创建了一个应用程序 ，让您玩滑桶算法。

中文演示

文章原有的演示页面为英文，我用“豆书记”简单的写了一下中文的演示页面，共大家参考：

• 令牌桶：http://log.660066.xyz/2025/06/13/interactive-guide-to-rate-limiting/token-bucket.html
• 漏水桶：http://log.660066.xyz/2025/06/13/interactive-guide-to-rate-limiting/leaky-bucket.html
• 固定窗口：http://log.660066.xyz/2025/06/13/interactive-guide-to-rate-limiting/fixed-window.html
• 滑动窗口：http://log.660066.xyz/2025/06/13/interactive-guide-to-rate-limiting/sliding-window.html

最近需要在MacOS上想装一个HMLC的启动器，因为开发的时候，使用的ZuluJDK8（最新版本），但是最新版本没带javaFX模块。HMLC又需要JavaFX模块启动，在网上搜索了一下，JDK8的JavaFX的好像没有支持的，都是自带的。

所以打算再装个JDK17，这样的话，我就需要可以动态切换JDK版本。开发的时候用8，玩MC的时候，就需要使用JDK17。

二、安装ZuluJDK

https://www.azul.com/downloads/

自己去下载安装吧，反正这个安装起来，比Win都无脑。

三、配置JDK切换

3.1 编辑.zshrc

1

vim ~/.zshrc

3.2 调整配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# JDK版本切换
export JAVA8_HOME=/Library/Java/JavaVirtualMachines/zulu-8.jdk/Contents/Home
export JAVA17_HOME=/Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home
CLASSPATH=$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:.

# 设置默认JDK版本
export JAVA_HOME=$JAVA8_HOME

# 配置alias命令可以动态切换JDK版本  
alias jdk8="export JAVA_HOME=$JAVA8_HOME"
alias jdk17="export JAVA_HOME=$JAVA17_HOME"
export JAVA_HOME
export PATH
export CLASSPATH

追加到文件结尾就行

3.3 生效.zshrc

1

source ~/.zshrc

3.4 测试

一、飞机延误

本来是晚上9点的飞机，从遥墙飞宝安。飞机是从大连飞到济南，但是4月30日晚上，大连下大雨，导致飞机延误。一直拖了到12点半，才开始登机，当时买的春秋航空，都说上了飞机就卖东西，可能是太晚的原因，并没空姐推销东西，我立马进入入睡状态。

大约三点半，落地了宝安，在宝安附近定的酒店，打了个滴滴，立马飞奔睡觉。

二、深圳一日游

深圳本来打算的挺好的，要去深圳湾，要去各种地方。但是第一站，就是去看看腾讯大厦，看看国内的大厂。

第二站，去华强北，本来是奔着去买个安卓备用机的，但是去了才发现，全是苹果，全是苹果啊。再加上五一，很多档口的老板可能都休假了，有些档口直接处于无人的状态，不太清楚是黄了还是休假了。

第三站，去中英街。提前感受一下香港地区的风土人情，因为第二天打算去香港。中英街就是个商业街，卖各种东西的。各种免税店，这里的大店铺是用港币结算的，小店铺有可能是港币也可能是人民币，大家去的时候一定要问清是什么结算。

大概看了一下化妆品、保健品啥的价格，因为五一的时候，汇率是94:100，说实话，也没太大优惠，但是肯定是比直接在淘宝天猫京东这些网店买要便宜。索性来一趟，买了点零食，买了一小箱南洋罐。

下面请看图！

高德显示的是香港，但是我看网上说是大陆和香港共管的状态。

这里是中英街的入口。

这条路好像是通往香港的，有武警战士在这站岗，这么多提示，一定是有大陆的游客曾经走进过去。

在深圳的当天晚上，是在皇岗口岸的格林豪泰入住的，因为三月就把酒店订好了，价格也不是很贵，订了两天。不打算晚上在香港过夜，主要是因为那边法律和大陆不同，再加上价格肯定高，所以就直接回深圳睡觉，反正也不是很远。

三、香港一日半游

因为看到网上有人说，过口岸会排长队，一大早就去了皇岗口岸。最后发现，过口岸的时候，几乎不用排队，直接进人工通道过境。

闸机人真的很少，几乎不用排队。过了闸机，需要坐大巴车去香港的口岸，然后刷通行证，拿过关小条。

因为是第一次去香港，不是很懂，边问边走。花了10港币，坐了皇巴，从大陆开到了香港口岸，然后过完关，再换车（只是换车，不用再交费用了），把你送出口岸。

其实当时不是很懂，不应该坐皇巴，因出了香港这边的口岸，不是很好找公交车，当时应该坐九巴这些，直接去想去的那些地方，很方便。

入境香港了，右舵车的天下。都说香港的冷气（空调）开得足，那确实是足，我本来就比较胖，所以说，冷一点也感觉不出啥来。不过大陆过来的小姑娘真的建议穿件防晒衣啥的。

这个图是我当时坐公交车，香港的公交车不便宜啊，12港币我记得。在车上的第一件事，就是换香港的手机卡。然后开香港银行卡，把汇丰、中银、众安都开了。

汇丰、众安都没啥太大问题。但是中银就不太好了，他需要识别我的身份证开启流动保安码，但是我名字里有个生僻字，OCR算法死活不认，没办法只能下次去香港的时候，线下营业厅搞一个实体的令牌了。如果不开启流动保安码，没法转账（有别的方式转）、没法修改通讯地址。

上面说的没法转账，其实也有办法，但是每天限额2W港币，对我来说，足够了。用BocPay+这个App去转账。

到了香港的第一站，就去了紫金广场，看看大海，看看紫荆花雕像。

这个图就是著名的星光大道，梁朝伟的手印哈哈哈哈。

ICAC查案，不方便透露。打卡点的人不是很多，我们去了，陆陆续续的有三四个人也来打卡。

去廉政公署打卡，旁边有个大厅，可以卖廉政公署的周边纪念品。我朋友买了个廉政公署的小咖啡杯，另一个朋友买了名片夹。我买了一个廉政公署的胸章和一个水瓶。

下午去了太平山，真的不建议去，出发不是旅游旺季。人太多，啥也不好看。

此时此刻，还不知道，一会下山要经历什么痛苦。大概拍了点照片，太累了，就去排队坐大巴下山了，一路上，我丢那个堵啊，那个要命啊。别问我为啥不坐缆车，那缆车排队2小时起步，哈哈哈哈哈扛不住。

当天还去了深水埗的鸭寮街，主要是去买大湾区的电信蓝卡，这样就有一个香港的手机号了，还能在大陆合法访问谷歌，就是流量有点贵，可以去参考参考小红书。

晚上回深圳，去皇岗村吃了个烧烤（真贵啊，不是一般的贵）。

第二天，有了经验，8点才去的皇岗口岸，人还是不多，这次直接坐的大巴，直捣油麻地警署，买点纪念品。

油麻地警署，人不少，可以早点去排队买点周边啥的，有很大一部分人，不是排队买周边，是排队打卡拍照哈哈哈哈。

哦豁，中午吃饭的时候，发现了一个BTC的ATM机，可以买比特币哈哈哈。

随后去了旺角中心，真没啥东西感觉，也可能是逛的时间短了？反正初印象就是，不如大陆宽敞。如果让我选一个地方生活，我还是喜欢在大陆生活。

四、返程回国

去苏州了，跳槽到了苏州，开启人生新篇章。

下一站去哪？新疆天山？西藏拉萨？韩国首尔？我还没想好。

但是，这次出镜去香港，本来是去见识见识资本主义是啥样的，但是发现，好像也没什么特别的地方。不知为啥，还是感觉大陆更自在更舒服。

1. 待整理……

二、后端

1. 待整理……

三、数据库

1. MySQL死锁：https://mp.weixin.qq.com/s/l6E5otoON1CQIEfIUHDvdA

四、运维

1. 待整理……

五、其他

1. DDD架构：https://mp.weixin.qq.com/s/DAiGCgE0ZdBRw_ckhD8AQA
   • DDD 系列 第一弹 - Domain Primitive：https://mp.weixin.qq.com/s?__biz=MzAxNDEwNjk5OQ==&mid=2650403892&idx=1&sn=a91fa477392e80f9420a8ca4d26bcace
   • DDD系列 第二弹 - 应用架构：https://mp.weixin.qq.com/s?__biz=MzAxNDEwNjk5OQ==&mid=2650404060&idx=1&sn=cacf40d19528f6c2d9fd165151d6e8b4
   • DDD系列 第三讲 - Repository模式：https://mp.weixin.qq.com/s?__biz=MzAxNDEwNjk5OQ==&mid=2650406692&idx=1&sn=4a4ac4168299d8ca1905a4f457ae4c59
   • DDD系列第四讲：领域层设计规范：https://mp.weixin.qq.com/s?__biz=MzAxNDEwNjk5OQ==&mid=2650414919&idx=1&sn=0ad1df1a1b0e2488f7faa21008fdbdd0
   • DDD系列第五讲：聊聊如何避免写流水账代码：https://mp.weixin.qq.com/s?__biz=MzAxNDEwNjk5OQ==&mid=2650427571&idx=1&sn=bfc3c1c6f189965a1a4c7f3918012405
   • DDD之于逛逛内容营销中的应用：https://mp.weixin.qq.com/s?__biz=MzAxNDEwNjk5OQ==&mid=2650433660&idx=1&sn=cb424db17b96aa28b476edafa2bc3509
   • DDD之于业务支撑的意义：https://mp.weixin.qq.com/s?__biz=MzAxNDEwNjk5OQ==&mid=2650517536&idx=1&sn=926ba6f2c0fcc01aaf5abeea625aa260

备份仓库：https://github.com/BaseOrange/solution-record

在文档处理场景中，用户踢出需求，需要根据以下规则隐藏或保留段落：

1. 标题保留条件：仅当标题的子段落中存在有权限的填报项时，该标题才被保留。
2. 段落类型区分
   • 正文/表格：根据权限决定是否保留。
   • 标题：需结合子段落的保留状态判断是否保留。
3. 层级嵌套复杂性：标题的层级（如一级标题、二级标题）需通过段落层级信息（OutLevel）动态计算其子段落范围。

存在的典型问题

• 标题范围计算错误：未正确记录标题的结束位置，导致误判子段落范围。
• 保留条件不精准：未区分“有权限填报项”与其他保留类型（如正文），导致标题被错误保留。

二、解决思路

1. 分阶段处理逻辑

将问题拆解为三个阶段，逐步解决：

1. 基础保留标记：标记每个段落的保留状态（retained数组）。
2. 标题范围与保留判断：通过层级嵌套关系确定标题的子段落范围，并判断是否保留。
3. 结果生成：根据保留标记生成最终的删除/保留指令。

2. 关键逻辑设计

(1) 标题范围计算

• 使用栈结构：通过栈记录当前层级的标题，动态维护标题的嵌套关系。
• 层级比较：当遇到新标题时，若其层级≤栈顶标题层级，则弹出栈顶标题并记录其结束位置。
• 结束位置处理：遍历结束后，栈中剩余标题的结束位置设为文档末尾。

(2) 保留条件细化

• 段落保留规则
  • 正文/表格：仅保留有权限的填报项。
  • 标题：仅保留子段落中存在有权限填报项的标题。
• 权限判断：通过FillInfo对象获取段落的填报项权限信息。

(3) 标题保留判断

• 遍历子段落：对每个标题的子段落范围（start到end），检查是否存在有权限的填报项。
• 标记保留状态：若满足条件，将标题的titleShouldKeep标记为true。

三、关键代码解析

1. 基础保留标记（retained数组）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 标记每个段落的保留状态
for (int i = 0; i < size; i++) {
    Para p = paras.get(i);
    int paraOutLevel = XxxUtil.getParaOutLevel(p, styles);
    FillInfo fillItemPermission = getFillItemPermission(fillItemList, p.getPos());
    boolean hasPermission = fillItemPermission.isHasPermission();
    FillItem fillItem = fillItemPermission.getFillItem();
    if (!hasPermission && fillItem != null) {
        retained[i] = false; // 无权限的填报项不保留
    } else if (paraOutLevel == 0) {
        // 正文或填报项：仅保留有权限的
        retained[i] = hasPermission;
    } else {
        // 标题或表格：根据层级是否需要保留
        if (levelsToKeep.contains(paraOutLevel)) {
            retained[i] = true; // 标题先标记为保留，后续根据子段落修正
        }
    }
}

关键点：

• 权限优先：无权限的填报项直接标记为不保留。
• 层级过滤：仅保留需要显示的层级（如levelsToKeep中的层级）。

2. 标题范围计算（栈结构）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 确定标题的子段落范围
List<Range> titleRanges = new ArrayList<>();
Stack<Range> stack = new Stack<>();
for (int i = 0; i < size; i++) {
    Para p = allPapx.get(i);
    int paraOutLevel = DocDataUtil.getParaOutLevel(p, styles);
    if (paraOutLevel > 0 && levelsToKeep.contains(paraOutLevel)) {
        while (!stack.isEmpty() && paraOutLevel <= stack.peek().getLevel()) {
            Range popped = stack.pop();
            popped.setEnd(i - 1); // 当前段落的前一个位置为结束
            titleRanges.add(popped);
        }
        Range newRange = new Range();
        newRange.setStart(i);
        newRange.setLevel(paraOutLevel);
        stack.push(newRange);
    }
}
// 处理栈中剩余标题
while (!stack.isEmpty()) {
    Range r = stack.pop();
    r.setEnd(size - 1); // 结束位置为文档末尾
    titleRanges.add(r);
}

关键点：

• 栈的层级判断：通过层级比较确保标题范围的正确嵌套。
• 结束位置修正：遍历结束后，确保所有标题范围到文档末尾。

3. 标题保留判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 判断标题是否保留
for (Range r : titleRanges) {
    boolean hasPermissionFilledForm = false;
    for (int j = r.getStart() + 1; j <= r.getEnd(); j++) {
        FillInfo fillItemPermission = getFillItemPermission(fillItemList, allPapx.get(j).getPos());
        if (retained[j] && fillItemPermission.isHasPermission()) {
            hasPermissionFilledForm = true;
            break;
        }
    }
    if (hasPermissionFilledForm) {
        titleShouldKeep[r.getStart()] = true; // 标记标题保留
    }
}

关键点：

• 子段落遍历：检查标题的子段落（start+1到end）中是否存在有权限的填报项。
• 权限双重验证：仅当retained[j]为true（被基础保留）且hasPermission为true（有权限）时，才视为有效。

4. 结果生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 生成最终的删除/保留指令
List<ResultItem> result = new ArrayList<>();
int i = 0;
while (i < size) {
    Para p = paras.get(i);
    int paraOutLevel = XxxUtil.getParaOutLevel(p, styles);
    if (paraOutLevel > 0 && levelsToKeep.contains(paraOutLevel)) {
        // 标题的保留状态由titleShouldKeep决定
        retained[i] = titleShouldKeep[i];
    }
    // 处理表格或普通段落
    if (/* 是表格 */) {
        // 删除表格并跳过所有表格段落
    } else {
        if (!retained[i]) {
            // 记录删除指令
            result.add(new ResultItem(p.getPos(), p.getLen(), 0));
        }
        i++;
    }
}

关键点：

• 标题保留状态更新：根据titleShouldKeep覆盖标题的retained标记。
• 统一处理：通过retained数组统一判断段落的保留或删除。

四、验证与测试

1. 测试案例

以用户提供的案例为例：

1
2
3
4
5
6
7
8

段落索引 | 内容              | 层级 | 是否保留
-----------------------------------------------
0       | 一级1            | 1    | false（无子段落有权限填报项）
1       | 二级1            | 2    | false
...     | ... | ...  | ...
18      | 一级2            | 1    | true（子段落包含有权限填报项）
21      | 二级10           | 2    | true（子段落包含有权限填报项）
25      | 有权限填报项      | 0    | true

验证逻辑：

• 一级2的保留：子段落（索引19-25）包含索引25的有权限填报项 → 保留。
• 二级10的保留：子段落包含索引25的有权限填报项 → 保留。
• 一级1的不保留：子段落中无有权限的填报项 → 不保留。

2. 边界条件测试

• 无子段落的标题：若标题无子段落，不保留。
• 层级嵌套交叉：如一级→二级→三级的复杂结构，确保范围计算正确。

五、总结与扩展

1. 解决方案优势

• 精准控制：通过层级栈和权限双重判断，确保标题保留的条件严格符合需求。
• 可扩展性：通过levelsToKeep和权限接口，可灵活适配不同业务场景。

2. 可优化方向

• 性能优化：对大规模文档，可优化子段落遍历逻辑（如预处理子段落列表）。
• 异常处理：增加对层级不合法或权限信息缺失的容错机制。

一、上传out文件夹

基于上一篇打包文章，需要将out文件夹上传到CentOS。

此处不在赘述。

二、安装rabbitmq及其配置

1. 更新yum（基本操作）

   1	yum -y update

2. 安装EPEL存储库

   1 2 3

   yum -y install epel-release yum -y update # (无网环境自行下载)https://packagecloud.io/rabbitmq/erlang

3. 安装Erlang语言

   1 2 3

   yum -y install erlang socat # 查看是否成功安装 erl -version

4. 下载并安装RabbitMq（自行选择方式，wget、curl、上传等）

   1 2 3 4 5 6 7 8 9 10 11 12

   https://github.com/rabbitmq/rabbitmq-server/releases/download/rabbitmq_v3_6_16/rabbitmq-server-3.6.16-1.el7.noarch.rpm # 安装命令 rpm -ivh rabbitmq-server-3.6.16-1.el7.noarch.rpm # 启动服务 systemctl start rabbitmq-server # 查看服务状态 systemctl status rabbitmq-server # 停止服务 systemctl stop rabbitmq-server #开启开机自启 systemctl enable rabbitmq-server

5. 添加RabbitMq用户（根据自己需要配置，一般生产无需配置）

   1 2 3 4 5 6 7 8 9 10 11

   # 创建账号和密码 rabbitmqctl add_user 用户名 密码 # 设置用户角色： rabbitmqctl set_user_tags 用户名 administrator # 为用户添加资源权限，添加配置、写、读权限 rabbitmqctl set_permissions -p "/" 用户名 ".*" ".*" ".*" #修改用户密码 rabbitmqctl change_password 用户名 新密码

三、安装nginx及其配置

1. 更新yum、安装EPEL存储库（Mq安装时一描述，不在赘述）

2. 安装nginx

   1 2 3 4 5 6 7

   yum install nginx # 启动Nginx服务： systemctl start nginx # 检查Nginx服务状态： systemctl status nginx # 设置Nginx开机自启： systemctl enable nginx

3. 配置Nginx配置

   1 2 3 4 5 6

   # 切换到配置文件目录 cd /etc/nginx/conf.d/ # 创建配置文件 touch nginx.conf # 编辑(配置信息如下) vim nginx.conf

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

   map $http_host $this_host { "" $host; default $http_host; } map $http_x_forwarded_proto $the_scheme { default $http_x_forwarded_proto; "" $scheme; } map $http_x_forwarded_host $the_host { default $http_x_forwarded_host; "" $this_host; } map $http_upgrade $proxy_connection { default upgrade; "" close; } proxy_set_header Host $http_host; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection $proxy_connection; proxy_set_header X-Forwarded-Host $the_host; proxy_set_header X-Forwarded-Proto $the_scheme; server { listen 0.0.0.0:80; listen [::]:80 default_server; server_tokens off; rewrite ^\/OfficeWeb(\/apps\/.*)$ /web-apps$1 redirect; location / { proxy_pass http://localhost:8000; proxy_http_version 1.1; } }

4. 重启Nginx

   1	nginx -s reload

四、修改项目配置文件

配置文件路径：./out/linux_64/onlyoffice/documentserver/server/Common/config/

不知道的配置项含义及其作用时，建议不要自己调整。

1. 数据库（因项目需要，将数据库替换为Mysql）

   1. 数据库SQL路径：./out/linux_64/onlyoffice/documentserver/server/schema/

   2. 搜索sql关键字。type根据需要进行调整。dbHost(数据库ip)、dbPort(端口)、dbName(库名)、dbUser(用户名)、dbPass(密码)

      

2. Redis

   1. 根据自己的需要，调整host、port、password(密码这个属性不一定存在，请自行测试！)

      

3. RabbitMq

   1. 使用vim搜索关键词rabbitmq，因为我的rabbitmq与服务在同一主机，所以无需调整。

   

五、启动项目

1. 生成字体数据信息

   1 2 3 4 5 6 7 8 9 10 11

   cd out/linux_64/onlyoffice/documentserver/ mkdir fonts # 生成命令 LD_LIBRARY_PATH=${PWD}/server/FileConverter/bin server/tools/allfontsgen \ --input="${PWD}/core-fonts" \ --allfonts-web="${PWD}/sdkjs/common/AllFonts.js" \ --allfonts="${PWD}/server/FileConverter/bin/AllFonts.js" \ --images="${PWD}/sdkjs/common/Images" \ --selection="${PWD}/server/FileConverter/bin/font_selection.bin" \ --output-web='fonts' \ --use-system="true"

2. 生成演示主题

   1 2 3 4 5 6

   cd out/linux_64/onlyoffice/documentserver/ # 生成命令 LD_LIBRARY_PATH=${PWD}/server/FileConverter/bin server/tools/allthemesgen \ --converter-dir="${PWD}/server/FileConverter/bin"\ --src="${PWD}/sdkjs/slide/themes"\ --output="${PWD}/sdkjs/common/Images"

3. 启动FileConverter

   1 2 3 4 5 6 7

   cd out/linux_64/onlyoffice/documentserver/server/FileConverter # 环境变量 export LD_LIBRARY_PATH=$PWD/bin export NODE_ENV=development-linux export NODE_CONFIG_DIR=$PWD/../Common/config ./converter # 守护执行 nohup ./converter > /xxxx/converter.log 2>&1 &

4. 启动DocService

   1 2 3 4 5 6

   cd out/linux_64/onlyoffice/documentserver/server/DocService # 环境变量 export NODE_ENV=development-linux export NODE_CONFIG_DIR=$PWD/../Common/config # 守护执行 nohup ./docservice > /xxxx/docservice.log 2>&1 &

二、注意事项

因部分依赖在阿里云镜像中可能不存在，因此镜像源未进行更改，编译全过程使用依赖软件自带镜像源。

系统版本、架构一定要按官方要求来，我踩坑路线：

• Ubuntu25（Arm）=> 内嵌的python不支持arm架构
• Ubuntu24.04（X64）=> 编译V8相关内容是卡住，综合来看，可能是clang或其他打包工具版本过高的原因。
• Ubuntu16.04（X64）=> 目前跑过了上面的错误，还不知道有没有其他坑。

系统的内存、Swap也不能随便搞（可以大，不能小！）：

总结一下就是，系统版本得按照上图，CPU、RAM、HDD、SWAP都要安装上图官方的来！

如果你用的是带Gui的桌面版乌班图，建议吧RAM、SWAP适当的调高一些。

三、编译

3.1 克隆编译工具（build_tools）

1

git clone https://github.com/ONLYOFFICE/build_tools.git

3.2 切换到linux编译目录

1

cd build_tools/tools/linux

3.3 执行编译命令

1

./automate.py server

3.4 编译命令注意事项

如果在没有任何参数的情况下运行脚本，这将构建 ONLYOFFICE 文档以及 Document Builder 和 Desktop Editors。

如有必要，可以使用与必要产品对应的参数运行脚本，从而一次构建多个产品。

工作：

1. 公司项目顺利的稳步开发中
2. 沟通上，有了进步，不像一年前刚入职时候语无伦次的样子了。管理上老样子，插不进手，毕竟刚毕业，也没资格插手哈哈哈哈哈。
3. 年内换了两次工位，从公共办公区进了会议室集中开发， 又从会议室搬到了经理室门口，”经理警卫排”。
4. 木涨薪、木涨薪、木涨薪。就这就业环境及其恶劣的情况下，还好没辞退我，谢天谢地了也是。

生活：

1. 24年总共去了三个地方。苏州->上海->南京
2. 找到了女朋友
3. 搬了新住处，在此提醒，济南的各位朋友，济南租房找中介、二房东的，95%你是拿不回押金的。（泊寓、冠寓等大概能拿回来，但是每年都涨租）

学习：

1. 了解了一下React相关的知识，但是完全去开发还是比较困难
2. LLM了解的比较多，相关的专业概念、术语也有所了解。
3. 软考划水的一年，很显然，过不了哈哈哈哈哈

资产：

1. 资产上比较走运。买了债基，小赚一笔。
2. 在低点买了沪指基金，也小赚了一点。
3. 黄金也多少赚了一点点，很少，也就买杯奶茶的钱。
4. 真是凑巧。24年，债牛、股牛都让我赶上了，虽然没赚到大钱，但是多少赚了点饭钱。
5. 开了证券账户，买了一手股票，开始积累股票交易经验。（妥妥投机分子我）
6. 年底置办了Mac mini m4的丐版。构建出了手机、手表、电脑的苹果生态。

2025年展望

工作：

1. 一步一个脚印，稳扎稳打，保证别出现重大生产事故。
2. 进一步提升沟通、管理能力。加强自己对系统架构的设计能力。
3. 尽量避免摸鱼被经理抓包。

生活：

1. 初步打算是五一去香港旅游，目前港澳通行证已经在审批了。
2. 多出去转转、玩玩。
3. 拔牙，公司给买的商业医疗补充险，把两个智齿拔了。

学习：

1. React还是要看啊，完成“全干”工程师的基本技能
2. 拿到软考中级证书，多看题多刷题。
3. 继续深耕LLM相关领域，重点是OCR识别、应用开发、微调相关方面。
4. 打算拿一下A类业余无线电执照

资产：

1. 也是稳扎稳打吧，以稳健投资为主体。
2. 多元化布局投资，布局少量的激进投资产品。
3. 学习一下金融投资相关的知识，少踩坑，多赚钱。

后话

其实本来有个2023年总结来着，2024年写着写着就写到年中了，实在是太忙，索性不总结了。

/etc/paths

• 作用：定义系统的路径列表，即命令搜索路径。
• 适用范围：全局，影响所有用户。
• 使用方法：直接编辑此文件，添加或修改路径条目。

/etc/paths.d/

• 作用：这是一个目录，可以在这个目录下创建多个文件，每个文件可以包含一个或多个路径条目，这些路径将被添加到PATH环境变量中。
• 适用范围：全局，影响所有用户。
• 使用方法：在/etc/paths.d/目录下创建文件，每行一个路径条目。

/etc/profile

• 作用：系统级的配置文件，当用户登录时，它会被读取以设置环境变量。
• 适用范围：全局，影响所有用户。
• 使用方法：编辑此文件，添加或修改环境变量设置。

~/.bash_profile

• 作用：用户级的配置文件，当用户登录时，它会被读取以设置环境变量和启动命令。
• 适用范围：仅影响当前用户。
• 使用方法：编辑此文件，添加或修改环境变量设置。

~/.bashrc

• 作用：用户级的配置文件，当用户打开一个新的终端窗口（非登录shell）时，它会被读取。
• 适用范围：仅影响当前用户。
• 使用方法：编辑此文件，添加或修改环境变量设置。

~/.zshrc

• 作用：如果你使用的是Zsh作为默认shell，这个文件会在每次打开新的终端窗口时被读取。
• 适用范围：仅影响当前用户。
• 使用方法：编辑此文件，添加或修改环境变量设置。

~/.profile

• 作用：用户级的配置文件，如果~/.bash_profile不存在，Bash会尝试读取这个文件。
• 适用范围：仅影响当前用户。
• 使用方法：编辑此文件，添加或修改环境变量设置。

/etc/launchd.conf

• 作用：系统级的配置文件，用于设置环境变量，这些变量在系统启动时生效。
• 适用范围：全局，影响所有用户。
• 使用方法：编辑此文件，添加或修改环境变量设置。注意：在macOS Catalina及更高版本中，/etc/launchd.conf可能不再被支持，建议使用launchctl命令来设置环境变量。

launchctl

• 作用：命令行工具，用于设置系统级或用户级的环境变量。

• 适用范围：全局或用户级。

• 使用方法：

  • 设置系统级环境变量：

    1	sudo launchctl setenv VARIABLE_NAME value

  • 设置用户级环境变量：

    1	launchctl setenv VARIABLE_NAME value

示例

假设你想为当前用户设置一个环境变量MY_VARIABLE，可以编辑~/.bash_profile文件：

1

nano ~/.bash_profile

添加以下内容：

1

export MY_VARIABLE=value

保存并退出编辑器，然后使更改生效：

1

source ~/.bash_profile

这样，每次你登录或打开一个新的终端窗口时，MY_VARIABLE就会被设置。