未似风不息

静态博客也能用管理面板了吗？

Sun, 02 Nov 2025 01:45:14 GMT

众所周知，静态博客部署简单、访问速度快，但缺点也很明显，不方便管理，每次发布文章都需要在本地编写好 Markdown 文件，然后推送到 GitHub 仓库中，操作起来比较麻烦。如果能有一个管理面板，可以直接在浏览器中编写和发布文章，那就更方便了。

无意中看到一个视频，是今年八月份发布的，介绍了一个名为 Hexo Pro 的项目，可以为 Hexo 博客添加一个管理面板，实现在线编写和发布文章等功能。于是下载了看看效果，发现十分不错，虽然有一些小问题，但整体体验还是很好的。相信作者会不断改进这个项目。

Hexo Pro

安装 Hexo Pro

只需要在 Hexo 博客的根目录下运行以下命令：

npm install --save hexo-pro

安装成功（这个项目文件好多 QAQ）

之后三连启动你的 hexo 服务器

hexo cl; hexo g; hexo s

然后在浏览器中访问 http://localhost

/pro/，就可以看到 Hexo Pro 的管理面板了。

fengmian10.png

配置 Hexo Pro

首先点击左侧系统管理->设置，配置你的博客信息，包括用户名、密码等，面板会把第一个进入的用户设置为管理员。

启用链接重定向

由于这是在 localhost 下运行的，所以需要看你个人情况决定是否开启。

编辑器模式

选择即时渲染模式，这样可以实时预览文章效果。

显示文章封面

开启显示文章封面，这样在文章列表中可以看到封面图片。建议开启。

跳过静态文件生成

如果没配置 GitHub Actions，可以开启这个选项，节省生成静态文件的时间。否则不建议开启。

存储类型

这个目前没法配置自己的图床，只有本地存储和一些大厂提供的存储服务。如果你有对应账号，可以选择你喜好的存储，否则选择本地存储（或使用你个人图床，只是这样麻烦一些）。

GitHub 部署配置（不建议）

不建议的原因是当你保存配置后，面板会自动修改你的 _config.yml 文件，这倒没什么，但你的代码中注释全部消失，而且没法撤回。如果你对你代码足够了解且不在意是否有注释，请往下看，否则请忽略此配置。（我发现后，想找之前拷贝过代码的 u 盘，结果发现 u 盘落在教室了，算是因祸得福了）

进入部署页面，配置你的 GitHub 仓库信息，格式为：username/repo，例如：weisifengbuxi/weisifengbuxi.github.io。

分支选择main或者master。

提交信息使用默认的即可

GitHub Token 需要你自己生成，进入 GitHub Developer Settings，点击 Generate new token，选择 repo 权限，然后生成一个新的 Token，复制粘贴到 Hexo Pro 的 GitHub Token 输入框中即可。注意 token 只会出现一次，因此要妥善保存。

体验功能

体验总体来说还是可以的，评分没那么高的原因是我的 u 盘到现在还是没找见，应该再也见不到了 QAQ，那个是学校给的，上面还有校徽。（也提醒大家不要图方便随便把 u 盘揣兜里，等你发现的时候就太迟了）。

优点

便于管理文件，尤其对刚建站的新手来说，这个面板可以让他们减少很多摸索时间，能尽快的将精力投入到文章创作之中，并且也方便后期管理。（但我觉得一个博客可以通过不断美化主题，来达到熟悉每项配置的效果。我当时刚建完博客，看到文件夹套文件夹天都塌了，后来跟着其他大佬美化了几十次也逐渐了解了每个文件的作用）

缺点

其中我觉得最不能接受的就是修改配置后会删掉注释，尤其是备份文件还找不到的时候！另外不能链接自己的图床我觉得是一大遗憾，当然这也正常。算我异想天开了。
面板功能不够多，这个和一些著名的面板比就能看出来，比如宝塔面板。
当你足够熟悉博客后，再用这个面板会觉得很不习惯。
当你使用该面板进行创作时，你每输入一个字，本地都会保存一次，这样当你双屏写作时候，看到不断刷新的保存信息会很不舒服。

当然我自然相信作者会逐渐让这个项目大放光彩的，我们拭目以待。

海洋保育户外课见闻

Sat, 01 Nov 2025 00:00:00 GMT

学校要求我们修一门 WPE 课，也就是水课，内容是关于海洋保育的。导师是梁霜芷。课程安排了一次去淇澳岛红树林自然保护区的户外教学活动，亲身体验海洋保育工作。以下是我这次户外课的一些见闻。

其实这篇文章我早应该写的，只是太忙了，最近放假才有时间写这篇文章。

淇澳岛简介

淇澳岛位于珠江口东侧，是珠海市的一个重要岛屿。岛上有丰富的自然资源和独特的生态环境，是海洋生态保护的重要区域。淇澳岛以其美丽的海滩、清澈的海水和丰富的海洋生物资源吸引了众多游客和研究人员。

淇澳岛最有名的动物是招潮蟹，这种小型甲壳类动物以其独特的行为和生态习性而闻名。招潮蟹生活在潮间带，能够适应潮汐变化，具有重要的生态功能，如促进泥沙循环和维持生态平衡。

此外还有弹涂鱼，这种鱼类因其腹部有强大的肢体，能够在陆地和水中生活，具有独特的适应能力。弹涂鱼在淇澳岛的红树林生态系统中扮演着重要角色，帮助维持生态平衡。

海洋保育的重要性

海洋保育是指保护和管理海洋生态系统，以确保其健康和可持续发展。随着人类活动的增加，海洋生态系统面临着诸多威胁，如污染、过度捕捞和气候变化等。保护海洋生态系统不仅有助于维护生物多样性，还能保障人类的生存和发展。

户外课

当时是周六下午 2 点，我们乘坐校巴前往淇澳岛。到达岛上后，就往里面走，最先看见的是一大片红树林。红树林是热带和亚热带沿海地区特有的生态系统，具有重要的生态功能，如防风固沙、净化水质和提供栖息地等。

老师带着专业的摄影装备，首先发现的动物是白鹭，由于没有拍到好的图片，以下会使用一些同学拍摄的照片

pVz0EOs.jpg

白鹭

pVz0Zmn.jpg

pVz0KYT.jpg

树上白色的都是白鹭

路过一座桥的时候发现桥下有很多招潮蟹，雄蟹的最大特征就是大小悬殊的一对螯，颜色鲜艳，有特别的图案。重量几乎为身体的一半，长度为该蟹甲壳直径的三倍以上。

zhaochaoxie.jpg

招潮蟹

pVz0ewq.jpg

pVz0mT0.jpg

也有很多弹涂鱼，可惜没拍到其特点，用一张网图

pVz0ukV.jpg

弹涂鱼

红树林的作用有很多，这里我举两个重要的

防风消浪红树林的根系发达，能够在恶劣的海洋环境中形成稳固的支架，减缓海浪对陆地的冲击，保护海岸线，降低洪水深度，维护海岸稳定性，因而被称为“海岸卫士”。
固碳储碳红树林通过光合作用吸收二氧化碳，储存在植物体内和土壤中，有助于减缓气候变化。红树林生态系统每年能够吸收大量的二氧化碳，其固碳能力远高于陆地森林。

印象里老师给了一个具体数据，记不太清了，只记得数值很大。展示红树林夸张的固碳能力。

注意事项

因为是湿地保护区，没有路的土地是不能走的，此外如果没有采摘证，是不能随意采摘保护区内的任何东西，即使它掉到你的面前。没有潜水证，是不能随便下水的。

这个注意保护招潮蟹和弹涂鱼，因为总有人会把他们装到桶里带走，破坏生态平衡。

梁霜芷老师

于是老师便带着一堆图片以便我们了解保护区内的其他生物。被来来往往的游客当成导游了，还在旁边看。。。

后面回去的时候老师发现许多小朋友走到栈道外面捕捉螃蟹，于是大声喝止，几个同学就走在前面假装老师是工作人员，狐假虎威地提醒小朋友们不要乱抓动物。

结语

还有很多内容，可惜时间太长了，我得一点一点回忆，总的来说梁老师的课还是很有意思的，虽然这门课不算绩点，但是能学到很多课本上没有的知识。她也很有耐心，愿意和我们分享她的专业知识。希望以后还能有机会参加类似的户外教学活动，亲身体验自然，了解更多关于海洋保育的知识。

此处赠诗一首，以表纪念：

蓝海为卷授真知，远涉重洋探藻茨。

课非显要趣盈室，巧设嬉游启稚思。

携赴滩涂亲碧浪，身虽娇小凛霜姿。

见斥妄为伸正义，丹心护海寄情痴。

为你的网站添加免费的EdgeOne CDN加速服务

Thu, 30 Oct 2025 00:00:00 GMT

很多朋友的网站没有购买服务器，因此部署在国外的服务器上，比如 Vercel。但由于 Vercel 国内被墙了，因此没法使用 CDN 加速。这使得网站访问速度十分缓慢。

听说腾讯云有相关免费 CDN 就去试了一下，没想到居然这么良心，免费套餐就能满足大部分个人站长的需求，而且配置起来也非常简单。分享一下如何为你的网站添加腾讯云 CDN 加速服务，保护你的网站同时让你的网站访问速度飞起来！

话不多说，直接上教程。

在开始前，你需要为你的网站备案，并注册一个腾讯云的账号（最好实名认证）

将你的网站部署在 EdgeOne 上

点击访问该链接EdgeOne page，点击创建项目，选择导入 Git 仓库，这时候你需要将你的网站代码上传到 GitHub，再将 GitHub 仓库地址填写进去，验证。之后选择你的项目进入。

edgeone1.png

进入你的项目之后点击开始部署，注意项目中不要有单个大小超过25MB的文件，否则会部署失败。

获得免费套餐资格

然后你需要先获得免费套餐内测资格，正常有以下几种方式获得（不推荐）：

在 X 平台分享
在 Discord 上赢取兑换码
GitHub 合作计划

EdgeOne 后两种方法我没试过，在 x 平台也就是推特，只需要点击立即发布，然后分享一条推文就可以获得免费套餐资格。这是很轻松的，当然如果你没法打开 X 平台，这里再提供第四种更简单的方法，就是直接点击下面的链接申请免费套餐资格。

我看其他博主没人说这个方法，就当是本站福利了（笑）。

点击下方链接

腾讯云 EdgeOne 免费套餐申请

选择每周抽兑换码，扫描二维码就可以参与了，这个兑换码每周发两千个，但实际参与人只有不到 200 个，因此 100%能拿到兑换码。

配置 CDN 加速

现在你有了免费套餐资格，接下来就可以配置 CDN 加速了。

进入你的EdgeOne 项目，点击新增站点，点击开始接入即可，之后将你的兑换码兑换个人版免费版即可（只能兑换这个）。

接下来的配置请根据你的网站实际情况进行配置即可，主要配置以下几个选项：

站点域名：填写你的网站域名
源站配置：填写你的网站源站地址，如果是从腾讯云购买的域名可以一键配置，否则得用 cname 配置
加速区域：选择全球加速
协议配置：建议开启 HTTPS，选择自动申请免费证书
缓存配置：建议开启静态资源缓存
防护配置：这个在免费版中好像不能设置

如果你是新手第一次配置，可以去看张洪 heo 大佬的文章腾讯云 EdgeOne 免费无限量 CDN 流量，良心到哭了（抽兑换码）

配置完之后效果非常显著。检测访问全国都是深绿色，没有闪电标志，最关键的是长期完全免费的。这次真的得感谢腾讯云，良心到家了！

彻底掌握插入排序与归并排序

Wed, 29 Oct 2025 00:00:00 GMT

冒泡排序法（Bubble Sort） 是一种简单的排序算法，它通过重复地遍历待排序的列表，比较相邻的元素并交换它们的位置来实现排序。虽然十分直观，但其时间复杂度达到了 O(n2)O(n^2)O(n2) 在大多数情况下效率较低，尤其是对于大型数据集来说。此时，插入排序（Insertion Sort） 和 归并排序（Merge Sort） 提供了更高效的替代方案。本文将详细介绍它们的原理、实现及性能分析，帮助读者彻底掌握这两种排序方法。

插入排序（Insertion Sort）

插入排序是一种简单直观的排序算法，它的工作原理类似于整理扑克牌。通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。

原理

从第一个元素开始，该元素可以认为已经被排序。
取出下一个元素，在已经排序的元素序列中从后向前扫描，找到相应位置并插入。
重复步骤 2 和 3，直到所有元素均排序完毕。

fengmian7.1.png

插入排序

几种排序演示 你也可以点击上方链接，进入可视化网站亲自体验插入排序的演示

实例

假设有一个待排序的列表 [5, 2, 4, 6, 1, 3]，插入排序的过程如下：

初始状态：
1. 已排序部分：[5]
2. 未排序部分：[2, 4, 6, 1, 3]
第一轮：
1. 取出未排序部分的第一个元素 2
2. 将 2 与已排序部分的 5 比较，2 < 5，插入到 5 前面
3. 已排序部分：[2, 5]
4. 未排序部分：[4, 6, 1, 3]
第二轮：
1. 取出未排序部分的第一个元素 4
2. 将 4 与已排序部分的 5 比较，4 < 5，插入到 5 前面
3. 已排序部分：[2, 4, 5]
4. 未排序部分：[6, 1, 3]
第三轮：
1. 取出未排序部分的第一个元素 6
2. 将 6 与已排序部分的 5 比较，6 > 5，插入到 5 后面
3. 已排序部分：[2, 4, 5, 6]
4. 未排序部分：[1, 3]
第四轮：
1. 取出未排序部分的第一个元素 1
2. 将 1 与已排序部分的 6、5、4、2 依次比较，1 < 2，插入到 2 前面
3. 已排序部分：[1, 2, 4, 5, 6]
4. 未排序部分：[3]
第五轮：
1. 取出未排序部分的第一个元素 3
2. 将 3 与已排序部分的 6、5、4 依次比较，3 < 4，插入到 4 前面
3. 已排序部分：[1, 2, 3, 4, 5, 6]
4. 未排序部分：[]

最终，列表被排序为 [1, 2, 3, 4, 5, 6]。

实现

以下是插入排序的 Java 实现代码：

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

复杂度分析

时间复杂度：最坏情况下为 O(n2)O(n^2)O(n2)，平均情况下为 O(n2)O(n^2)O(n2)，最好情况下为 O(n)O(n)O(n)（当数组已经有序时）。
空间复杂度：O(1)O(1)O(1)，因为插入排序是原地排序算法。

稳定性：插入排序是稳定的排序算法。适用场景：适用于小规模数据集或部分有序的数据集。优点：简单易实现，适合小数据集，具有稳定性。缺点：对于大规模数据集效率较低。

归并排序（Merge Sort）

归并排序是一种高效的排序算法，采用分治法（Divide and Conquer）策略。它将待排序的数组分成两半，分别对这两半进行排序，然后将排序好的两半合并在一起。

原理

将数组分成两半，递归地对每一半进行归并排序。
当子数组的大小为 1 时，认为它们已经排序好。
合并两个已排序的子数组，形成一个更大的已排序数组。

fengmian7.2.png

归并排序

几种排序演示

实例

假设有一个待排序的列表 [38, 27, 43, 3, 9, 82, 10]，归并排序的过程如下：

初始状态：
- 待排序部分：[38, 27, 43, 3, 9, 82, 10]
分割阶段：
- 将列表分成两半：[38, 27, 43] 和 [3, 9, 82, 10]
- 继续分割：
  - [38, 27, 43] 分成 [38] 和 [27, 43]
  - [27, 43] 分成 [27] 和 [43]
  - [3, 9, 82, 10] 分成 [3, 9] 和 [82, 10]
  - [3, 9] 分成 [3] 和 [9]
  - [82, 10] 分成 [82] 和 [10]
合并阶段：
- 合并 [27] 和 [43] 得到 [27, 43]
- 合并 [38] 和 [27, 43] 得到 [27, 38, 43]
- 合并 [3] 和 [9] 得到 [3, 9]
- 合并 [82] 和 [10] 得到 [10, 82]
- 合并 [3, 9] 和 [10, 82] 得到 [3, 9, 10, 82]
- 最后合并 [27, 38, 43] 和 [3, 9, 10, 82]

得到最终排序结果 [3, 9, 10, 27, 38, 43, 82]

实现

以下是插入排序的 Java 实现代码：

public class MergeSort {
    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }
    public static void merge(int[] arr, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int n2 = right - mid;

        int[] L = new int[n1];
        int[] R = new int[n2];

        for (int i = 0; i < n1; i++)
            L[i] = arr[left + i];
        for (int j = 0; j < n2; j++)
            R[j] = arr[mid + 1 + j];

        int i = 0, j = 0;
        int k = left;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }

        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
}

复杂度分析

时间复杂度：最坏情况下为 O(nlog⁡n)O(n \log n)O(nlogn)，平均情况下为 O(nlog⁡n)O(n \log n)O(nlogn)，最好情况下为 O(nlog⁡n)O(n \log n)O(nlogn)。
空间复杂度：O(n)O(n)O(n)，因为归并排序需要额外的存储空间来存放临时数组。
稳定性：归并排序是稳定的排序算法。
适用场景：适用于大规模数据集，尤其是需要稳定排序的场景。
优点：时间复杂度稳定，适合大数据集，具有稳定性。
缺点：需要额外的存储空间，空间复杂度较高。

时间复杂度稳定指的是无论输入数据的初始顺序如何，无论数组每次被分成几部分，归并排序的时间复杂度始终保持在 O(nlog⁡n)O(n \log n)O(nlogn)，这使得它在处理各种类型的数据时表现一致。

【学习笔记】逻辑门电路

Wed, 22 Oct 2025 00:29:00 GMT

下周一要考试，因此通过这篇文件对逻辑门电路进行一个简单的复习和总结。

逻辑门电路简介

1937 年克劳德・香农(Claude Shannon) 在硕士论文中提出，电气开关可用于实现布尔逻辑，这是连接电子元件与逻辑运算的关键理论突破。

基本逻辑门电路

逻辑门的本质：是实现布尔函数的数字电路，接收 2 个或多个输入信号，输出基于布尔运算的结果，实际由 1-6 个晶体管组成，但被视为独立功能单元。

基础逻辑门及实现

非门（Inverter）：用 CMOS 晶体管实现，输入为 0（0V）时，N 型管断开、P 型管导通，输出 1（2.9V）；输入为 1 时则相反。
或门与或非门：或非门直接通过晶体管组合实现，或门可基于或非门进一步搭建，二者均遵循 “有 1 出 1（或非门为有 1 出 0）” 的逻辑规则。
与门与与非门：与非门通过多组晶体管串联 / 并联实现，与门可基于与非门搭建，遵循 “全 1 出 1（与非门为全 1 出 0）” 的逻辑规则。

fengmian6.1.png

三种逻辑门电路示意图

通用逻辑门

定义：可独立实现任何布尔函数，无需依赖其他类型逻辑门。代表类型：NAND（与非门）和 NOR（或非门），因成本低、易制造，成为集成电路中最基础的门电路。

组合逻辑电路

逻辑门

逻辑门是电路的基本构建块 定义：小型电子设备，用于计算二值信号（0/1）的逻辑函数，是组合电路的基础单元。

常见类型：

基本门：AND（仅双输入为 1 时输出 1）、OR（至少一个输入为 1 时输出 1）、NOT（输入取反，又称反相器）；
扩展门：XOR（异或，输入不同时输出 1，用于加法器）、NAND（与非，AND 后取反，属 “通用门” 可构建其他门）、NOR（或非，OR 后取反，亦为通用门）。

布尔函数的三种等价表示

布尔函数是组合电路的数学描述，有三种表示形式逻辑等价，可相互转换

表示形式	核心作用
真值表	用逻辑运算符（ ⋅/AND\cdot /AND⋅/AND 、+/OR+ /OR+/OR 、 ¬/NOT\neg /NOT¬/NOT 、 ⊕/XOR\oplus /XOR⊕/XOR ）描述输入与输出的数学关系（如 XOR：Q=A⊕B）
逻辑电路	用逻辑门物理连接实现布尔函数，是表达式的硬件映射

典型组合电路实例

加法器

加法器是实现二进制加法的基础电路，按输入位数分为三类

半加器（Half Adder）

功能：仅计算 2 个 1 位二进制数（A、B）的和，输出 “和（S）” 与 “进位（C）”
逻辑表达式：S = A⊕BA \oplus BA⊕B（异或）、C = A・B（与）
电路结构：1 个 XOR 门（算和）+ 1 个 AND 门（算进位）

全加器（Full Adder）

功能：计算 3 个 1 位二进制数（A、B、进位输入 Cin），解决半加器无法处理 “来自低位进位” 的问题，输出 S 和进位输出 Cout
电路结构：由 2 个半加器串联（第一个算 A+B 的和与进位，第二个结合 Cin 算最终 S，两个进位通过 OR 门输出 Cout）

4 位 ripple-carry 加法器

功能：计算两个 4 位二进制数的和，将全加器 “级联” 实现（文档 1）
结构：4 个全加器串联，前一个全加器的 Cout 接后一个的 Cin，初始 Cin=0
缺点：进位信号 “逐位传递”，速度慢（ripple 即 “ ripple 延迟”）

解码器（Decoder）

功能：n 个输入对应 2ⁿ个输出，对任意输入组合，仅 “唯一 1 个输出” 为 1（其余为 0），实现 “输入到输出的选择映射”
典型应用：计算机内存地址解码 —— 当 CPU 访问内存时，解码器将二进制地址信号转换为 “唯一内存单元的选中信号”
示例：2-4 解码器（2 输入 A、B，4 输出 Y0-Y3），逻辑表达式如 Y0=A・¬B、Y1=¬A・BY0=A・\neg B、Y1=\neg A・BY0=A・¬B、Y1=¬A・B 等

多路复用器（Multiplexer, MUX）

功能：“通道选择器”，从 n 个输入中选 1 个输出，选择由 log₂n 个 “控制端” 决定
示例：4-to-1 MUX（4 输入 I0-I3，2 控制端 S1、S0）—— 通过 S1S0 的 4 种组合（00-11），分别选择 I0-I3 输出
核心作用：在数字系统中实现 “数据路由”，如 CPU 内部数据选择、总线数据传输

算术逻辑单元（ALU）

功能：实现基本算术（加法、减法）和逻辑运算（AND、OR），是 CPU 的核心组件
结构示例：1 位 ALU 结合全加器实现加法，2 位 ALU 通过级联 1 位 ALU + 解码器，增加 “溢出（Overflow）” 检测功能

组合电路的分析与设计流程

分析流程

核心目标：已知电路结构，推导其实现的布尔函数（文档 1），步骤为:

标记电路输入、输出及中间门的输出
从输入到输出，逐步写出每个门的逻辑表达式
化简表达式，结合真值表验证逻辑功能

设计流程

核心目标：已知功能需求，构建电路，标准 5 步：

需求转真值表：根据功能描述，枚举所有输入组合及对应输出（如 1 位比较器需列出 A、B 的 4 种组合与 G/E/L 的关系）
导出布尔表达式：从真值表中提取 “输出为 1” 的输入组合，写出 “积之和（SOP）” 表达式
表达式最小化：用卡诺图（Karnaugh Map）简化 SOP 表达式，减少门的数量，优化电路
门级实现：用逻辑门搭建简化后的表达式（如 1 位比较器用 AND、OR、NOT 门实现 G=A・¬B、E=A・B+¬A・¬BG=A・ \neg B、E=A・B+ \neg A・\neg BG=A・¬B、E=A・B+¬A・¬B）
验证：通过真值表或仿真，确认电路功能符合需求

设计实例：1 位比较器

需求：比较两个 1 位二进制数 A、B，输出 G（A>B）、E（A=B）、L（A<B）
真值表：

输入 A	输入 B	输出 G（A>B）	输出 E（A=B）	输出 L（A<B）
0	0	0	1	0
0	1	0	0	1
1	0	1	0	0
1	1	0	1	0

简化表达式：G=A⋅¬B、E=A⋅B+¬A⋅¬B、L=¬A⋅BG=A·\neg B、E=A·B + \neg A·\neg B、L=\neg A·BG=A⋅¬B、E=A⋅B+¬A⋅¬B、L=¬A⋅B
电路实现：用 2 个 AND 门（实现 G、L）、1 个 OR 门 + 2 个 AND 门（实现 E）搭建

集成电路（IC）与应用场景

集成电路

定义：将大量晶体管（及逻辑门）集成到单个小型芯片中，是组合电路的实际载体
分类：按门数量分为小规模（SSI，如单个门）、中规模（MSI，如加法器、解码器）、大规模（LSI）等

核心应用

组合电路是数字革命的关键组件，应用于

数字计算：计算器、CPU 的 ALU
数据处理：数字信号处理（DSP）、总线数据路由（MUX/Decoder）
存储控制：内存地址解码
智能设备：机器人控制、数字通信（信号编码 / 解码）

单元核心总结

本质：组合电路是 “无记忆的数字逻辑模块”，输出仅依赖当前输入，由逻辑门按布尔函数构建
关键实例：加法器（半加器→全加器→4 位加法器）、解码器、MUX、ALU，覆盖算术运算、数据选择、逻辑比较核心需求
工程逻辑：分析（电路→函数）与设计（需求→电路）需依托真值表、布尔表达式、卡诺图，核心是 “简化与验证”
价值：是计算机、数字设备的基础，支撑从简单运算到复杂数据处理的所有数字功能。

时序电路

基础

核心定义：区别于组合电路

对比维度	组合电路（Combinational）	时序电路（Sequential）
输出依赖	仅依赖当前输入	依赖当前输入 + 历史状态（前序输入）
记忆性	无记忆（memoryless）	有记忆（可 “记住” 前序输入）
核心需求	实现算术 / 逻辑运算（如 ALU、加法器）	实现存储、计数、时序控制（如寄存器、计数器）

时序电路本质是 “组合电路 + 存储器”，其中一种结构如下图所示：

shixudianlu.png

SR-NOR 锁存器

存储器的基本要求（以 1 位存储器为例）

可写（Write）：能修改存储的二进制值（0→1 或 1→0）
可保持（Hold）：无修改操作时，能稳定保留当前值
可读（Read）：能获取存储的当前值
最小存储单元：1 位存储器（存储 0 或 1）

基础存储单元：锁存器与触发器

时序电路的 “记忆核心” 是锁存器（Latch） 和触发器（Flip-flop），二者均基于 “反馈” 实现记忆（电路输出反馈至输入）。

反馈：记忆的原理

反馈是时序电路实现记忆的关键：将电路输出信号回传至输入，使输出状态能 “自我维持”（如 Q=0 时持续输出 0，Q=1 时持续输出 1）
但单纯反馈无法修改状态，需额外控制信号（如 Set/Reset）实现 “写操作”

SR 锁存器（Set/Reset Latch）：最基础的时序单元

核心功能

通过 Set（置 1）和 Reset（置 0）信号控制 1 位存储，是时序电路的 “基础积木”（类似组合电路的逻辑门）。

类型与特性

类型	核心组件	特性表（Q (t+1) 为下一状态，Q (t) 为当前状态）	关键问题
SR-NOR 锁存器	2 个 NOR 门交叉连接	S=0,R=0：Q (t+1)=Q (t)（保持）S=0,R=1：Q (t+1)=0（置 0） S=1,R=0：Q (t+1)=1（置 1）S=1,R=1：undefined（非法状态）	S=1,R=1 时，Q 与 ¬Q\neg Q¬Q 均为 1（逻辑矛盾，不稳定）
SR-NAND 锁存器	2 个 NAND 门交叉连接	S=0,R=0：undefined（非法） S=0,R=1：Q=1（置 1） S=1,R=0：Q=0（置 0） S=1,R=1：保持	非法状态为 S=0,R=0

SR-NOR 锁存器即为上图所示，SR-NAND 锁存器则是用 NAND 门实现，因此逻辑相反（Set/Reset 信号为低电平有效）。

触发器（Flip-flop）

核心区别

锁存器（Latch）：电平触发（EN 为高 / 低电平时持续响应输入，状态随输入变化）
触发器（Flip-flop）：边沿触发（仅在时钟信号的 “上升沿” 或 “下降沿” 瞬间响应输入，状态稳定，无毛刺）

关键类型 JK 触发器：解决 SR 锁存器的非法状态

结构：SR 触发器 + 反馈逻辑，确保 S 和 R 不同时有效
特性表：
- J=0,K=0：保持 Q (t+1)=Q (t)
- J=0,K=1：置 0 Q (t+1)=0
- J=1,K=0：置 1 Q (t+1)=1
- J=1,K=1：翻转 Q (t+1)= ¬Q(t)\neg Q (t)¬Q(t) （核心优势，可用于计数）

D 触发器：真正的 1 位存储器

问题：SR/JK 触发器需 2 个控制端（S/R 或 J/K），操作复杂
设计：仅 1 个数据端（D）+ 时钟端，时钟触发时 Q=D（直接存储 D 的值）
优势：无非法状态，是计算机物理内存的 “最小单元”，满足 “写 - 保持 - 读” 全部需求

时钟系统

时钟的定义与作用

定义：产生周期性电脉冲的电路，速度单位为兆赫兹（MHz，百万脉冲 / 秒）
核心作用：控制时序电路的状态更新时机，确保所有存储单元 “同步工作”，避免状态混乱

时钟触发方式

触发类型	触发时机	适用场景
边沿触发	时钟脉冲的 “上升沿”（低→高）或 “下降沿”（高→低）瞬间	触发器（如 D/JK 触发器），状态稳定
电平触发	时钟信号持续为高 / 低电平时	锁存器，响应速度快但易受毛刺影响

时序电路典型应用

寄存器（Register）

功能：存储一组二进制数（如 4 位、8 位），是 CPU 内部临时存储数据的核心
结构：由多个 D 触发器串联组成（如 4 位寄存器 = 4 个 D 触发器，共享时钟和写使能）

关键信号

数据端（D3~D0）：输入 4 位数据写使能（WE）：WE=1 时允许写入，WE=0 时保持数据清零端（Clear）：将所有触发器置 0（初始化）

二进制计数器（Binary Counter）

原理：用 JK 触发器的 “翻转特性”（J=K=1 时 Q=¬Q\neg Q¬Q），通过时钟同步级联 4 位计数器示例：

4 个 JK 触发器级联，低位触发器的 Q 端接高位触发器的时钟端
每来一个时钟脉冲，最低位（B0）翻转，低位从 1→0 时高位翻转（如 0000→0001→0010→……→1111）
状态方程：
- B0 (t+1) = ¬B0(t)\neg B0 (t)¬B0(t)
- B1 (t+1) = B1 (t) ⊕\oplus⊕ B0 (t)
- B2 (t+1) = B2 (t) ⊕\oplus⊕ (B1 (t)・B0 (t))
- 高位同理，实现 “逢 2 进 1”

内存（Memory）

基础结构：4x3 内存示例

存储单元：每个 “字（Word）”=3 位，共 4 个 word（Word0~Word3）组成：3 个 D 触发器 /word + 解码器（地址选择） + 写使能

总结

时序电路的本质：组合电路 + 存储器 + 时钟，具备记忆功能；基础存储单元：锁存器（电平触发）→ 触发器（边沿触发，如 D/JK 触发器）；典型应用：寄存器（CPU 临时存储）、计数器（计数 / 定时）、内存（大规模存储）；时钟的关键：同步状态更新，避免时序混乱。

这篇文章写的很不满意，主要是时间太紧了，导致很多概念没有完全理解，更多的是依靠 ai。后续 rw 会修改的。

【学习笔记】链表、栈、队列的实现方法

Wed, 15 Oct 2025 21:30:00 GMT

链表（Linked List）、栈（Stack）、队列（Queue）是数据结构中最基础的三大结构（还有一个是数组）。熟悉并掌握数据结构和算法是合格程序员基本功之一，不同的结构在不同的应用场景中往往会带来不一样的处理效率。之前文章中已经介绍了链表，本文将介绍栈和队列，以及这三种结构的实现方法。

栈和队列

栈

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

fengmian6.png

栈示意图

栈，通俗地说，就像我们往一个杯子里面放东西一样，先放进去的放在最下面，只有把上面的东西拿出来后才能拿出下面压着的东西。

栈，具有很多用处，计算机中很多处理都是通过栈这种数据结构来进行的，比如算术运算，准备两个栈，一个栈存储数字，一个栈存储符号，从头开始依次把字符对应压入到这两个栈中，当所有字符都放入栈之后，依次从数字栈中取出两个元素，并从符号栈中取出一个元素，进行计算，结果压回数字栈，继续以此运行，直到符号栈为空，或者数字栈只剩下一个元素为止，弹出这个数字即为最后的结果。

这么说很抽象，后面以实际题目进行讲解。

实现方法

可以用数组（连续的内存空间，按索引取值）来实现栈。

栈的基本方法只有两个，分别为入栈（Push）元素和出栈（Pop）。

以 Lab3 作为例题，题目如下：

fengmian6.2.jpg

链表 UML 图

method

public Stack(int size)
- Creates an empty stack whose capacity is size（构造方法，初始化栈，参数 size 指定栈的大小。）
public boolean isEmpty()
- Returns true if the stack is empty and false otherwise （判断栈是否为空）
public boolean isFull()
- Returns true if the stack is full and false otherwise（判断栈是否已满）
public Double top()
- Returns the top element （获取栈顶元素）
- Returns null if the stack is empty （如果栈为空则返回 null）
public Double push(double x)
- Adds a new element with value x to the top of the stack （将新元素 x 压入栈顶）
- Returns the new element if the operation is successful and null otherwise （如果操作成功则返回新元素，否则返回 null）
public Double pop()
- Removes and returns the top element of the stack （弹出栈顶元素并返回该元素）
- Returns null if the operation fails （如果操作失败则返回 null）
public void displayStack()
- Displays all elements in the stack from top to bottom （从栈顶到栈底显示栈中所有元素）

这是老师给的模板，在此基础上进行实现：

public class Stack {

	/* YOUR CODE HERE*/ 
	
	public static void main(String[] args) {
		Stack myStack = new Stack(4);
		System.out.println(myStack.isEmpty());
		myStack.push(-3);
		myStack.push(5);
		System.out.println("The stack has 2 items:");
		myStack.displayStack();
		myStack.push(1);
		myStack.push(2);
		myStack.push(-1);
		System.out.println("The stack has 4 items:");
		myStack.displayStack();
		System.out.println("The top is: " + myStack.top());
		System.out.println(myStack.isFull());
		myStack.pop();
		myStack.pop();
		myStack.pop();
		myStack.pop();
		System.out.println("The stack is empty:");
		myStack.displayStack();
	}

}

我们定义一个 double 类型数组 values 来存储栈中的元素，一个整型变量 top 来表示栈顶元素在数组中的索引位置。初始时，栈为空，top 设置为 -1。

    private Double[] values;
	private int top;
	public Stack(int size) {
		this.values = new Double[size];
		top = -1;
	}

对于 isEmpty 方法，只需要检查 top 是否为 -1 即可：（注意 autolab 不允许使用中文注释）

    public boolean isEmpty() {
        return top == -1; //  或者 return this.top < 0; 
    }

对于 isFull 方法，需要检查 top 是否等于数组的最后一个索引位置，即 values.length - 1：

    public boolean isFull() {
        return top == values.length - 1;
    }

对于 top 方法，需要返回栈顶元素，如果栈为空则返回 null：

    public Double top() {
        if (isEmpty()) {
            return null;
        }
        return values[top];
    }

对于 push 方法，需要将新元素压入栈顶，如果栈已满则返回 null，否则将元素放入数组并更新 top：

    public Double push(double x) {
        if (isFull()) {
            return null;
        }
        values[++top] = x;
        return x;
    }

对于 pop 方法，需要弹出栈顶元素并返回它，如果栈为空则返回 null：

    public Double pop() {
        if (isEmpty()) {
            return null;
        }
        return values[top--];
    }

最后，对于 displayStack 方法，这个根据个人爱好实现即可，这里提供一种方法：

    public void displayStack() {
        System.out.print("top -->");
		for(int i = this.top; i >= 0; i --)
			System.out.println("\t|\t " + String.format("%, .4f", this.values[i].doubleValue()) + "\t|");
		System.out.println("\t+-----------------------+");
    }

最后将上面的方法整合到 Stack 类中即可，总的来说还是比较简单的。

队列

队列（queue）是只允许在一端进行插入操作，在另一端进行删除操作的线性表，队列的特点是先进先出（First In First Out），简称 FIFO。

允许插入的一端称为队尾（rear），允许删除的一端称为队头(front)。

向队列中插入新的数据元素称为入队。

从队列中删除队头元素称为出队。

和链表相比，队列更像是排队买票，先来的人先买到票，后来的只能在后面排队等待。

fengmian6.3.webp

但是队列的实现相对复杂一些，因为队列的插入和删除操作分别在两端进行，如果使用普通的数组来实现队列，可能会出现数组前端有空闲空间但无法利用的情况。

我们可以利用一种思路：

当项目排队时，后索引会向前移动
当项目出队时，前索引也会向前移动一个元素

这样就将数组变成了循环数组（circular array），即当后索引到达数组末尾时，如果前索引不在数组起始位置，则可以将后索引重新指向数组起始位置，从而利用前端的空闲空间。

fengmian6.4.webp

实现方法

与栈类似，队列可以用数组来实现队列。

队列的基本方法也只有两个，分别为入队（enqueue）元素和出队（dequeue）。

我们来看题目Lab4 题目如下：

fengmian6.5.jpg

队列 UML 图

method

public Queue(int size)
- Creates an empty queue whose capacity is size（构造方法，初始化队列，参数 size 指定队列的大小。）
public boolean isEmpty()
- Returns true if the queue is empty and false otherwise （判断队列是否为空）
public boolean isFull()
- Returns true if the queue is full and false otherwise（判断队列是否已满）
public Double enqueue(double x)
- Adds a new element with value x to the rear of the queue （将新元素 x 插入队尾）
- Returns the new element if the operation is successful and null otherwise （如果操作成功则返回新元素，否则返回 null）
public Double dequeue()
- Removes and returns the front element of the queue （弹出队头元素并返回该元素）
- Returns null if the operation fails （如果操作失败则返回 null）
public void displayQueue()

老师给的模板，在此基础上进行实现：

public class Queue {


	/*YOUR CODE HERE*/
	
	
	public static void main(String[] args) {
		Queue myQueue = new Queue(4);
		System.out.println(myQueue.isEmpty());
		myQueue.enqueue(-2);
		myQueue.enqueue(3);
		myQueue.enqueue(1);
		System.out.println("The queue has 3 items: -2, 3, 1");
		myQueue.displayQueue();
		myQueue.enqueue(8);
		myQueue.enqueue(6);
		System.out.println("The queue has 4 items: -2, 3, 1, 8");
		System.out.println(myQueue.isFull());
		myQueue.displayQueue();		
		myQueue.dequeue();
		myQueue.dequeue();
		System.out.println("The queue has 2 items: 1, 8");
		myQueue.displayQueue();
		myQueue.dequeue();
		myQueue.dequeue();
		myQueue.dequeue();
		System.out.println("The queue is empty:");
		myQueue.displayQueue();

	}
}

我们定义一个 integer 类型数组 values 来存储队列中的元素，两个整型变量 front 和 rear 分别表示队头和队尾在数组中的索引位置。初始时，队列为空，front 设置为 0， rear 设置为 -1。此外还需要一个整型变量 counter 来记录队列的当前大小。

    private Integer[] values;
	private int front, rear, counter;

	public CircularDeque(int size) {
		values = new Integer[size];
		front = 0;
		counter = 0;
		rear = -1;
	}

对于 isEmpty 方法，只需要检查 counter 是否为 0 即可：

    public boolean isEmpty() {
        return counter == 0;
    }

对于 isFull 方法，需要检查 counter 是否等于数组的长度：

    public boolean isFull() {
        return counter == values.length;
    }

对于 enqueue 方法，需要将新元素插入队尾，如果队列已满则返回 null，否则将元素放入数组并更新 rear 和 counter：

    public Integer enqueue(double x) {
        if (isFull()) {
            return null;
        }
        rear = (rear + 1) % values.length; //这一步是实现循环队列的关键，当 rear 到达数组末尾时，重新指向数组起始位置
        values[rear] = x;
        counter++;
        return x;
    }

对于 dequeue 方法，需要弹出队头元素并返回它，如果队列为空则返回 null：

    public Integer dequeue() {
        if (isEmpty()) {
            return null;
        }
        Integer value = values[front];
        front = (front + 1) % values.length; // 同样实现循环队列
        counter--;
        return value;
    }

最后，对于 displayQueue 方法，这个根据个人爱好实现即可，这里依旧提供一种方法：

    public void displayQueue() {
        if (isEmpty()) {
			System.out.println("Empty queue!");
			return;
		}

		System.out.print("front-> ");
		for (int i = front; i <= rear; i++) {
			if (i != front)
				System.out.print("\t");
			if (i == values.length) { 
				i = 0;
			} else {
				System.out.printf("|\t%7.4f        |", values[i]);
				if (i != values.length - 1)
					System.out.print("\n"); 
			}
		}
		System.out.println("<-rear"); 
	}

最后将上面的方法整合到 Queue 类中即可，有了链表的基础，实现起来还是不难的。

本文当然不会只是介绍实现方法，有请 assignment 登场。

链表、栈、队列的进阶

链表的进阶

定义以下三个方法：

removeNodes
removeDuplicates
reverseList

其中

public int removeNodes(double x)
- Removes all the elements from a linked list that have value x. (从链表中删除所有值为 x 的元素)
- Returns the number of occurrences of x. (返回 x 出现的次数)
public void removeDuplicates()
- Remove duplicates from sorted list (you may assume that the node values in the list are in non-decremental order). (从排序链表中删除重复元素（你可以假设链表中的节点值是非递减顺序的）)
- Removes all nodes that have duplicate values, leaving only nodes with distinct values. (删除所有具有重复值的节点，只保留具有不同值的节点)
- Your implementation should finish the removing with SINGLE traversal of the whole list, which means you cannot simply invoke the removeNodes method for removing the duplicates. (你的实现应该在对整个列表进行单次遍历的情况下完成删除，这意味着你不能简单地调用 removeNodes 方法来删除重复项)
public void reverseList()
- Reverse the linked list WITHOUT using extra space. (反转链表不使用额外空间)
- Hint: Reverse the linked list can be performed by modifying the “next” pointer of current node from the original next node to its previous node. (提示：反转链表可以通过将当前节点的“下一个”指针从原始下一个节点修改为其前一个节点来执行)

这是老师给的模板，在此基础上进行实现：

public class List {

    private Node head;

    public List() {
        this.head = null;
    }

    public boolean isEmpty() {
        return this.head == null;
    }

    public Node insertNode(int index, double x) {
        if (index < 0)
            return null;
        int currIndex = 1;
        Node currNode = this.head;
        while (currNode != null && index > currIndex) {
            currNode = currNode.getNext();
            currIndex++;
        }
        if (index > 0 && currNode == null)
            return null;

        Node newNode = new Node(x);
        if (index == 0) {
            newNode.setNext(this.head);
            this.head = newNode;
        } else {
            newNode.setNext(currNode.getNext());
            currNode.setNext(newNode);
        }
        return newNode;
    }

    public Node findNode(double x) {
        for (Node currNode = head; currNode != null; currNode = currNode.getNext())
            if (currNode.getData() == x)
                return currNode;
        return null;
    }

    public Node removeNode(double x) {
        if (head == null)
            return null;
        Node currNode = head;
        if (head.getData() == x) {
            this.head = head.getNext();
            return currNode;
        }
        for (; currNode.getNext() != null; currNode = currNode.getNext())
            if (currNode.getNext().getData() == x) {
                Node matchNode = currNode.getNext();
                currNode.setNext(matchNode.getNext());
                return matchNode;
            }
        return null;
    }

    public void displayList() {
        Node currNode = head;
        if (currNode != null) {
            System.out.print(currNode.getData());
            for (currNode = currNode.getNext(); currNode != null; currNode = currNode.getNext()) {
                System.out.print(" -> " + currNode.getData());
            }
        }
        System.out.println();
    }

    public void removeDuplicates() {
        /*YOUR CODE HERE*/
    }

    public void reverseList() {
        /*YOUR CODE HERE*/
    }

    public int removeNodes(double x) {
        /*YOUR CODE HERE*/
    }

    public static void main(String[] args) {
        /*YOUR CODE HERE*/
    }
}

public class Node {
	private double data;
	private Node next;
	
	public Node(double data) {
		this.data = data;
		this.next = null;
	}
	
	public double getData() {
		return this.data;
	}
	
	public Node getNext() {
		return this.next;
	}
	
	public void setNext(Node next) {
		this.next = next;
	}

}

对于 removeNodes 方法，我们可以遍历链表，检查每个节点的值是否等于 x，如果是，则将该节点从链表中删除，并计数器加一。最后返回计数器的值：

    public int removeNodes(double x) {
        if (head == null)
			return null;
		Node currNode = head;
		if (head.getData() == x) {
			this.head = head.getNext();
			return currNode;
		}
		for (; currNode.getNext() != null; currNode = currNode.getNext())
			if (currNode.getNext().getData() == x) {
				Node matchNode = currNode.getNext();
				currNode.setNext(matchNode.getNext());
				return matchNode;
			}
		return null;
	}

对于 removeDuplicates 方法，由于链表是排序的（这是此题关键），我们可以使用了一个哑节点（dummy node）来简化边界情况的处理。pastNode 用于跟踪当前节点的前一个节点，currNode 用于遍历链表。当发现重复节点时，hasDuplicate 标志被设置为 true，直到遇到不同的值时，根据 hasDuplicate 的状态决定是否删除重复节点。

    public void removeDuplicates() {

		if (head == null) {
			return;
		} // define head and second node is null
		Node dummy = new Node(0);
		dummy.setNext(head);
		Node pastNode = dummy;
		Node currNode = head;
		boolean hasDuplicate = false;

		while (currNode != null) {// condition: when head is not null return null
			Node nextNode = currNode.getNext();
			if (nextNode != null && currNode.getData() == nextNode.getData()) {
				hasDuplicate = true;
				currNode = nextNode;
			} else {
				if (hasDuplicate) {
					pastNode.setNext(nextNode);
					hasDuplicate = false;
				} else { 
					pastNode = currNode;
				}
				currNode = nextNode;
			}
		}
		head = dummy.getNext();
	}

对于 reverseList 方法，我们可以使用三个指针来反转链表：pastNode 指向前一个节点，currNode 指向当前节点，nextNode 指向下一个节点。在遍历链表时，我们将当前节点的 next 指针指向前一个节点，然后更新指针以继续遍历。最后，将头节点更新为 prevNode，即新的头节点。

    public void reverseList() {
        Node currNode = head;
		Node pastNode = null;
		while (currNode != null) {
			Node nextNode = currNode.getNext(); 
			currNode.setNext(pastNode);
			pastNode = currNode;
			currNode = nextNode;
		}
		head = pastNode;
    }

这个方法也许不好想，但理解了其原理后实现起来还是比较简单的。核心代码就只有三行。

接着来看栈的进阶。

栈的进阶

只需要写一个 computePostfix 静态方法：

public static int computePostfix(String postfix)
- postfix is a string representing a valid postfix expression which contains only digits and ‘+’, ‘-’, ‘*’, ‘/’ operators, separated by ‘,’. (后缀表达式是一个字符串，表示一个有效的后缀表达式，只包含数字和‘+’，‘-’，‘*’，‘/’运算符，以‘，’分隔)
- You can assume the length of postfix will not exceed 50. (你可以假设后缀表达式的长度不会超过 50)
- Returns the evaluation result. (返回计算结果)
Consider the postfix expression evaluation algorithm introduced in Lec3:
- If the element is an operand, push it to stack. (如果元素是操作数，则将其压入栈中)
- If the element is an operator O, pop twice and get A and B respectively. Calculate BOA and push it back to stack. (如果元素是运算符 O，则弹出两次，分别获取 A 和 B。计算 BOA 并将其压回栈中)
- When the expression is ended, the value in the stack is the final answer. (当表达式结束时，栈中的值即为最终答案)

这个考验的是对栈的理解和应用能力。以及学习能力。老师给的模板如下：

public class Stack {
	private Integer[] values;
	private int top;
	public Stack(int size) {
		this.values = new Integer[size];
		top = -1;
	}
	public boolean isEmpty() {
		return this.top < 0;
	}
	public boolean isFull() {
		return this.top == this.values.length - 1;
	}
	public Integer top() {
		if(top < 0)
			return null;
		return this.values[top];
	}
	public Integer push(String x) {
		if(isFull())
			return null;
		this.values[++top] = Integer.valueOf(x);
		return top();
	}
	public Integer push(Integer x) {
		if(isFull())
			return null;
		this.values[++top] = x;
		return top();
	}
	public Integer pop() {
		if(top < 0)
			return null;
		return this.values[top --];
	}
	public void displayStack() {
		System.out.print("top -->");
		for(int i = this.top; i >= 0; i --)
			System.out.println("\t|\t " + this.values[i].intValue() + "\t|");
		System.out.println("\t+---------------+");
	}
	public static int computePostfix(String postfix) {
		/*YOUR CODE HERE*/
	}
	public static void main(String[] args) {
		/*YOUR CODE HERE*/
		
	}

}

首先得使用 split 函数按分隔符分割字符串

参考这个链接：

Java String split()

把这个学会，剩下的就是 switch 函数来判断是数字还是符号，然后进行相应的操作即可（注意题目要求的操作顺序）：

    public static int computePostfix(String postfix) {
		Stack stack = new Stack(50);
		String[] result = postfix.split(",");
		for (int count = 0; count < result.length; count++) {
			int answer = 0;
			if (result[count].equals("+") || result[count].equals("-") || result[count].equals("*")
					|| result[count].equals("/")) {
				int right = stack.pop();
				int left = stack.pop();
				switch (result[count]) {
					case "+":
						answer = left + right;
						break;
					case "-":
						answer = left - right;
						break;
					case "*":
						answer = left * right;
						break;
					case "/":
						answer = left / right;
						break;
				}
				stack.push(answer);
			} else {
				stack.push(result[count]);
			}
		}
		return stack.pop(); 
	}

这道题算是三道题里面最简单的了，最后就是队列了。

队列的进阶

之前介绍了循环队列的实现方法，这里则需要实现一个双端队列（Deque，Double-Ended Queue），需要允许在队列的两端进行插入和删除操作。

fengmian6.6.webp

CircularDeque(int size) Initializes the deque with a maximum size of size. (使用最大大小为 size 初始化双端队列)
Integer insertFront() Adds an item at the front of Deque. Returns this item if the operation is successful, or Null otherwise. (在队列前端插入一个元素。如果操作成功，返回该元素，否则返回 Null。)
Integer insertLast() Adds an item at the rear of Deque. Returns this item if the operation is successful, or Null otherwise. (在队列后端插入一个元素。如果操作成功，返回该元素，否则返回 Null。)
Integer deleteFront() Deletes an item from the front of Deque. Returns this item if the operation is successful, or Null otherwise. (从队列前端删除一个元素。如果操作成功，返回该元素，否则返回 Null。)
Integer deleteLast() Deletes an item from the rear of Deque. Returns this item if the operation is successful, or Null otherwise. (从队列后端删除一个元素。如果操作成功，返回该元素，否则返回 Null。)
boolean isEmpty() Returns true if the deque is empty, or false otherwise. (如果双端队列为空，返回 true，否则返回 false。)
boolean isFull() Returns true if the deque is full, or false otherwise. (如果双端队列已满，返回 true，否则返回 false。)
Void displayCircularDeque(). (显示双端队列中的所有元素)

老师给的模板如下：


public class CircularDeque {
	private Integer[] values;
	private int front, rear, counter;
	
	public CircularDeque(int size) {
		/*YOUR CODE HERE*/
	}

	public boolean isEmpty() {
		/*YOUR CODE HERE*/
	}

	public boolean isFull() {
		/*YOUR CODE HERE*/
	}

	public Integer insertFront(int x) {
		/*YOUR CODE HERE*/
	}

	public Integer deleteFront() {
		/*YOUR CODE HERE*/
	}


	public Integer insertLast(int x) {
		/*YOUR CODE HERE*/
	}

	public Integer deleteLast() {
		/*YOUR CODE HERE*/
	}

	public void displayCircularDeque() {
		/*YOUR CODE HERE*/
	}
	
	public static void main(String[] args) {
		/*YOUR CODE HERE*/

	}

}

与之前实现的循环队列类似，我们需要维护一个数组 values 来存储双端队列的元素，两个指针 front 和 rear 分别指向队列的前端和后端，以及一个计数器 counter 来记录当前队列的大小。

    public CircularDeque(int size) {
		values = new Integer[size];
		front = 0;
		counter = 0;
		rear = -1;
	}

对于 isEmpty 和 isFull 方法，与之前的实现类似：

    public boolean isEmpty() {
        return counter == 0;
    }

    public boolean isFull() {
        return counter == values.length;
    }

对于 insertFront 方法，我们需要在队列前端插入一个元素，如果队列已满则返回 null，否则将元素放入数组并更新 front 和 counter：

    public Integer insertFront(int x) {
        if (isFull()) {
            return null;
        } else {
            int temp = values[rear];
            front = (front - 1 + values.length) % values.length; //这一步和上文稍有出入
            values[front] = x;
            counter--;
            return temp;
        }
    }

解释代码：temp 用于存储当前队列后端的元素值，然后将 front 指针向前移动一个位置，并将新元素插入到 front 指向的位置。最后返回原后端元素的值。

对于 deleteFront 方法，我们需要从队列前端删除一个元素，如果队列为空则返回 null，否则将元素从数组中删除并更新 front 和 counter：

    public Integer deleteFront() {
		if (isEmpty()) {
			return null;
		} else {
			int temp = values[rear]; 
			front = (front + 1) % values.length;
			counter--;
			return temp;
		}
	}

与此类似，insertLast 和 deleteLast 方法分别在队列后端进行插入和删除操作：

    public Integer insertLast(int x) {
        if (isFull()) {
            return null;
        } else {
            rear = (rear + 1) % values.length;
            values[rear] = x;
            counter++;
            return x;
        }
    }

    public Integer deleteLast() {
        if (isEmpty()) {
            return null;
        } else {
            int temp = values[rear];
            rear = (rear - 1 + values.length) % values.length;
            counter--;
            return temp;
        }
    }

至此，双端队列的基本操作已经实现。至于 displayCircularDeque 方法，则可以参考或直接使用上文给的例子即可。

那么本文就介绍到这里，链表、栈、队列是数据结构中非常基础且重要的部分，掌握它们的实现方法和应用场景对于编程能力的提升非常有帮助。希望本文能对您有所帮助，祝您学习愉快！

这是我目前写过最长的一篇文章了，虽然不会有很多人看 QAQ，也算是我对所学知识的一次复习吧，本文所有题目全部是英文，为了严谨我照搬一遍，并加上我的翻译，如果有错误欢迎指正，我收到后会及时更正~

【学习笔记】计算机组成原理前三讲核心知识点

Wed, 01 Oct 2025 16:42:12 GMT

计算机组成原理（Computer Organisation） 是计算机科学与技术专业的核心课程之一，它不仅仅是为了让学生了解计算机硬件的工作原理，更是为了培养学生的系统思维和解决问题的能力。通过学习这门课，可以了解现代计算机是如何工作的。

这门课要求我们系所有人到大礼堂共同听课，Lab 课则由四位 TA 老师负责，老师们讲的很快，因此想学好这门课不光要按时上课，课下也要整理总结。

Lecture 1 什么是计算机

计算机定义

一台现代计算机是一种电子的、数字的、通用的计算设备，它自动遵循一系列逐步的指令来解决问题。

计算机所遵循的这一系列逐步的指令也被称为计算机程序。

图灵机

图灵机（Turing Machine） 是由英国数学家艾伦·图灵开发的一种假设装置，它是所有计算机的抽象模型。一个图灵机由

一个分成单元格的磁带
一个移动的读写头
一个存储图灵机状态的寄存器
一个有限的指令表

详细介绍

Turing Machine Simulator（图灵机模拟器）

通用图灵机

通用图灵机（Universal Turing Machine），能够模拟其他所有的图灵机。

输入：数据 + 计算描述（图灵机）
它是可编程的，因此它是一台计算机，指令是输入数据的一部分
计算机就是一台通用图灵机

冯·诺依曼体系结构

冯·诺依曼体系结构（Von Neumann Architecture），也称为存储程序架构，数据和程序都存储在内存中

存储程序架构

一个中央处理器（CPU）
- 控制单元
- 算术逻辑单元（ALU）
- 寄存器
主存
I/O 系统

主存储器和 CPU 之间的一条单一路径，称为冯·诺依曼瓶颈。

wenzhang5.2.jpeg

冯·诺依曼体系结构

冯·诺依曼执行周期

冯·诺依曼执行周期（Von Neumann Execution Cycle） 也称为获取-解码-执行周期，分成四步

控制单元从内存中获取下一条指令
指令被解码成 ALU 能够理解的语言
数据操作数从内存中获取到 CPU 内部的寄存器中
ALU 执行指令并将结果放入寄存器或内存中

Von Neumann Machine Simulator（冯·诺依曼机器模拟机）

冯·诺依曼瓶颈

冯·诺依曼瓶颈（The Von Neumann Bottleneck）

CPU 和内存是分开的
所有数据和代码都在内存中
CPU 通常比内存快
CPU 被迫等待需要的数据被传输到或从内存中

抽象

抽象（abstraction） 是通过识别一组个体中的共同特征，或忽略这些个体的时空方面来形成概念的过程，抽象的本质是在特定情境中保留相关信息，并忘记在该情境中无关紧要的信息。

从抽象到具体

一份出版物 2. 一份报纸 3. 《旧金山纪事报》 4. 《纪事报》5 月 18 日那一期 5. 我那本《纪事报》5 月 18 日那一期

现代现代计算系统的抽象层次

用户级别：应用程序如 qq.exe
高级语言：C、Java、C++
汇编语言
操作系统
机器语言：指令集 A
控制级别：微码或硬接线
数字逻辑：电路、门

硬件与软件

硬件能做的，软件也能做，反之亦然。硬件实现更快但固定，软件实现更灵活但更慢。

Lecture 2 比特：数据表示与操作

计算机是处理数字的机器，输入数字，对数字进行操作，输出也是数字。

二进制数：比特

计算机是二进制机器：只有 0 和 1。BIT = Binary digITs; 1 bit: 0 or 1（比特 = 二进制数字；1 比特：0 或 1），1 字节 = 8 比特（1 Byte = 8 bits），一个字（word） 是作为单元处理的固定大小数据块

数值数据表示

Unsigned integers（无符号整数）
Signed integers（有符号整数）
- Sign-magnitude（原码）
- 1’s complement（反码）
- 2’s complement（补码）
Real number representation（实数表示）
Floating-point numbers（浮点数）

无符号整数表示

无符号整数表示（Unsigned Integer Representation）是计算机中以二进制形式表示非负整数的方法，其所有二进制位均为数值位，无符号位，取值范围为 0 到 2n−12^n-12n−1（n 为位数）

有符号整数表示

有符号整数表示（Signed Integer Representation）最左侧的比特位（最高有效位）用作符号位。按照惯例，符号位为 0 表示正数，为 1 则表示负数。原码：其余比特位表示数值大小不足七位要补足七位；反码：在原码基础上，正数不变，负数符号位不变，其数值位的的相反 1 变为 0，0 变为 1；补码：需先通过按位取反运算（即反码）将所有位反转或“翻转”；然后在结果值上加 1，并忽略对 0 取补码时产生的溢出。

取一个正数，其原码，反码，补码完全相同。例如 25，二进制为：11001；原码：00011001（符号位 0 + 数值位 0011001）；反码：00011001；补码：00011001。

例如-25，其原码：10011001；反码：11100110（符号位 1 + 取反后的数值位 1100110）；补码：11100110+1=11100111。

数值	原码	反码	补码
25	00011001	00011001	00011001
-25	10011001	11100110	11100111

数字转换

主要对数字进行 2 进制和 16 进制转换，因较为基础，这里不多赘述。

实数表示

正二进制小数（Positive binary fractions (fixed point)）这里以三个例子来进行解释，如下：

问题一问题二问题三

(6.625)10=(?)2(6.625)_{10} = ( ? )_2(6.625)10=(?)2

$(0.1001001)_2 = (?)_{10}$

将0.9近似表示为二进制小数（使用8位数）

对这三个问题进行解答（点击按钮显示对应答案）

问题一问题二问题三

首先看整数位，对其进行 2 进制转换。本题整数位为 6，(6)10=(110)2(6)_{10}=(110)_2(6)10=(110)2，接着看小数部分，本题为 0.625。采取乘 2 取整法

0.625×2=1.250.625 \times 2 = 1.250.625×2=1.25，取整数部分 1 ,剩余小数部分 0.25
0.25×2=0.50.25 \times 2 = 0.50.25×2=0.5，取整数部分 0（剩余小数部分0.50.50.5）
0.5×2=1.00.5 \times 2 = 1.00.5×2=1.0，取整数部分 1 将整数部分从上往下排列，小数部分的二进制为：101。

因此

$(6.625)_{10} = (110.101)_2$

对于(0.1001001)2(0.1001001)_2(0.1001001)2：

小数点后第 1 位：1×2−1=0.51 \times 2^{-1} = 0.51×2−1=0.5
第 4 位：1×2−4=0.06251 \times 2^{-4} = 0.06251×2−4=0.0625
第 7 位：1×2−7=0.00781251 \times 2^{-7} = 0.00781251×2−7=0.0078125

其余位为 0，求和：

0.5+0.0625+0.0078125=0.5703125

因此，

$(0.1001001)_2 = (0.5703125)_{10}$

步骤如下：

0.9×2=1.80.9 \times 2 = 1.80.9×2=1.8 → 取整 1（第 1 位，记为b1=1b_1=1b1=1），剩余小数0.80.80.8
0.8×2=1.60.8 \times 2 = 1.60.8×2=1.6 → 取整 1（第 2 位，b2=1b_2=1b2=1），剩余小数0.60.60.6
0.6×2=1.20.6 \times 2 = 1.20.6×2=1.2 → 取整 1（第 3 位，b3=1b_3=1b3=1），剩余小数0.20.20.2
0.2×2=0.40.2 \times 2 = 0.40.2×2=0.4 → 取整 0（第 4 位，b4=0b_4=0b4=0），剩余小数0.40.40.4
0.4×2=0.80.4 \times 2 = 0.80.4×2=0.8 → 取整 0（第 5 位，b5=0b_5=0b5=0），剩余小数0.80.80.8（开始循环）
0.8×2=1.60.8 \times 2 = 1.60.8×2=1.6 → 取整 1（第 6 位，b6=1b_6=1b6=1），剩余小数0.60.60.6
0.6×2=1.20.6 \times 2 = 1.20.6×2=1.2 → 取整 1（第 7 位，b7=1b_7=1b7=1），剩余小数0.20.20.2
0.2×2=0.40.2 \times 2 = 0.40.2×2=0.4 → 取整 0（第 8 位，b8=0b_8=0b8=0）

凑齐 8 位后，二进制小数为0.1110011020.11100110_20.111001102。

因此，

$0.9_{10}$的 8 位二进制近似为$0.11100110_2$

浮点数

浮点（Floating point） 指数字的基数点可以"浮动"，即它可以相对于数字的有效数字放置在任何位置。

半/单精度浮点数

半精度浮点数是一种使用 16 位（2 字节）存储的浮点数格式，主要用于对存储和计算效率要求较高的场景，如深度学习和图形处理。

组成：

符号位：1 位，表示数值的正负
指数部分：5 位，采用偏移表示法，用于表示数值的大小
尾数部分：10 位，表示有效数字，包含一个隐含的 1（对于规范化数）

与半精度浮点数类似，单精度浮点数为 32 位，1 位作为符号位，8 位作为指数部分；23 位表示尾数部分

以下是几道题目

问题一问题二

0.011110000000000=(?)100.011110000000000 = ( ? )_{10}0.011110000000000=(?)10

12.735=(?)212.735 = (?)_{2}12.735=(?)2

解答如下（点击按钮显示对应答案）

问题一问题二

符号位：0。 指数位：接下来的 5 位是 01111 吗，将其转为十进制位 15，半精度的指数偏移量为 15（25−1−12^{5-1}-125−1−1）实际指数=15-15=0。 尾数为：0000000000.半精度尾数采用隐含 “1” 的规格化形式，即尾数为 1.M（M 是尾数位），这里 M 全为 0，所以尾数是 1.0。

代入半精度公式计算

(−1)(符号位)×(1.M)×2E(-1) ^ (符号位) \times (1.M) \times 2^E(−1)(符号位)×(1.M)×2E

带入具体数值得到

(−1)0×1.0×20=1×1×1=1(-1)^0 \times 1.0 \times 2^0=1 \times 1 \times 1=1(−1)0×1.0×20=1×1×1=1

符号位：12.375 是正数，符号位为 0。 指数位：单精度的指数偏移量为 127（因为 8 位指数的偏移量公式：28−1−1=1272^{8-1} - 1 = 12728−1−1=127）。实际指数是 3，因此指数字段的值= 实际指数 + 偏移量 =3 + 127 = 130。130 转成 8 位二进制：130 = 128 + 2 → 10000010。 尾数位：规格化尾数是 1.100011，去掉隐含的 “1”，剩下小数部分 100011。尾数位需要补够 23 位，因此在 100011 后补 17 个 0，得到 10001100000000000000000。

将这三部分组合：

01000001010001100000000000000000

非数值数据表示

这一部分内容不是很重要，因此放一张 ASCII 码，可自行对照

ASCII.png

ASCII码对照表

Lecture 3 布尔代数：从比特到逻辑

计算机通过比特（二进制位）表示信息。一个比特具有两种可能的值，即0和1。比特可用于表示真值——真与假。因此比特运算对应着布尔代数中的逻辑运算。

布尔变量与运算符

布尔变量是只能取两个值的变量：真/假；或1/0

布尔运算符

AND（A AND B , AB , A∧BA \wedge BA∧B）
OR (A OR B , A+B , A∨BA \vee BA∨B)
NOT （ NOT A , A’ , ¬A\neg A¬A）

布尔函数

函数是一种关系，能够唯一地将一个集合的成员与另一个集合的成员相关联。

布尔函数具有

至少一个布尔变量
至少一个布尔运算符
至少一个来自集合{0,1}的输入

其产生的输出也在集合{0,1}之中

布尔运算符优先级

一个布尔函数中可能包含多个布尔运算符。运算优先级规则为：

NOT优先级最高
其次是AND
最后是OR

布尔运算符的真值表

AND OR NOT

AND
A	B	AB
0	0	0
0	1	0
1	0	0
1	1	1

OR
A	B	A+B
0	0	0
0	1	1
1	0	1
1	1	1

NOT
A	$ \overline{A}$
0	1
1	0

布尔恒等式

布尔恒等式(Boolean Identities)，也可以称为布尔代数常用基本法则。由于打成表格太麻烦了，找了张图片

BooleanRules.png

上述所有恒等式都可以通过真值表来证明。为此，你需要使用真值表展示等式两边的所有可能取值。若两者完全一致，则该恒等式成立。

规范形式

表示同一布尔表达式有多种方式。逻辑等价的表达式具有相同的真值表。例如，(X+Y)′=X′Y′(X+Y)^{'} = X^{'}Y^{'}(X+Y)′=X′Y′。为避免混淆，设计者采用标准化或规范形式来表达布尔函数。主要有两种规范形式

积之和(Sum-of-products)
和之积(Product-of-sums)

积之和

来自输入的不同 “乘积” 项被 “相加” 在一起。这也被称为析取范式（Disjunctive Normal Form）。

和之积

来自输入的不同 “和项” 被 “相乘” 在一起。这也被称为合取范式（Conjunctive Normal Form）。

卡诺图

卡诺图（KM 或 K-map）是由莫里斯·卡诺（Maurice Karnaugh，1924 年~）于 1953 年提出的一种简化布尔代数表达式的方法。

K-map1.png

K-map2.png

K-map3.png

K-map4.png

前三节课的知识就结束了，之后是门电路，只学了一部分就国庆放假了（老师看我们听不下去就提前下课了）。门电路部分我尽量在 quiz 之前整理出来。

花了三天时间终于写完了，由于课件全部是英文的，只能一点一点翻译出来 QAQ。有些地方翻译不当请见谅，本人实力实在有限。易造成歧义的关键词后已经加上了原单词，如果存在其他有错误的部分请在评论区指正，我收到后会及时更正~

【学习笔记】递归与链表

Tue, 23 Sep 2025 16:14:41 GMT

数据结构和算法分析（Data Structures and Algorithm Analysis） 的第一节课是回顾之前所学的递归（Recursion），作为导入课的同时还可以简单复习一下 java（这门课所使用语言）。因此第一周的课程和 lab 不算难，以下是 Lab 的具体细节。

Lab 1

题目 1

Read in a positive number and compute its factorial using recursion.
Note that your class should be named “T1”， and should contain
- a main function, which does IO
- and a recursive function, public static int factR(int n), which computes the factorial
You may build you recursion as follows.
- Step, if n>1: factR(n) = n * factR(n-1)
- Base, if n<=1: factR(1) = 1

简单来说就是读入一个正整数并使用递归计算其阶乘，值得注意的是虽然题目说的是正整数，但如果输入负数和零也要进行处理。老师已经给了主要结构：

import java.util.Scanner;
public class T1 {
	public static int factR(int n) {
		/*YOUR CODE HERE*/
	}

	public static void main(String[] args) {
		/*YOUR CODE HERE*/

	    System.out.println(factR(n)); //n is the input from keyboard
	}
}

即当给的数小于等于 1 时返回 1（0 的阶乘为 1），否则就按照阶乘的运算方式递归即可。如下:

import java.util.Scanner;
public class T1 {
	public static int factR(int n) {
		if (n <= 1)
			return 1;
		else
			return n * factR(n - 1);
	}

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		System.out.println(factR(n)); 
		scan.close();
	}
}

不是没有注释，而是因为我写的不严谨。索性全删了，以后不再赘述。

题目 2

Read in and compute the greatest common divisor (GCD) of two natural numbers using recursion.
GCD(x, y) is the greatest natural number which divides both x and y
- GCD(6, 5) = 1
- GCD(6, 9) = 3
- GCD(6, 0) = 6
Note that your class should be named “T2” and should contain
- a main function, which does IO
- and a recursive function, public static int GCD(int x, int y), which computes the GCD of x and y.

老师给的模板：

import java.util.Scanner;
public class T2 {
	public static int GCD(int x, int y) {
		/*YOUR CODE HERE*/
	}

	public static void main(String[] args) {
		/*YOUR CODE HERE*/
	    System.out.println(GCD(x, y)); // x, y are the inputs from keyboard
	}
}

这个题目就很有意思了，计算两个自然数的最大公约数。通常最经典的方法便是欧几里得算法，其步骤为：

用较大的数除以较小的数，取余数。
用较小的数替代较大的数，用余数替代较小的数。
重复上述步骤，直到余数为 0，此时较小的数即为最大公约数。

正常输入的数一大一小，但大数在前面还是小的数在前面就是一个问题。这里引用朋友的方法，我觉得十分巧妙，无论大数在前面还是小的数在前面都能完美解决:

import java.util.Scanner;

public class T2 {
	public static int GCD(int x, int y) {
		if (y == 0)
			return x;
		else {
			return GCD(y, x % y);
		} 
	}

	public static void main(String[] args) {
		Scanner scan1 = new Scanner(System.in);
		Scanner scan2 = new Scanner(System.in);
		int x = scan1.nextInt();
		int y = scan2.nextInt();
		System.out.println(GCD(x, y)); 
		scan1.close();
		scan2.close();
	}
}

题目 3

Output the reverse-order form of an integer. Recursion should be used, and your input should be a positive integer.
For example:
- Input: 2783; output: 3872
- Input: 598; output: 895
- Input: 3; output: 3
Note that your class should be named “EX1” and should contain
- a main function, which does IO
- and a recursive function, public static int reverseForm(int n).

老师给的结构：

import java.util.Scanner;
public class EX1 {
	
	public static int reverseForm(int n) {
		/*YOUR CODE HERE*/
	}
	public static void main(String[] args) {
		/*YOUR CODE HERE*/
		
		System.out.println(reverseForm(n)); //n is the input from keyboard
	}
}

这道题就其实也不算难，要求输出一个整数的逆序形式。比如输入是 123456，那么要求输出就是 654321。其实我之前再 LeetCode 上见过，印象里学 C 的时候老师好像也提到过，不过好像每次都没做出来。。。属于是它认识我我不认识它了 QAQ。

正常思路就是将这个数取 10 的余，得到的数即输出的最高位，将它每次递归都乘 10，以此类推。

我自己写的话出现了很多问题，比如输入的数可能是不同位数，因此递归次数就成了一个比较难解决的问题。

中间问同学的思路得知他们是先得到所给数的位数，即用数学方法中的 log10，取到位数后再进行递归。不过我觉得还是很麻烦，加上当时已经筋疲力尽了，通过 ai 果然得到了更好的方法：

import java.util.Scanner;
public class EX1 {
	public static int reverseForm(int n) {
		if (n < 10) {
			return n;
		} else {
			int i = n % 10;
			int all = n / 10; 
			int digits = (int) Math.log10(all) + 1;
			return i * (int) Math.pow(10, digits) + reverseForm(all);
		}
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt(); 
		System.out.println(reverseForm(n));
		scanner.close();
	}
}

可以看到定义三个整数，i 作为新的最大位数，all 作为下次递归的数据，digits 为数据位数吗，最后返回对应位数的对应 10 次放即可。

题目 4

Output the binary form of a decimal integer. Recursion should be used, and your input should be a String.
For example:
- Input: 27; output: 11011
- Input: 33; output: 100001
- Input: 3; output: 11
Note that your class should be named “EX2” and should contain
- a main function, which does IO
- and a recursive function, public static String binaryForm(int n).

老师给的代码如下

/*Add some comments by yourself*/
import java.util.Scanner;
public class EX2 {
	public static String binaryForm(int n) {
		/*YOUR CODE HERE*/
	}

	public static void main(String[] args) {
	    /*YOUR CODE HERE*/
	    System.out.println(binaryForm(n)); //n is the input from keyboard
	}

}

也就是将一个十进制整数变成二进制形式。还是比较简单的：

import java.util.Scanner;
public class EX2 {
	public static String binaryForm(int n) {
		String a = "";
		if (n == 0)
			return "0";
		if (n == 1)
			return "1";
		if (n % 2 == 0) {// case 1
			a = "0";
			return binaryForm(n / 2) + a;
		} else if (n % 2 == 1) {
			a = "1";
			return binaryForm(n / 2) + a;
		}
		return a;
	}

	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		System.out.println(binaryForm(n)); 
		scan.close();
	}
}

Lab0 到这里就结束了。下面是第二周课的细节

Class 1

所讲内容

（Linked List）

作用： 链表一种基础的数据结构，在平时写程序的时候用的并不多，但在操作系统里面使用的非常多。不管是 RTOS 还是 Linux 等使用非常广泛，所以必须要搞懂链表，链表分为单向链表和双向链表，单向链表很少用，使用最多的还是双向链表。

定义： 链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。

结构：

链表由一系列节点（链表中每一个元素称为节点）组成，每个节点包括两个部分：
- 存储数据元素的数据域
- 存储下一个节点地址的指针域
- 首个节点的地址必须被存储

lianbiao.png

这样，链表的结构使其能够建立起各节点之间的线性关系。

老师上课讲的英文我也听不太懂，接下来就是 Lab 时间

Lab 2

首先看下题目：

Given Node.java, complete List.java with
- all the complete functions defined
- a main function has been given for the class which tests 5 functions:
  - isEmpty
  - insertNode
  - findNode
  - removeNode
  - displayList Submit List.java to iSpace. 也就是通过 Node.java 里面所写的内容，用在 List.java 中，实现 5 个基本功能：1.判断链表是否为空，2.插入节点，3.寻找节点，4.移除节点，5.展示链表。

UML1.png

UML 图

老师给的模板如下：

List.java

public class List {
	/*YOUR CODE HERE*/
	
	public static void main(String[] args) {
		List myList  = new List();
		System.out.println(myList.isEmpty());
		myList.insertNode(0, 1);
		System.out.println("Data of head: " + myList.head.getData());
		myList.displayList();
		myList.insertNode(1, 2);
		myList.displayList();
		myList.insertNode(0, 3);
		myList.displayList();
		myList.insertNode(4, 4);
		myList.displayList();
		myList.insertNode(-4, 5);
		myList.displayList();
		System.out.println(myList.findNode(2).getData());
		myList.removeNode(1);
		myList.displayList();
		myList.removeNode(4);
		myList.displayList();
	}

}

Node.java

public class Node {
	private double data;
	private Node next;
	
	public Node(double data) {
		this.data = data;
		this.next = null;
	}
	
	public double getData() {
		return this.data;
	}
	
	public Node getNext() {
		return this.next;
	}
	
	public void setNext(Node next) {
		this.next = next;
	}
}

创建和初始化链表

先观察 Node.java 里面的参数，是通过类（class）来实现链表的节点，这也是最优的实现方法。可以看到 Node 中 data 是链表节点的数据域，next 是指针域。因为指针域指向链表下一个节点，因此它的数据类型与当前节点一样还是 Node。

接下来就是这个类的构造方法，只需要给它的数据域赋值即可。下面的三个方法是为了满足封装需求而设立的。接下来返回 List.java 研究如何插入节点。根据 UML 图写 get/set 方法就不再说了。

判断节点是否为空

这个相对容易，只需判断头节点（head）是否为空即可

public boolean isEmpty() {
	if (head == null) {
		return true;
	} else {
		return false;
	}
}

插入节点

插入节点需要将前一个指针域的值赋到该节点的地址，而前面提到节点是通过类来表示，因此将插入节点这个类赋到前一个节点。

插入节点方法 insertNode 中传入两个参数，第一个是插入位置（index），第二个是数据。首先判断 index 是否小于 0，返回 null。接着定义一个变量 currIndex（当前索引）初始化为 1，一个变量 currNode（当前节点）初始化为链表的头节点。

接下来尝试定位插入节点的位置，使用 while 循环遍历节点，只要当前节点不为 null，且索引位置比当前位置数大就一直循环，每次循环让当前节点等于下一个节点的地址（使用 Node.java 中的 getNext 方法），同时让当前索引数加 1。

然后创建一个新节点，其数据域为 x（Node 构造方法）。

最后插入这个新节点，判断 index 是否等于 0，0 即为该链表的头节点，使用 setNext 方法，参数即为 head 头节点，让它等于新节点的指针域，让新节点成为头节点；如果不为 0，参数为下一节点的地址，让新节点的指针域为当前节点的指针域，设置当前节点的指针域为新节点即可。代码如下

public Node insertNode(int index, double x) {
	if(index < 0)
		return null;
	int currIndex = 1;
	Node currNode = this.head;
	while(currNode != null && index > currIndex) {
		currNode = currNode.getNext();
		currIndex ++;
	}		
	if(index > 0 && currNode == null)
		return null;
	
	Node newNode = new Node(x);
	if(index == 0) {
		newNode.setNext(this.head);
		this.head = newNode;
	}
	else {
		newNode.setNext(currNode.getNext());
		currNode.setNext(newNode);
	}
	return newNode;
}

寻找节点

这个也比较容易，findNode 会给你一个数据 x，让你从链表中找到一个数据域与其相同的节点。

只需要定义节点变量 currNode 等于头节点，当该节点不为空就一直遍历，再在其中加入判断看它是否与所给数据相同即可：相同就返回，不相同返回就当前节点的指针域。

public Node findNode(double x) {
	Node currNode = head;
	while (currNode != null)		
		if (currNode.getData() == x)
			return currNode;
		else
			currNode = currNode.getNext();
	return currNode;
}

删除节点

这个其实只需要将前节点指针域赋到后面节点的地址，中间的节点会被垃圾收集器（Garbage Collection） 自动回收并不再使用对象所占用的资源。

只是这样会出现特殊情况，即移除节点可能为当前链表的最后节点，因此需设置节点类型变量 lastNode，使其初始化为空。

依旧定义变量 currNode，依旧相同 while 循环。可以使用嵌套 if 语句：在当前节点不为空的情况下，如果当前节点数据等于所给数据 x，那么使头节点等于当前节点的下一节点，否则使 lastNode 的指针域等于当前节点的指针域。

如果当前节点为空，则使 lastNode 等于 currNode，让currNode 等于下个节点的地址，代码如下

public Node removeNode(double x) {
	Node currNode = head;
	Node lastNode = null;
	while (currNode != null) {
		if (currNode.getData() == x) {
			if (lastNode == null) {
				head = currNode.getNext();
			} else {
				lastNode.setNext(currNode.getNext());
			}
			return currNode;
		} else {
			lastNode=currNode;
			currNode = currNode.getNext();				
		}
	}
	return null;
}

展示节点

这个只需要按照 sample 写就好

依旧定义 currNode，依旧 while 循环，只要节点不为空就一直打印 “->” 最后把换行打出来即可

public void displayList() {
	Node currNode = head; 
	while (currNode != null) { 
		System.out.print(currNode.getData());
		if (currNode.getNext() != null)
			System.out.print(" -> ");
		currNode = currNode.getNext(); 
	}
	System.out.println();//c4
}

将上述代码添加到 List.java 中即可。

数学建模经历以及获奖建议

Wed, 10 Sep 2025 17:14:41 GMT

2025 年的全国大学生数学建模比赛（CUMCM）已经落下帷幕。以下是博主的比赛经历。

比赛规则

三人为一对，分别担任建模手，编程手和论文手
选择一组题目，解决对应问题并上传。通常包含一篇论文（PDF 格式）以及支撑材料（压缩文件）

数学建模竞赛的基本流程

由建模手将问题转化为数学模型
由编程手根据数学模型编写程序代码
将数据输入程序，得到结果
由论文手将问题、数学模型、结果整理成论文
论文与程序代码构成问题最终的解决方案

这里引用小嗷犬的图片来解释

jianmo1.png

jianmo2.png

数学建模竞赛详细介绍

全国大学生数学建模竞赛，以下简称国赛，是中国规模最大的数学建模竞赛，也是世界上规模最大的数学建模竞赛。参加比赛不仅可以能增长见识，如果能获奖，则该奖项可以被写在履历中来丰富自己的学术经历。

以今年（2025）国赛广东赛区为例：

比赛时间：九月四号下午六点开赛，到九月七号晚上八点截止
比赛时长：3 天
报名费用：100 元 / 人
比赛语言：中文
比赛题目：ABCDE 五组题目，本科生只能选择 ABC 组题目，专科生可以选择 ABCDE 题目
比赛奖项：
- 国家级：一等奖、二等奖
- 省级：一等奖、二等奖、三等奖
- 赞助商特别奖项

赛前准备

选择队友

以博主自身经历来看，数学建模比赛的特点是时间紧、任务重，因此选择队友是非常重要的一步。一个好的队友能在关键时刻起到决定性作用。

团队分工不一定要十分明确，例如在这次比赛中博主是编程手，但论文是博主使用 latex 生成的。论文手是博主朋友，他只需将对应内容发给博主即可，而他也帮助博主编写相关程序。建模手则是位女生，她在最后的时候帮助博主寻找合适图片，文献来帮博主分担工作。由此可见，模型构建与算法实现是紧密结合的。三个位置相互帮助才能产出一个好的作品。

能否完赛，取决于建模手和编程手，建模手和编程手决定了团队的下限；能否拿奖，取决于论文手，论文手决定了团队的上限。因为评委老师一开始只能看到你的论文。因此论文的美观程度对于评委影响是十分巨大的。

知识储备

因为博主是论文手，因此本文主要从论文手角度分析其所需要的的知识储备：

论文排版：推荐使用LaTeX
论文参考文献：BibTeX等

另外为新手推荐数模资料

工具准备

由于比赛要求论文格式为 pdf，因此推荐使用 latex 编辑器TeXstuio，网上有不少安装教程，例如TeXstudio 安装，如果觉得安装时间过长的话（大约 40 分钟），那么可以考虑使用 Overleaf来写论文， Overleaf是一个支持多人同时编辑的在线 LaTeX 编辑器。

利用 LaTeX 运行后直接生成 pdf 文件，因此不必再将其他格式文件转成 pdf 格式。

LaTex：需要一定的基础，若想要速成则推荐一个非常快速的 Latex 入门教程
LaTex 论文模板：推荐全国大学生数学建模竞赛论文模板
GeoGebra：几何图、函数图等
LaTeX 公式编辑器：LaTeX 公式编辑器 1，或者 LaTeX 公式编辑器 2

本人经历

从找队友说起，博主和朋友打算参加比赛。于是在校园墙发布帖子，很快就有人来加微信询问。由于我俩都是计算机专业的，所以最后选择了应用数学专业的同学，她来负责建模。

由于报名人数太多，学校要求队内没有参加过美赛（美国大学生数学建模竞赛）并且拿 S 奖以上同学的队伍进行模拟比赛。于是博主便开始找关于国赛论文的资料，找到了小嗷犬发布相关模板（做博客的想法也是从那时候开始的）。后面比赛是在家里面做完的，大概看了一下，绝大多数队伍都通过了初选。

在后面就是学雅思，学车了。其实没怎么学相关知识。只是提前回学校看了看。

比赛情况

我们选择的是 A 组题《烟幕干扰弹的投放策略》。一共是有 5 道问题。第一问就是纯物理模型计算，我查找相关论文的时候看到了这个

fengmian3.1.png

要知道当时比赛也就开始了 2 小时，点进去发现内容和 A 题完全一致的时候我人直接懵了。

然后建模手开始计算，最后算出答案发现和其他人答案不一样（其他人答案哪来的你别问），就开始改，改了半天还是这个答案。于是启动 GPT-5 最新模型，发现思路没有问题。但答案就是出不来。最后搞到 12 点也没出来，女生说太晚了先睡觉吧。我俩也怕女生熬太久身体扛不住，就只能先宿舍睡觉了。因为三点没有大巴车，我和我朋友又花了 20 分钟走回宿舍。收拾完躺到床上就 2 点了，第一天的建模以信心满满开始，以无解失败告终。

第二天起来我先写程序，跑了一上午好不容易跑出来并加到论文中去，但第一题还是出不来正确结果。下午我和我朋友坐机房里面分析，突然看到一组数据不太对，然后我俩就问 AI 为什么思路一样数据不对，得到的答案是重力加速度我们 g 取的 10，别人取的 9.8。。。

那很明显了，初高中的后遗症，经典默认题目会给 g=10m/s^2，这波建模手全责。等第一题搞完第二天都快结束了，然后建模手开始做第二题，这题倒是很快，不过等论文写好已经是凌晨 2 点了，重复昨天的流程。第二天也结束了。

等起来已经是 11 点了，赶紧吃饭。第三天需要把第三问第四问写出来，不然第四天晚上交很可能来不及。第三位算出来六点多，和别人的十一点多差的有点大。建模手直接不会了，问 AI，AI 算的也不是这个，第四问也是如此。就这样一直改，改到 3 点最终确定使用一开始的方案，然后回去休息，等他躺床上已经是 5 点了，天都快亮了。

最后一天我们借助 AI 完成了第五问，把论文的相关内容进行填充，把图片加入文章，找了相关文献，还写了支撑材料。多亏 GPT-5 大人，让我们在 7 点半的时候生成了 MD5 码，并在最后成功上传作品。

全国大学生数学建模比赛
全国大学生 AI 建模比赛

作品信息

我们的作品正文部分共计 23 页，算上附录的代码共 97 页。使用了运动学模型，模拟退火算法，候选策略池和蚁群算法，以及分时分段拼接遮蔽策略。以下是我们论文的部分摘要：

对于问题一，本文建立了导弹 — 真目标 — 烟幕云团的几何相交判据，将题目中的遮蔽判定为云团中心到视线线段的最小距离不超过 10m，同时在有效窗内离散时间、先粗扫后用二分 Brent 法求出进入与离开遮蔽时刻。接着在运动学计算中将导弹视为匀速飞行，干扰弹视为抛体运动再配合全局时间网格评估最小距离并提取最长连续遮蔽段。最终数值结果给出 τin=2.913s、τout =4.348s，对应有效遮蔽时长∆τ =1.435s。

对于问题二，建立 “投放 — 起爆 — 下沉” 的运动学模型，在扫描满足 d2 ≤ 100 的最长连续段作为目标函数的同时，也全局时间网格上预计算导弹与视线。在编码时采用遗传算法并且配合核心操作模块，多次重启以提升收敛稳定性。得到最优投放策略：速度 v ≈ 106.82m/s, 航向 θ ≈ 178.46◦, 起爆点 Rburst≈(17451.9,9.4,1753.2)，投放点 Rdrop≈(17769.90,0.73,1800.00)。

对于问题三，通过优化投放策略，使遮蔽时长最大。我们建立 “导弹恒速直线 — 烟幕云团抛体起爆后下沉” 的运动学模型与 “球 — 视线线段相交” 遮蔽判据，在速度 v = 140m/s、航向 θ = 180◦ 的启发式设定下，采用核心操作模块，最终得出最优遮蔽时长为 6.80s，第一枚投放点与起爆点为 (17800,0,1800) 与 (17310,0,1739.975)，第二枚投放点与起爆点为 (17310,0,1800), 与 (16540,0,1651.775)，第三枚投放点与起爆点 (17030,0,1800) 与 (16190,0,1623.600)。

对于问题四，构建导弹以 300 米每秒匀速运动、无人机沿等高直线飞行、烟幕先做 “自由落体” 运动，起爆后以 3 米每秒下沉的运动学模型，以便让三枚烟幕的并集有效遮蔽时长达到最大。借助点到线段距离以及细时间步积分构建精确评估器，在速度 70 至 140 米每秒、投放与延时 0.1 至 10 秒的可行范围内，运用 “候选策略池 + 蚁群算法” 进行全局寻优，以单机严格遮蔽秒数作为启发，并对当代最优解添加信息素以提高收敛效率，数值结果显示：最优方案的并集有效遮蔽总时长为 11.7 秒。

对于问题五，采用 “分时分段拼接遮蔽” 策略。在构建基于几何逆解的烟幕投放模型之下，设置导弹与真目标之间的线段为爆点。在各种约束条件包括：速度约束 (70–140m/s)、每架无人机投放间隔 (≥1s)、起爆延时 (0.1–10s) 与云团判据 (半径 10m, 起爆后 20s, 下沉 3m/s) 下优化模型。再设计密集起爆时隙网格、竖直高度离散扫描、半秒级双向时间微调，并采用 “遮蔽最少优先” 的二次补位提升总量。最终得出三导弹遮蔽时长分别为 6.9s、6.8s、3.5s，总计 17.2s。

最后整活

一道惊怒的声音响起：“小子，你都做了什么？没有 GPT，我等如何建模？” 只听博主淡然一笑：“很简单，我来建模不就是了”。说罢他的气息不再掩饰，显露而出，建模颠佬！一瞬间，全场又是一寂。众人只听道他口中吟道：

灯火通明建模夜，题组如潮案前叠。

乱麻数据寻规律，模型初构意难决。

迭代数回终有隙，误差如刺心有泪。

挑灯再改星渐淡，不肯轻言方案歇。

初闻建模知路远，仍携纸笔向难前。

三月磨题身似茧，团队同研影如烟。

百算千推心似铁，殚精只为构精尖。

今朝赛场挥毫处，炼数炼模更炼天！

最后，靠着这些经验，第一次参赛拿个省级二等奖是没什么问题的。

科目二没过给我的反思

Sun, 10 Aug 2025 17:14:41 GMT

8 月 8 号考的科目二，可惜没过。按理来说应该是没什么问题的，后来想想，确实是我大意了，考前还是不够细致，临阵时候也不够镇定。

情况

由于学校原因得学习雅思，从 7 月 14 号开始，学到 8 月 3 号结束。科目二的练习是在 7 月 15 号开始，因为一学就是一天所以雅思结课前我是没法报考科目二的，这也给了我接近 20 天的时间练车。

按理来说是没什么问题的，正常情况是学习 7 天然后开始去总校进行 1：1 训练（我平时练习的场地没有 S 弯道，只能去总校练。同时模拟考试流程）。学了 20 天那我自然很有信心。然而发现科目二报名时间很少，并且 8 月 8 号之前的时间全部冲突。没办法只好报这天的。

然后 8 月 3 号当天开始 1：1……最重要的第一天就没法去。第二天是手动挡休息，只有自动挡练习，我又没去成…因此我第一次过流程是 8 月 5 号，印象很深刻，那天我六点半起的床，7 点到分部等车去总部，车上还有练科目三的，他们是半途下车，我第一次去什么也不懂跟着他们就下了车。

我就感觉不太对劲，一打听才知道没坐到站就下车了。没办法又打了个车去的总部，到了一看队伍排出校门了。最后领卡搞了一个小时才进去。进去坐到座位上接着等，因为人很多（其实人相对其他时间段很少了，但还是一个教练带十来个学员还是很多），等到十点多才叫到我。

我远远一看，那捷达岁数可能跟我差不多，车上坐了四个人，不知道是教练为了舒服把座位往后调导致我坐得很挤还是那车本来就小，反正腿伸不开很难受。加上教练和车外一个兄弟相互递烟，还不开窗户搞得车上全是烟味，我们后面三个兄弟吸了俩小时二手烟

完了这教练还直播，让我们打开抖音给他点赞。我一看直播间加上我，加上他管理员老婆一共就 4 个人。更逆天的是他还要我们给他点到一万赞。。。

我们点到一万赞他也不直播了，让我们观摩别人怎么找点位，就这样看到十二点半，实在是热的受不了了，我和旁边兄弟也聊熟了，就去吃了个饭。

一点半的时候就到我了，我就开始第一次练车，一共是四条路线，每条路线跑一次，除了 S 弯道第一次学，其他我没什么问题，唯一小插曲的是倒车入库，就是教练让我比平时都往后多退一点，这就埋下伏笔了。

当时肯定不知道么，觉得已经没什么问题了，再来一次可以直接考了

然后坐在外面开心等第二轮大展身手，教练在里面就再也没消息了。。。

我和我刚认识的兄弟从两点开始等，边等边睡，睡到 4 点起来还是没有消息，旁边女生去了都回来了，我们俩都懵了

就这样继续等，等到五点又让我去，然后跟我说今天没时间了随便挑一条线练一次吧。就这样第一天结束了。

我想这第一天因为我的问题去得晚了，那第二天早点去呗。确实去的早，不过第二天是模拟，就是一个人在车上练，机器给你算分。当时前面项目都没问题，就是半坡距离把握不准，挂了两次。然后教练讲了讲细节就结束了

七号按时间表不练，但教练让我们下午去再找找问题，再把问题一解决，我就感觉更没问题了就等 8 号的考试了。

考试当天

我强烈建议大家考科目二的时候，要么早早就去，早到驾校没开门就到了，要么就睡到自然起再去因为人非常多。我七点坐车，到了那里七点五十。排队排到 11 点半，早知道我就睡好了再去 QAQ。

好不容易排到到我，发现照片跟我本人不一样，是完全不一样那种，我怀疑可能是拍照出问题了，没办法再去拍照。然后就开始考试，

真的很熟练，右边倒车入库停的非常标准，就是左边的库有点小问题，有点太靠右了，这样来说我就应该不回方向盘，先保证两边距离，再微调使车身正朝前方，我平时遇到过这种情况，也就这样做了没什么问题，然而当我停下来的时候系统突然说车压线，扣我 100 分。我人直接懵了，当时我应该立刻下车看车是什么情况，但我太自信了，以为是压到两侧的线了，丝毫没想到是后退太多导致车身压住后线了。

把后面项目做完，明白问题之后手感也来了，自信回到起点打算一雪前耻

第二次真可以说是行云流水，就是左边的倒车入库，还是一样的问题，还是扣我 100 分，我这下人彻底懵了。要说是碰到后线，那为什么在右库没提示呢。碰到两边线就跟不可能了，毕竟眼睛一直盯着。那是什么问题呢？我也不知道，就迷迷糊糊把车开回去就结束了。以上说压后线是我的猜测，因为没有照片。直到到我写这篇文章的时候我都不知道到底压了哪根线。

唯一能给我一点安慰的就是那个跟我关系不错兄弟也没过（不是幸灾乐祸），他情况跟我差不多，是学托福的 3 号才结束。不过他 3 号请假来学车了，因此比我多练了一天。他说他考试时候车突然熄火了，然后他挂着档就紧急点火了，直接挂了。第二次是直角拐弯的时候压线了两次全挂。那哥们今年高考，考了 691 分，去了清华。一想到去清华的学霸和我一样我心里就好受不少（）。

反思

和我们一起练的还有一个女生，那个女生大四，给我的感觉就是反应有一些慢（没别的意思哈），但是她很努力练，自然而然的过了。对比我和那个兄弟，我俩太自信了，这导致在一些细节上把握不到位，明明在分校练的时候教练就告诉我点位很多次了。但我把 1：1 教练随意的一句话话当正确的。完全没想到他当时玩手机很可能没注意看。这一对比就能看出分校带我的吴教练的用心，平时我练习时候他从不看手机，考试当天还在叮嘱我一些细节。

那个兄弟可能完全没考虑到熄火这种情况，导致后面一步错，步步错。

这件事其实不大，无非再考一次，但也提醒我细节问题出一点差错都是致命的。那个兄弟的错误我也应该避免。以后有些事是没有机会再来一次的，要未虑胜，先虑败啊。唉，切记切记！

AnZhiYu主题美化：为爱好的游戏卡片添加头像

Wed, 01 Jan 2025 00:00:00 GMT

之前看张洪 heo 大佬的博客，在他的个人主页，爱好的游戏卡片上，发现了他将自己喜欢的英雄展示了出来。

fengmian11.1.webp

因为我也喜欢玩联盟（尤其他喜欢玩的英雄恰巧我也喜欢玩），于是也想在自己的博客中添加类似的功能。花了一下午的时间，终于实现了这个功能。

效果：

fengmian11.webp

教程

打开文件：博客根目录/themes/anzhiyu/layout/includes/page/about.pug

在大约 175 行，找到如下代码段：

      .author-content
        - let {game_tips, game_title, game_uid, game_bg} = item.game
        .author-content-item.game-yuanshen(style=`background: url(${game_bg}) top / cover no-repeat;`)
          .card-content
            .author-content-item-tips=game_tips
            span.author-content-item-title=game_title
            .content-bottom
              .icon-group
                .loading-bar(role='presentation', aria-hidden='true' style=`${game_title != "原神" ? "display: none": ""}`)
              .tips.game-yuanshen-uid=game_uid
        .author-content-item.comic-content
          .card-content
            - let {comic_tips, comic_title, comic_list} = item.comic
            .author-content-item-tips=comic_tips
            .author-content-item-title=comic_title
            .comic-box
              if comic_list
                each i in comic_list
                  a.comic-item(href=i.href, target="_blank", title=i.name)
                    .comic-item-cover
                      img(src=i.cover, alt=i.name)

将其修改为：

      .author-content
        - let {game_tips, game_title, game_uid, game_bg} = item.game
        .author-content-item.game-yuanshen(style=`background: url(${game_bg}) top / cover no-repeat;`)
          .card-content
            .author-content-item-tips=game_tips
            span.author-content-item-title=game_title
            .hero-group
              img.hero-group-item(
                data-tooltip="提示信息1"                            //替换为你喜欢的角色名称
                src="https://xxxxxxxxxx.com/your-image1.webp"     //替换为你喜欢的角色头像
                alt="提示信息1")                                   //替换为你喜欢的角色名称
              img.hero-group-item(
                data-tooltip="提示信息2"
                src="https://xxxxxxxxxx.com/your-image1.webp"
                alt="提示信息2")
              img.hero-group-item(
                data-tooltip="提示信息3"
                src="https://xxxxxxxxxx.com/your-image1.webp"
                alt="提示信息3")
            .hero-tooltip
            .content-bottom
              .icon-group
                .loading-bar(role='presentation', aria-hidden='true' style=`${game_title != "原神" ? "display: none" : ""}`)
              .tips.game-yuanshen-uid=game_uid
        .author-content-item.comic-content
          .card-content
            - let {comic_tips, comic_title, comic_list} = item.comic
            .author-content-item-tips=comic_tips
            .author-content-item-title=comic_title
            .comic-box
              if comic_list
                each i in comic_list
                  a.comic-item(href=i.href, target="_blank", title=i.name)
                    .comic-item-cover
                      img(src=i.cover, alt=i.name)

复制粘贴之后，你需要先修改这段代码格式。

然后，需要修改这段代码中的这一部分：

img.hero-group-item(
data-tooltip="提示信息1"                            //替换为你喜欢的角色名称
src="https://xxxxxxxxxx.com/your-image1.webp"     //替换为你喜欢的角色头像
alt="提示信息1")                                    //替换为你喜欢的角色名称

每一段这个代码即表示一个头像，展示顺序为从左到右，你可以根据自己的喜好，添加多个头像。

然后还是这个文件,在文件最下方，也就是 script 标签内，添加如下代码：

      function initEventDelegation() {
          const heroGroup = document.querySelector('.hero-group');
          const tooltip = document.querySelector('.hero-tooltip');

          if (!heroGroup) {
              setTimeout(initEventDelegation, 100);
              return;
          }

          if (!tooltip) {
              console.error('提示框元素未找到');
              return;
          }

          // 使用事件委托，在父元素上监听
          heroGroup.addEventListener('mouseover', function (e) {
              if (e.target.classList.contains('hero-group-item')) {
                  const allItems = document.querySelectorAll('.hero-group-item');

                  // 变暗其他头像
                  allItems.forEach(item => {
                      if (item !== e.target) item.classList.add('dimmed');
                  });

                  // 显示提示框
                  const tipText = e.target.getAttribute('data-tooltip');
                  if (tipText) {
                      tooltip.textContent = tipText;

                      // 计算提示框位置
                      const targetRect = e.target.getBoundingClientRect();
                      const tooltipRect = tooltip.getBoundingClientRect();

                      // 计算提示框位置（在头像上方居中）
                      let left = targetRect.left + (targetRect.width / 2) - (tooltipRect.width / 2);
                      let top = targetRect.top - tooltipRect.height - 10;

                      // 边界检查，确保提示框不会超出屏幕
                      if (left < 10) left = 10;
                      if (left + tooltipRect.width > window.innerWidth - 10) {
                          left = window.innerWidth - tooltipRect.width - 10;
                      }
                      if (top < 10) {
                          top = targetRect.bottom + 10;
                      }

                      tooltip.style.left = left + 'px';
                      tooltip.style.top = top + 'px';
                      tooltip.classList.add('show');

                      console.log('显示提示框:', tipText, '位置:', left, top);
                  }
              }
          });

          heroGroup.addEventListener('mouseout', function (e) {
              if (e.target.classList.contains('hero-group-item')) {
                  const allItems = document.querySelectorAll('.hero-group-item');

                  // 恢复所有头像
                  allItems.forEach(item => item.classList.remove('dimmed'));

                  // 隐藏提示框
                  tooltip.classList.remove('show');
              }
          });

          console.log('英雄头像事件委托初始化完成');
      }

      // 使用多种方式确保执行
      document.addEventListener('DOMContentLoaded', initEventDelegation);
      window.addEventListener('load', initEventDelegation);
      document.addEventListener('pjax:complete', initEventDelegation);

如果你不知道格式，可以使用快捷键来格式化代码。

打开第二个文件：博客根目录/themes/anzhiyu/source/css/_page/about.styl 在文件最下方，添加如下代码：

.author-content-item.game-yuanshen {
  position: relative !important;
  overflow: hidden !important; /* 保持 hidden 确保圆角裁剪 */
}

.author-content-item.game-yuanshen .card-content .hero-group {
  position: absolute;
  bottom: 20px;
  left: 40px;
  display: flex;
  align-items: center;
  z-index: 3;
}

.hero-group-item {
  width: 40px;
  height: 40px;
  border-radius: 50%;
  border: 2px solid var(--anzhiyu-main);
  object-fit: cover;
  position: relative;
  z-index: 1;
  transition: z-index 0.2s, transform 0.2s;
  cursor: pointer;
}

.hero-group-item:nth-child(n+2) {
  margin-left: -10px; /* 调整这个值控制重叠程度 */
}

.hero-group-item img {
  width: 100% !important;
  height: 100% !important;
  object-fit: cover !important;
}

.hero-group-item:hover {
  transform: scale(1.1) !important;
  z-index: 10 !important;
}

/* 英雄提示框样式 */
/* 提示框样式 - 使用固定定位 */
.hero-tooltip {
  position: fixed;
  background: rgba(0, 0, 0, 0.9);
  color: white;
  padding: 8px 12px;
  border-radius: 6px;
  font-size: 12px;
  white-space: nowrap;
  opacity: 0;
  visibility: hidden;
  transition: all 0.3s ease;
  z-index: 10000;
  pointer-events: none;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
  font-weight: 500;
  max-width: 200px;
  text-align: center;
  /* 添加小箭头 */
  &::after {
    content: '';
    position: absolute;
    top: 100%;
    left: 50%;
    transform: translateX(-50%);
    border: 5px solid transparent;
    border-top-color: rgba(0, 0, 0, 0.9);
  }
}

.hero-tooltip.show {
  opacity: 1;
  visibility: visible;
}

/* 英雄头像基础样式 */
.hero-group-item {
  width: 40px;
  height: 40px;
  border-radius: 50%;
  border: 2px solid var(--anzhiyu-main);
  object-fit: cover;
  position: relative;
  z-index: 1;
  transition: all 0.3s ease;
  cursor: pointer;
}

/* 重叠效果 */
.hero-group-item:nth-child(n+2) {
  margin-left: -10px;
}

/* 悬停效果 */
.hero-group-item:hover {
  z-index: 10;
  transform: scale(1.1);
}

/* 变暗效果 */
.hero-group-item.dimmed {
  opacity: 0.3;  
}

这个样式是头像之间有一些重叠效果，因为我的喜欢玩的英雄很多（嘿嘿）。

你可以根据注释来针对你的喜好进行修改

/* 英雄头像样式 */
.author-content-item.game-yuanshen {
  position: relative !important;
  overflow: hidden !important; /* 保持 hidden 确保圆角裁剪 */
}

.author-content-item.game-yuanshen .card-content .hero-group {
  position: absolute !important;
  bottom: 20px !important;
  left: 40px !important;
  display: flex !important;
  gap: 8px !important;
  z-index: 3 !important;
}

.hero-group-item {
  width: 40px !important;
  height: 40px !important;
  border-radius: 50% !important;
  border: 2px solid var(--anzhiyu-main) !important;
  overflow: hidden !important;
  cursor: pointer !important;
  transition: all 0.3s ease !important;
}

.hero-group-item img {
  width: 100% !important;
  height: 100% !important;
  object-fit: cover !important;
}

.hero-group-item:hover {
  transform: scale(1.1) !important;
  z-index: 10 !important;
}

/* 英雄提示框样式 */
.hero-tooltip {
  position: absolute;
  opacity: 0;
  pointer-events: none;
  background: rgba(0, 0, 0, 0.8);
  color: #fff;
  padding: 6px 12px;
  border-radius: 8px;
  z-index: 10000;
  font-size: 14px;
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.5);
  transition: opacity 0.2s ease;
  white-space: nowrap;
}

.hero-tooltip.show {
  opacity: 1;
}

.hero-group-item.dimmed {
  opacity: 0.5;
  transition: opacity 0.3s ease;
}

然后一键三连即可查看效果啦。

lc-3 处理器的指令格式表

Wed, 01 Jan 2025 00:00:00 GMT

学期末尤其繁忙，不是考试就是小组作业，终于有时间写出这篇文章。话不多说，让我们开始吧

在介绍 LC-3 处理器前，我们需要先回顾指令集体系结构（Instruction Set Architecture, ISA），其作为计算机系统中软硬件交互的核心界面，定义了处理器可执行指令的集合、寄存器组织结构、内存访问方式以及中断处理机制等基础硬件特性。

LC3 简介

LC-3 有 16 条指令，每条指令有 16 个字符，也就意味着它有2162^{16}216个地址空间，它还有 8 个寄存器（Register）。每个寄存器以 3 位二进制字符进行编号。

以下是这 16 条指令，以 15 到 12 位不同的操作符进行区分，此外操作符 1101 的指令并没有使用，所以其实只有 15 条指令

fengmian12.1

LC-3 指令格式表

操作指令

LC-3 有三种操作指令：ADD, AND, NOT

ADD 和 AND 需要两个操作数，NOT 只需要一个源操作数。下面这条操作指令将 R5 寄存器中的值进行 NOT 运算，然后存入 R3 寄存器。第 5 到第 0 位是未使用的位，以 1 进行填充。

DR 代表目标寄存器（Destination Register），是将操作结果存储到该寄存器中，SR 代表源寄存器（Source Register）

ADD 指令

ADD 指令的操作码为 0001，它将两个操作数相加，结果存入目标寄存器 DR。ADD 支持两种寻址模式，由第 5 位决定：

寄存器模式（bit[5] = 0）：两个源操作数均来自寄存器。bit[2
] 指定 SR2，bit[8
] 指定 SR1，bit[4
] 固定填充 00。
立即数模式（bit[5] = 1）：第二个操作数为 5 位有符号立即数（imm5），需要先进行符号扩展至 16 位后再与 SR1 相加。

寄存器模式:  0001  DR  SR1  0  00  SR2
立即数模式:  0001  DR  SR1  1  imm5

举个例子：0001 011 010 1 00101 表示 R2 = R2 + 5。将 R2（SR1，也是 DR）与符号扩展后的立即数 5 相加，结果存回 R2。

ADD 指令会根据计算结果自动更新条件码（Condition Code, CC）：结果为正则 N=0 Z=0 P=1，结果为负则 N=1 Z=0 P=0，结果为零则 N=0 Z=1 P=0。

AND 指令

AND 指令的操作码为 0101，与 ADD 结构完全一致，同样支持两种寻址模式，区别仅在于执行按位与（bitwise AND）而非加法：

寄存器模式:  0101  DR  SR1  0  00  SR2
立即数模式:  0101  DR  SR1  1  imm5

同样会根据结果更新条件码。立即数模式常用于位掩码操作，例如 0101 011 010 1 00011 表示 R2 = R2 AND 3，可用来提取 R2 的低 2 位。

NOT 指令

NOT 指令的操作码为 1001，它是唯一一条只有一个源操作数的操作指令。对 SR 的值按位取反后存入 DR，低 6 位以 1 填充：

NOT:  1001  DR  SR  111111

举个例子：1001 011 101 111111 表示 R3 = NOT(R5)，对 R5 按位取反后存入 R3。

NOT 同样会根据结果更新条件码。利用 NOT 和 ADD 组合，可以实现减法操作：先对减数取反，再加 1（二进制补码），然后与被减数相加。

数据搬移指令

数据搬移指令负责在寄存器和内存之间传输数据，是 LC-3 中指令数量最多的一类，共 7 条。根据寻址方式的不同，可分为三类：PC 相对寻址（LD、ST、LEA、LDI、STI）、基址偏移寻址（LDR、STR）和立即数加载（LEA 严格来说加载的是地址而非内存数据）。

LD 指令（Load）

操作码 0010，将内存中某个地址的值加载到目标寄存器 DR。地址计算方式：将 9 位有符号偏移量（PCoffset9）符号扩展至 16 位，然后与递增后的 PC 相加得到目标地址。

LD:  0010  DR  PCoffset9

举个例子：0010 011 000000101 表示 R3 = M[PC + 5]，将 PC+5 地址处的值加载到 R3。

ST 指令（Store）

操作码 0011，将源寄存器 SR 的值存储到内存中。地址计算方式与 LD 完全相同——将 PCoffset9 符号扩展后与递增后的 PC 相加。

ST:  0011  SR  PCoffset9

注意：LD 和 ST 的寻址范围是 PC ± 256，这是因为 9 位有符号偏移量的范围是 -256 到 +255。

LDR 指令（Load Register）

操作码 0110，使用基址加偏移的方式计算地址：将 6 位有符号偏移量（offset6）符号扩展至 16 位，与基址寄存器 BaseR 的值相加。

LDR:  0110  DR  BaseR  offset6

举个例子：0110 011 010 000110 表示 R3 = M[R2 + 6]，以 R2 为基址、偏移 6 来访问内存。

对比 LD：LD 以 PC 为基址（PC 相对寻址），适合访问全局变量和静态数据；LDR 以任意寄存器为基址，灵活度更高，适合访问数组元素和结构体成员。

STR 指令（Store Register）

操作码 0111，与 LDR 结构一致，区别在于将 SR 的值写入内存而非读取：

STR:  0111  SR  BaseR  offset6

LDI 指令（Load Indirect）

操作码 1010，间接寻址：先以 PC 相对寻址方式找到一个内存地址，再以该地址存储的值为最终地址，去读取数据加载到 DR。用 C 语言的指针概念来理解，就是双重解引用。

LDI:  1010  DR  PCoffset9

举个例子：1010 011 000001010，先计算 PC+10 处地址 A，再读取 M[A] 的值为地址 B，最终 R3 = M[B]。

STI 指令（Store Indirect）

操作码 1011，与 LDI 结构一致，区别在于将 SR 的值存储到通过间接寻址得到的目标地址中：

STI:  1011  SR  PCoffset9

LEA 指令（Load Effective Address）

操作码 1110，这条指令不访问内存，而是直接将计算出的地址（而非地址中的内容）加载到 DR。地址计算方式与 LD 相同：PCoffset9 符号扩展后与递增后的 PC 相加。

LEA:  1110  DR  PCoffset9

举个例子：1110 011 000000101 表示 R3 = PC + 5。注意：R3 得到的是地址值 PC+5，而非 M[PC+5] 的内容。

LEA 常用于获取某个数据区域或字符串的起始地址，然后配合 LDR/STR 遍历访问。

指令	操作码	格式	寻址方式
LD	`0010`	`0010 DR PCoffset9`	PC 相对
ST	`0011`	`0011 SR PCoffset9`	PC 相对
LDR	`0110`	`0110 DR BaseR offset6`	基址偏移
STR	`0111`	`0111 SR BaseR offset6`	基址偏移
LDI	`1010`	`1010 DR PCoffset9`	间接
STI	`1011`	`1011 SR PCoffset9`	间接
LEA	`1110`	`1110 DR PCoffset9`	立即数（地址）

控制指令

控制指令负责改变程序的执行流程，包括条件分支、无条件跳转、子程序调用和系统陷阱等。

BR 指令（Branch）

操作码 0000，根据条件码 N、Z、P 的状态决定是否跳转。bit[11

] 分别为 n、z、p 标志位，当对应的条件码为 1 时，该条件被"选中"；只有被选中且对应的 CC 位也为 1 时，跳转才会发生。

BR:  0000  n  z  p  PCoffset9

n z p	助记符	跳转条件
0 0 0	—	永不跳转（无操作）
1 1 1	BR	无条件跳转
1 0 0	BRn	N=1 时跳转（结果为负）
0 1 0	BRz	Z=1 时跳转（结果为零）
0 0 1	BRp	P=1 时跳转（结果为正）
1 1 0	BRnz	N=1 或 Z=1 时跳转
0 1 1	BRzp	Z=1 或 P=1 时跳转
1 0 1	BRnp	N=1 或 P=1 时跳转

若跳转发生，目标地址 = PC + sext(PCoffset9)；若跳转不发生，程序顺序执行下一条指令。汇编器会将条件组合自动翻译为对应的助记符。

JMP 指令（Jump）

操作码 1100，无条件跳转到基址寄存器 BaseR 中存储的地址。bit[8

] 指定 BaseR，其余未使用位以 0 填充。

JMP:  1100  000  BaseR  000000

举个例子：1100 000 010 000000 表示 PC = R2，程序跳转到 R2 中存储的地址继续执行。

对比 BR：BR 的跳转目标是相对于 PC 的偏移且受条件码约束，而 JMP 的跳转目标来自寄存器，可以跳转到任意地址，更加灵活。

JSR 与 JSRR 指令（Jump to Subroutine）

操作码 0100，用于子程序调用。在执行跳转前，JSR/JSRR 会自动将返回地址（即当前 PC 的值，指向下一条指令）保存到 R7 寄存器中，以便子程序执行完毕后通过 RET 返回。

JSR 和 JSRR 由同一个操作码 0100 实现，通过 bit[11] 区分：

JSR（bit[11] = 1）：使用 11 位 PC 相对偏移量，跳转范围为 PC ± 1024。
JSRR（bit[11] = 0）：使用基址寄存器 BaseR 指定目标地址，bit[8
] 指定寄存器，其余位填充 0。

JSR:   0100  1  PCoffset11
JSRR:  0100  0  00  BaseR  000000

举个例子：0100 1 00000001001 先将当前 PC 保存到 R7，再跳转到 PC + 9。

注意：JSRR 的基址寄存器同样可以是 R7，但由于返回地址已经被写入 R7，若再以 R7 作为 BaseR 去跳转，会导致程序跳转回返回地址处（即自己），这种用法并不常见。

RET 指令（Return）

操作码 1100。实际上，RET 是 JMP R7 的别名——将 R7（保存了返回地址）的值加载到 PC，从而从子程序返回。

RET:  1100  000  111  000000

为什么是 R7？因为 JSR/JSRR 在跳转前已经把返回地址写入了 R7，所以 RET 只需一句 JMP R7 就能回到调用点。在 LC-3 汇编器中，RET 和 JMP R7 是完全等价的。

RTI 指令（Return from Interrupt）

操作码 1000，用于从中断服务程序返回。RTI 的行为较为特殊——它不会修改 PC 的值；当中断被触发时，处理器会将当前 PC 值压入系统栈，RTI 只是向处理器发出"中断处理完毕"的信号，由硬件恢复现场。

RTI:  1000  000000000000

在 LC-3 教学模型中，RTI 的具体行为取决于模拟器的实现，很多情况下它被简化处理。如果你用的是 LC-3 模拟器，建议查阅其文档确认 RTI 的精确行为。

TRAP 指令

操作码 1111，高 8 位为 11110000，低 8 位为 trapvect8，用于调用操作系统的服务例程。TRAP 与 JSR 类似：先将 PC 保存到 R7，然后跳转到由 trapvect8 指定的服务例程地址。

TRAP:  1111  0000  trapvect8

常见的 TRAP 服务例程（LC-3 操作系统内置）：

trapvect8	助记符	功能
`x20`	GETC	从键盘读取一个字符（不回显），存入 R0[7 ]
`x21`	OUT	输出 R0[7 ] 中的字符到屏幕
`x22`	PUTS	输出以 R0 为起始地址的字符串（以 NUL 结尾）
`x23`	IN	提示输入一个字符，回显后存入 R0[7 ]
`x24`	PUTSP	输出以 R0 为起始地址的打包字符串
`x25`	HALT	停止程序执行，打印停机信息

举个例子：1111 0000 00100001（即 TRAP x21），将 R0[7
] 中的字符输出到显示器上。

TRAP 是用户程序与 LC-3 操作系统之间的桥梁。你的程序不需要知道 OUT 服务例程具体放在内存的哪个位置，只需要通过 TRAP 指令加上对应的 trapvect8 即可调用。

指令	操作码	格式	说明
BR	`0000`	`0000 n z p PCoffset9`	条件分支
JMP	`1100`	`1100 000 BaseR 000000`	无条件跳转
JSR	`0100`	`0100 1 PCoffset11`	子程序调用（PC 相对）
JSRR	`0100`	`0100 0 00 BaseR 000000`	子程序调用（寄存器）
RET	`1100`	`1100 000 111 000000`	从子程序返回（JMP R7）
RTI	`1000`	`1000 000000000000`	从中断返回
TRAP	`1111`	`1111 0000 trapvect8`	系统服务调用

总结

LC-3 总共定义了 16 条指令（操作码 1101 保留未使用，实际使用 15 条），按照功能可以分成三大类：

操作指令（ADD、AND、NOT）：执行算术和逻辑运算，结果存入寄存器，同时更新条件码。
数据搬移指令（LD、ST、LDR、STR、LDI、STI、LEA）：在寄存器和内存之间搬运数据，不同指令对应不同的寻址方式——PC 相对、基址偏移或间接寻址。
控制指令（BR、JMP、JSR/JSRR、RET、RTI、TRAP）：控制程序执行流程，实现条件分支、跳转、子程序调用和系统交互。

理解这些指令的二进制格式，是读懂 LC-3 机器码、手写汇编程序以及后续学习微架构设计和LC-3 数据通路的基础。建议对照指令格式表，多在 LC-3 模拟器上动手编写和调试几段程序，熟悉后你会发现这 16 条指令虽然简单，但已经能完成相当多有趣的事情了。

在学校压力还是很大的，各种事情使我脱不开身，而我又很喜欢游戏，这使我很少更新文章 QAQ，以后尽量多抽时间写点东西