zola-将博客从hexo迁移到zola并部署至Cloudflare Pages

2025-03-07T11:23:16+00:00

最近将原博客部署到了Cloudflare Pages上，并且静态站点生成器也从Hexo换成了Zola，这里做一下迁移记录。

迁移的起因</h2>
原有博客是部署在Amazon Lightsail</a>的机器上的，这台机器平时只运行了个Nginx，一直续费实属浪费钱。博客这种能Serverless化的小东西，还是无需自己手动管理环境比较省精力。
托管静态Web应用的框架或平台已经很多，Github Pages</a>、Netlify</a>和 Cloudflare Pages</a>都非常成熟，鉴于博客目前套用的是Cloudflare的免费CDN套餐，干脆就拜托赛博菩萨好事做到底吧，于是选用了Cloudflare Pages。
至于Hexo，它上次更新距今已过了大半年，且我不太喜欢nodejs环境的臃肿，现在Rust社区也有了新的静态站点生成工具-Zola</a>，性能强且足够轻量，功能简洁够用，就决定迁移到Zola。
很久以前部署Hexo博客的文章在 这里</a>。

从Hexo迁移到Zola</h2>
这个迁移大致需要做以下几件事:

修改博客的Markdown文件内容格式</li>
修改主题</li>
修改配置文件</li>
SEO</li> </ol>
更改Markdown格式</h3>
Zola与Hexo的Markdown文件内容格式主要区别在`Front matter</code>上，这是Zola的Front Matter格式文档</a>。`
`将博客目录从服务器上打包下载到本地后，如果一篇一篇手动调整文章格式，太过重复且耗费时间。于是让AI写了个Python脚本，用来转换整个目录里的源Markdown文件的Front matter头，并重命名生成副本。`
`Deepseek给出的代码如下：`
import os import re import yaml from datetime import datetime def convert_front_matter(md_content): # 原有转换逻辑保持不变 yaml_match = re.search(r'^---\n(.?)\n---\n', md_content, re.DOTALL) if not yaml_match: return md_content yaml_str = yaml_match.group(1) data = yaml.safe_load(yaml_str) if 'date' in data: date_str = data['date'] if '/' in date_str: dt = datetime.strptime(date_str.split()[0], '%Y/%m/%d') data['date'] = dt.strftime('%Y-%m-%d') + ' ' + date_str.split()[1] toml_lines = ['+++'] for key, value in data.items(): if isinstance(value, list): quoted = [f'"{item}"' for item in value] toml_lines.append(f'{key} = [{", ".join(quoted)}]') else: if isinstance(value, str) and not value.startswith(('"', "'")): toml_lines.append(f'{key} = "{value}"') else: toml_lines.append(f'{key} = {value}') toml_lines.append('+++') return md_content.replace( yaml_match.group(0), '\n'.join(toml_lines) + '\n\n', 1 ) def process_markdown_files(input_dir): # 遍历目录中的所有.md文件 for filename in os.listdir(input_dir): if filename.endswith('.md'): input_path = os.path.join(input_dir, filename) # 读取原始文件内容 with open(input_path, 'r', encoding='utf-8') as f: content = f.read() # 转换front matter new_content = convert_front_matter(content) # 生成新文件名 new_filename = f'zola-{filename}' output_path = os.path.join(input_dir, new_filename) # 写入新文件 with open(output_path, 'w', encoding='utf-8') as f: f.write(new_content) print(f'已转换: {filename} -> {new_filename}') if name == 'main': # 配置参数（按需修改） MARKDOWN_DIR = './markdown_files' # 你的Markdown文件所在目录 # 执行转换 process_markdown_files(MARKDOWN_DIR) print("\n全部转换完成！新文件已添加 zola- 前缀") </code></pre> 这个代码可以一次性运行成功，不由得感叹2025年的大模型相比半年前确实进步不少。 修改主题</h3> Zola的主题目前还是有点少，在Github上找到一个比较成熟的主题-tabi</a>，直接使用它的脚手架项目-tabi-start</a>，在本地用Git初始化了这个项目，将调整过的Markdown文件全都放入content/blog</code>目录中，本地运行zola server</code>命令，访问http://127.0.0.1:1111</code>，确认可以正常运行。 如果以后需要更新主题，使用git submodule update --remote themes/tabi</code>命令即可。 修改配置</h3> 参考Zola的配置文件文档</a>和Tabi的配置文件文档</a>修改即可，文档非常详细，我主要调整了base_url</code>、搜索以及favicon相关的内容。 SEO</h3> 没人看，写着给自己看，这次直接放弃SEO。 部署到Cloudflare Pages</h2> 这一步主要参考自Zola的部署文档</a>，和Cloudflare Pages的开发人员文档</a>。 关联远程Git仓库</h3> 需要启用一个远程仓库，使得Cloudflare Pages能够由地方拉取代码，鉴于目前Github的私有仓库也已经免费，就直接将博客代码关联到了Github上。 通过代码仓库将网站部署到Cloudflare Pages</h3> 登录到Cloudflare Dashboard</a></li> 在帐户主页中，选择 Workers & Pages > Create > Pages > Connect to Git</li> 选择GitHub存储库，并在设置构建和部署部分中配置以下信息：</li> </ol> Configuration option</th> Value</th></tr></thead> Production branch</td> Master</td></tr> Build command</td> zola build</td></tr> Build directory</td> public</td></tr> </tbody></table> 在环境变量的配置框中添加ZOLA_VERSION</code>这个键，设置一个比较新的zola版本号作为它的值，因为默认的zola版本较低，可能会编译不通过。 </li> 点击Deploy部署即可。 </li> </ol> 可能会出现zola not found的报错，这是因为截止2025/03/01，Pages默认的v2编译环境还没有包含zola，在设置里将其切换至v1环境即可，详情参考Troubleshooting</a>。 </blockquote> 重新设置域名解析和CDN</h3> Pages部署成功后，Cloudflare会生成一个xxx.pages.dev</code>的域名，在Cloudflare里将主域名解析到这个三级域名，启用CDN，等待DNS解析生效即可。 后续更新维护</h2> 发布新文章时，只需要git push</code>推送到远程仓库，Cloudflare Pages服务会触发拉取代码仓库的动作，使用最新的代码部署页面。 迁移Docker Volume的本地目录 2024-03-15T12:00:01+00:00 最近在折腾大模型，用docker直接拉起的ollama服务来运行它们。 由于经常需要下载比较大的LLM，导致ollama的docker volume占用空间迅速增加，而docker volume默认位置是/var/lib/docker/volumes/</code>，位于根分区下。眼看着只有500G的盘要被占满了，只好考虑到给它迁移到更大的数据盘去。 以下是迁移volume的简要记录。 准备新的volume目录</h2> 为了保证数据拷贝速度，这里用了一块7TB的NVMe盘，格式化、挂载并新建一个目录用来存放迁移后的数据。 mkdir -p /data/rei/docker/volumes/ollama </code></pre> 挂载旧的volume目录</h2> 出于数据一致性的考虑，需要避免原有volume数据在拷贝时被修改，先停掉ollama容器。 docker stop ollama </code></pre> 然后拉起一个busybox容器挂载原有的volume，原有volume的名字是“ollama“。 docker run -d –name temp_container -v ollama:/volume_data busybox tail -f /dev/null 将volume拷贝到新目录</h2> 使用docker cp</code>命令拷贝数据。 docker cp temp_container:/volume_data /data/rei/docker/volumes/ollama </code></pre> 数据量大的情况下，可能需要很久。拷贝完成后，查看数据是否存在。 ls /data/rei/docker/volumes/ollama/volume_data </code></pre> 用新的volume目录重新拉起服务</h2> 先删除临时使用的busybox容器与旧的ollama容器。 docker rm -f temp_container && docker rm -f ollama </code></pre> 拉起一个新的ollama容器，volume使用上文迁移后的目录。 docker run -d --gpus=all -v /data/rei/docker/volumes/ollama/volume_data/:/root/.ollama -p 11434:11434 --name ollama ollama/ollama </code></pre> 一些清理工作</h2> 确认新的ollama容器可以正常工作后，清理掉旧的ollama容器释放硬盘空间。 docker volume rm ollama </code></pre> 关于pytest框架的fixture参数化实践踩坑记录 2023-06-28T10:52:01+00:00 需求</h2> 目前在写的测试框架里，有这么个需求，要在测试用例模块的同级data目录下，引用到同模块名同测试用例方法名的数据。 例如，测试模块名为test_ns.py</code>，测试用例的方法名为test_create_ns</code>，则它可以自动获取的测试数据位于./data/test_ns.toml</code>文件中，测试用例独占的数据为该toml文件的[[test_create_ns]]</code>块的数据。 文件目录结构如下： tests/csk/api/ ├── conftest.py ├── data │ └── test_ns.toml └── test_ns.py </code></pre> 其中test_ns.toml</code>简化内容为： [sharedata] cluster_id = "xxx" # 同测试方法名，为表数组 [[test_create_ns]] name = 'api-test-1' label_name = "api_label_1" label_val = "api_label_val_1" [test_create_ns.assert] success = true [[test_create_ns]] name = 'api-test_下划线' label_name = "api_label_2" label_val = "api_label_va_2" # ns名称不支持下划线，所以断言false [test_create_ns.assert] success = false </code></pre> 初步尝试</h2> 直接写一个方法去加载这些数据很简单，例如定义名为load_data</code>的方法，在测试用例里调用它，即可直接使用数据： def test_create_ns(self): data = load_data('xxx') # 过程处理 assert xxxxx </code></pre> 但是这样有个缺陷，即无法很好的使用Pytest的参数化功能，因为测试用例集的定义是个列表，即反序列化data为可迭代对象。 我们可以去循环迭代此data，然而Pytest会认为这只是一个测试用例；另一方面，默认情况下，若某次循环的断言没有通过，则该用例的测试过程会结束掉，这显然不是我们想要的结果。 引入参数化机制</h2> 利用Pytest框架实现最简单的参数化过程是，对测试类或者测试方法，使用@pytest.mark.parametrize()</code>装饰器。 稍微灵活一点的操作是，对fixture做参数化处理，形如@pytest.fixture(params=["xxx", "yyy"])</code>。 于是可以写这么个fixture，形式如下： @pytest.fixture(params=["xxx", "yyy"]) def _case_data(request): return request.param </code></pre> params</code>的内容是一个可迭代对象，此数据需要从我们的toml测试数据文件里取到，而解析数据这个动作的前提是，测试用例方法能够自动找到自己同名的段数据。 起初我把它也实现成了一个fixture，形式大概如下： @pytest.fixture() def _load_data(request): # 获取模块名和测试用例方法名 module_name = request.module.name method_name = request.node.name # 处理数据 return ['xxx', 'yyy'] </code></pre> 随后把这个名为_load_data</code>的fixture传递给之前的fixture： @pytest.fixture(params=_load_data) def _case_data(request): return request.param </code></pre> 看似逻辑正确，然而运行却报错了，输出提示表明，fixture不能作为参数传递给另一个fixture。 Collection time and testing time</h2> Pytest的执行大致分为两个阶段，即collection time 和 testing time。 顾名思义，前一个阶段目的主要是参数化准备以及收集测试用例，后者是真正执行测试的阶段。 fixture生成是在collection time内，装饰器是在模块导入的时候执行。 collection time完成后，Pytest进入’test time’，此时，一系列的setup方法、fixture方法会被调用，前一阶段收集的测试用例方法被执行，同样，teardown方法也会在最后时刻被调用。 由此引出的关键问题是，fixture或者test case从来不会在collection time时期执行。 所以上面的错误是，我们想要在collection time内使用fixture把数据收集完成，逻辑合理，但是pytest并不支持这种实现。 关于这个问题，pytest-dev的Github issues上也有过讨论，how to get data from fixture to parametrize with @parametrize ?</a> 如果试图直接将fixture作为方法调用，Pytest会终止运行并提示: Fixtures are not meant to be called directly。 使用pytest_generate_tests方法完成参数化处理</h2> 有了上述前提，解决问题的思路大致清晰了起来： 完整的收集数据不能放在collection time，可以在此之前，例如模块导入的时候，作为通用的方法被调用；也可以在此之后，例如test time； </li> 数据被参数化调用解析可以在collection time，由于要能够发现模块名/方法名，所以实现这种机制，还需要依赖自省的能力。 </li> </ol> 第一条解决起来很快，将之前的fixture拆分出来，变成普通的函数，解析出全局的字典，用以存储完整数据。 第二条在查阅文档后，发现pytest_generate_tests方法提供了完备的支持。 pytest_generate_tests是Pytest框架内置的hook方法，提供了自省的能力，而且它可以发现所有的fixture名。它的使用比较直接，直接实现即可。 collection time时间段内，Pytest在每个模块中寻找名为pytest_generate_tests的方法并调用它。这个方法并非fixture，只是普通的Python函数。 它接受名为metafunc的参数，该参数也不是fixture，而是一个特殊的pytest对象，详见pytest 7.4 源码</a>。 最终实现示例</h2> @pytest.fixture(scope='function') def _case_data(request, params=[]): return request.param def pytest_generate_tests(metafunc): if '_case_data' in metafunc.fixturenames: # 这里先获取所有数据 all_global_data = _all_global_data() # 区分测试用例所在的测试模块名 module_name = metafunc.module.name global_data = all_global_data[module_name] # load_data是个加载数据的普通方法，关键点是metafunc的自省能力 case_data = load_data(global_data, metafunc.function.name) # 对_case_data这个fixture做参数化 metafunc.parametrize('_case_data', case_data) </code></pre> 在测试用例里，加上名为_case_data</code>的fixture： def test_create_ns(self, _case_data): key=_case_data['label_name'], value=_case_data['label_val'] resp = self._ns.create_ns(xxx) assert resp.json['success'] is _case_data['assert']['success'] </code></pre> 后记</h2> Fixtures 和 parametrization机制使得测试数据与测试方法分离开来，数据分离使得测试代码尽可能的简化，让测试的重用性与健壮性更强了。 但是使用起来还是要理解它们的运行流程和实现机制，否则很容易踩坑。 在CentOS7.x环境上安装Python3.11 2023-06-25T18:53:01+00:00 当前的自动化测试项目使用的Python版本需要大于等于3.10，而公司的服务器操作系统为CentOS 7.9，默认的Python版本还是经典的2.7.5，源里最新的版本为3.6，因此需要手动安装新版本的Python。 这里没有采用从源码编译安装的方式，因为最近在看Flask作者的rye</a>项目时，他提到了rye的Python二进制文件来自于Github上，indygreg的python-build-standalone</a>项目的预编译版本： Note that does mean, that Rye will automatically download and install an appropriate Python binary for you. These Python binaries are currently pulled from the indygreg python-build-standalone releases. </blockquote> 看了一下这个项目，对于Python版本、环境版本的分类还是非常完备的，于是选择了当前最新的3.11.3版本。 文件名为cpython-3.11.3+20230507-x86_64-unknown-linux-gnu-pgo+lto-full.tar.zst</code>。 安装环境准备</h2> 此文件采用了zstandard方式压缩，对于旧版本的CentOS，它的tar并不支持该压缩算法，需要安装zstd。 sudo yum install zstd </code></pre> 查阅此项目文档，发现它还需要一些运行时依赖，主要是glibc的库，一并安装了： sudo yum install openssl-devel bzip2-devel libffi-devel sudo yum install glibc-devel glibc-headers compat-glibc-headers </code></pre> 卸载掉旧的Python3和pip: sudo yum -y remove python3 python2-pip </code></pre> 解压出二进制，配置环境变量</h2> zstd -d cpython-3.11.3+20230507-x86_64-unknown-linux-gnu-pgo+lto-full.tar.zst tar -xvf cpython-3.11.3+20230507-x86_64-unknown-linux-gnu-pgo+lto-full.tar </code></pre> 解压出的Python二进制目录位于./python/install/bin/</code>下，将这个目录添加到Path里即可。 编辑~/.bashrc</code>，加入下面一行： export PATH="$PATH:/home/yvqa/software/python/install/bin/" </code></pre> 确认Python版本</h2> source ~/.bashrc python3 --version && pip --version </code></pre> 刷新环境变量，确认版本正确即可。 在CentOS7.x环境上编译安装Git2.x版本的简要记录 2023-06-25T18:52:01+00:00 目前公司内网环境下的虚拟机系统以CentOS7.9为主，源里的最新Git版本还是1.8.3.1，缺失一些新特性，因此需要升级到Git 2.x版本。 以下是从源码编译安装最新Git版本的简要记录。 编译环境准备</h2> 首先需要安装编译环境的依赖，以及卸载旧的git 1.x版本。 sudo yum -y remove git sudo yum -y install epel-release sudo yum -y groupinstall "Development Tools" sudo yum -y install wget perl-CPAN gettext-devel perl-devel openssl-devel zlib-devel curl-devel expat-devel getopt asciidoc xmlto docbook2X sudo yum -y remove git sudo ln -s /usr/bin/db2x_docbook2texi /usr/bin/docbook2x-texi </code></pre> 下载源码，配置与编译</h2> 先从Github上下载最新的git源码，这里使用的是v2.41.0版本，文件名为git-2.41.0.tar.gz</code>，上传到服务器目录。 解压源码并编译，配置的安装路径位于/usr/local</code>下，命令如下： tar -xvf git-2.41.0.tar.gz cd git-2.41.0 make configure sudo ./configure --prefix=/usr/local sudo make sudo make install </code></pre> 确认Git版本</h2> 按照上述配置，Git的路径应该为/usr/local/bin/git</code>。 source ~/.bashrc && source /etc/profile whereis git && git --version </code></pre> 刷新环境变量，确认版本正确即可。 leetcode打卡-1720解码异或后的数组 2021-05-07T22:32:01+00:00 五一这几天玩的有点嗨，今天看书脑子嗡嗡的，还是先整点简单题适应一下学习节奏好了。 题目描述</h2> 未知整数数组arr由n个非负整数组成。 经编码后变为长度为n - 1的另一个整数数组encoded ，其中encoded[i] = arr[i] XOR arr[i + 1]</code> 。例如，arr = [1,0,2,1]</code>经编码后得到encoded = [1,2,3]</code>。 给你编码后的数组encoded和原数组arr的第一个元素first(arr[0])</code>。 请解码返回原数组arr。可以证明答案存在并且是唯一的。 示例： 输入：encoded = [6,2,7,3]</code>, first = 4 </blockquote> 输出：[4,2,0,7,4]</code> </blockquote> 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/decode-xored-array 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 解题思路</h2> 1. 位运算性质计算</h3> 异或满足交换律和结合律，对原式进行计算可得： arr[i] ^ arr[i + 1] = encoded[i]</code></li> arr[i] ^ arr[i + 1] ^ encoded[i] = encoded[i] ^ encoded[i] = 0</code></li> arr[i] ^ arr[i + 1] ^ arr[i + 1] ^ encoded[i] = 0 ^ arr[i + 1]</code></li> arr[i] ^ encoded[i] = arr[i + 1]</code></li> </ul> 所以遍历encoded数组即可迭代算出完整的arr数组. 代码如下： class Solution: def decode(self, encoded: List[int], first: int) -> List[int]: # arr[i] ^ arr[i + 1] = encoded[i]，用异或的性质运算得出 # arr[i + 1] = arr[i] ^ encoded[i] length = len(encoded) arr = [0] (length + 1) arr[0] = first for i in range(length): arr[i + 1] = arr[i] ^ encoded[i] return arr </code></pre> 练习一下Rust实现 impl Solution { pub fn decode(encoded: Vec<i32>, first: i32) -> Vec<i32> { let len = encoded.len(); let mut arr = vec![first; len + 1]; for i in 0..len { arr[i + 1] = encoded[i] ^ arr[i]; } arr } } </code></pre> 时间复杂度: O(n)</li> 空间复杂度: O(1)</li> </ul> 总结</h2> 几种位运算的基本规则要记牢。 leetcode打卡-0633平方数之和 2021-04-28T16:12:01+00:00 题目描述</h2> 给定一个非负整数c，你要判断是否存在两个整数a和b，使得a2 + b2 = c 。 示例： 输入：c = 5 </blockquote> 输出：true </blockquote> 解释：1 1 + 2 * 2 = 5 </blockquote> 解题思路</h2> 1. 双指针</h3> 如果使用暴力枚举，而且不限定范围，就需要在0~c之间遍历，理论上时间复杂度就成了O(c^2)，实在是太高了，所以不太好。 由题目可知，a或b一定会小于√c，所以考虑把a、b两个值作为双指针，从0~√c两头缩放的方式来确定是否满足条件。 两数平方之和sum=c，直接返回True</li> sum < c，a += 1</li> sum > c，b -= 1</li> </ul> 代码如下： class Solution: def judgeSquareSum(self, c: int) -> bool: left = 0 right = math.isqrt(c) while left <= right: res = pow(left, 2) + pow(right, 2) if res == c: return True if res > c: right -= 1 else: left += 1 return False </code></pre> 练习一下Rust实现 impl Solution { pub fn judge_square_sum(c: i32) -> bool { let mut left: i32 = 0; let mut right: i32 = (c as f64).sqrt() as i32; while left <= right { let s = left.pow(2) + right.pow(2); match s.cmp(&c) { std::cmp::Ordering::Less => { left += 1; }, std::cmp::Ordering::Greater => { right -= 1 }, _ => { return true; } } } false } } </code></pre> 时间复杂度: O(√c)</li> 空间复杂度: O(1)</li> </ul> 总结</h2> 这题本来是可以用费马平方和定理来解的，虽然会简化计算，但是那样就变成了一个数学问题，所以还是用双指针的方式来写了。 leetcode打卡-0019删除链表的倒数第N个结点 2021-04-26T22:12:01+00:00 题目描述</h2> 给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。 解题思路</h2> 1. 快慢指针</h3> 单链表的遍历方向只能从头到尾单向遍历，如果要删除倒数第N个节点，就意味着后面还有N-1步才能遍历到末尾。 所以考虑用快慢指针的方法，快指针先走N-1步，然后两个指针再同时前进，这样当快指针走到末尾时，慢指针正好指向倒数第N个节点。 不过为了便于删除节点，当慢指针指向倒数第N+1个节点时就停下来即可，所以，先让快指针走N步。代码如下： class Solution: def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode: fast = head slow = head # 快指针先走N步 for _ in range(n): fast = fast.next # 如果快指针走完了整个链表，那么链表长度为N，倒数第N个即头节点 if fast is None: return head.next while fast.next: fast = fast.next slow = slow.next slow.next = slow.next.next return head </code></pre> 时间复杂度: O(n)，其中n是链表的长度</li> 空间复杂度: O(1)</li> </ul> 总结</h2> 单链表由于其方向上的一致性，运用双指针解法时候一般优先考虑快慢指针。 Python3中不同方式建立已知长度数组的效率 2021-04-26T21:43:01+00:00 今天在做一个前缀和题目的时候，因为要预分配一个前缀和数组，而数组的长度是已知的，所以想到了对比一下几种数组生成方式的效率。 这里用生成10000个int型数据的数组来做对比。 1. 列表生成式</h3> [i for i in range(10000)] </code></pre> 可以看到平均速率是258µs。 2. list的append方法</h3> def test_listappend(n): res = [] for i in range(n): res.append(i) return res </code></pre> 可以看到平均速率是701µs，相对列表生成式来说慢了很多。 3. list的预分配方法</h3> def test_preadd(n): res = [0] * n for i in range(n): res[i] = i return res </code></pre> 预分配空间后，再将值写入，效率大概在445µs左右，比append方法快，但是依然比列表生成式慢。 4. deque的append方法</h3> from collections import deque def test_dequeappend(n): res = deque() for i in range(n): res.append(i) return res </code></pre> 速率大概是680µs，只比list的append方法快了一点点。 5. deque的预分配方法</h3> from collections import deque def test_predeque(n): res = deque([0] * n) for i in range(n): res[i] = i return res </code></pre> 777µs，比deque的append的效率还要慢一些。 可以看出，在数组长度已知的情况下，列表生成式的效率是很高的，如果不使用列表生成式，预分配数组空间再遍历写入值，效率也是比append方法要来的快。 leetcode打卡-0049字母异位词分组 2021-04-23T21:33:01+00:00 题目描述</h2> 给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。 示例： 输入：[“eat”, “tea”, “tan”, “ate”, “nat”, “bat”] </blockquote> 输出：[[“ate”,“eat”,“tea”],[“nat”,“tan”],[“bat”]] </blockquote> 解题思路</h2> 1. 排序 + 哈希表</h3> 这道题的解法，是一个分类的过程，物以类聚，就要从表面不同的对象中找到它们的共同点，才可以归为一类。 所以字母异位词的字母是一样的，只是顺序不同，那么将他们重新排列后，就可以变为同值的对象。于是将排序后的对象作为哈希表的键，将对应的原始字符串存储到值列表中，即可满足条件。 由于Python中字典的键是不可变对象，所以还要将排序后的字符串转为元组处理。 class Solution: def groupAnagrams(self, strs: List[str]) -> List[List[str]]: # 手动管理字典的方法 # hashmap = {} # for val in strs: # key = tuple(sorted(val)) # hashmap[key] = hashmap.get(key, []) + [val] # return list(hashmap.values()) # 利用标准库里的defaultdict更简单一些 hashmap = collections.defaultdict(list) for val in strs: hashmap[tuple(sorted(val))].append(val) return list(hashmap.values()) </code></pre> 时间复杂度: O(nklogk)，其中n是strs中的字符串的数量，k是strs中的字符串的的最大长度</li> 空间复杂度: O(nk)</li> </ul> leetcode打卡-0056合并区间 2021-04-22T22:23:01+00:00 题目描述</h2> 以数组intervals表示若干个区间的集合，其中单个区间为intervals[i] = [starti, endi]</code>。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/merge-intervals 示例： 输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]] </code></pre> 解释：子数组 [4,3]</code> 是该条件下的长度最小的子数组。 解题思路</h2> 1. 排序</h3> 本来这是个合并区间的题，但是由于是二维数组，所以得先考虑它的外层，即一维数组之间元素的关系。 所以问题可以简化成外层数组之间每个元素的并集。 那么首先对外层进行排序，依照区间的左端点为基准，即可把每个小区间的起始点有序地排列在数轴上。这样就很容易看出某个区间与它下一个区间是否有交集。 将外层按照左端点排序，并新建一个merged数组用于存放合并后的新区间；</li> 遍历排序后的数组，如果当前区间的左端点在merged数组最后元素的右端点之后，则它们不重合，直接将这个区间加入merged；</li> 否则为重合区间，则取当前区间右端点的值与最后元素右端点值的较大者，更新最后的右端点值。</li> </ol> class Solution: def merge(self, intervals: List[List[int]]) -> List[List[int]]: if not intervals: return [] intervals.sort() res = [intervals[0]] for start, end in intervals[1:]: if res[-1][1] < start: res.append([start, end]) else: res[-1][1] = max(end, res[-1][1]) return res </code></pre> 时间复杂度: O(nlogn)</li> 空间复杂度: O(logn)</li> </ul> leetcode打卡-0209长度最小的子数组 2021-04-21T23:50:01+00:00 题目描述</h2> 给定一个含有n个正整数的数组和一个正整数target 。 找出该数组中满足其和≥target的长度最小的连续子数组[numsl, numsl+1, …, numsr-1, numsr]，并返回其长度；如果不存在符合条件的子数组，返回0。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/minimum-size-subarray-sum 示例： 输入：target = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。 </code></pre> 解题思路</h2> 1. 前缀和 + 二分查找</h3> 数组中查找相关的题目，可以考虑二分查找提高效率，但是二分查找适用于有序数组。题目中这个数组是正数序列，于是就想到先把这个数组的前缀和计算出来，保证形成的是一个从小到大的有序序列。 长度为n的数组nums，生成一个长度为n+1首位为0的前缀和数组sums，则sums[j]-sums[i]，即为nums的i到j-1位之和。 得到前缀和之后，对于每个开始下标i，可通过二分查找得到大于或等于i的最小下标bound，使得sums[bound]-sums[i-1]>target，并更新子数组的最小长度，此时子数组的长度是bound−(i−1)。 本来手写了个二分查找，看了题解后才知道原来Python标准库里有个bisect的模块已经实现了二分查找，就直接用它好了。 class Solution: def minSubArrayLen(self, target: int, nums: List[int]) -> int: if not nums: return 0 n = len(nums) ans = n + 1 sums = [0] * (n + 1) for i, val in enumerate(nums): sums[i + 1] = sums[i] + val for i in range(1, n + 1): tmp = target + sums[i - 1] bound = bisect.bisect_left(sums, tmp) if bound != len(sums): ans = min(ans, bound - (i - 1)) return 0 if ans == n + 1 else ans </code></pre> 时间复杂度: O(nlogn)</li> 空间复杂度: O(n)</li> </ul> 2. 滑动窗口</h3> 看了官方题解才发现这题能够转换为滑动窗口问题，真是没想到。 滑动窗口的精髓在于放大窗口与缩小窗口的过程中，不断调整范围以适应目标，最终找到最优解。这道题求范围之和，正好可以用滑动窗口的思路来调节范围。 用两个指针start和end指向窗口的起始与终止位置，维护一个变量sums不断存储窗口中的元素之和。 end不断后移，扩大窗口范围，sum += nums[end]，直到sums >= target</li> 更新窗口的最小长度</li> start后移，缩小窗口范围，sums -= nums[start]，直到sums < target</li> 更新窗口的最小长度，继续循环</li> </ol> class Solution: def minSubArrayLen(self, target: int, nums: List[int]) -> int: if not nums: return 0 if nums[0] >= target: return 1 n = len(nums) ans = n + 1 start = 0 total = 0 # 外层通过右移end增大窗口 for end in range(n): total += nums[end] while total >= target: ans = min(ans, end - start + 1) # 内层通过右移start缩小窗口 total -= nums[start] start += 1 return 0 if ans == n + 1 else ans </code></pre> 时间复杂度O(n)</li> 空间复杂度O(1)</li> </ul> Rust刚学，不太熟练，直接从Python代码翻译着写了，以后熟练了看看能不能优化一下。 impl Solution { pub fn min_sub_array_len(target: i32, nums: Vec<i32>) -> i32 { if (nums.is_empty()) { return 0; } if (nums[0] >= target) { return 1; } let n = nums.len(); let mut ans = n + 1; let mut start = 0; let mut total = 0; for end in 0..n { total += nums[end]; while total >= target { ans = ans.min(end - start + 1); total -= nums[start]; start += 1; } } if ans == n + 1 { 0 } else { ans as i32 } } } </code></pre> 总结</h3> 区间问题转换为滑动窗口问题，有些场合下是个比较好的思路，可以多练习练习。 leetcode打卡-0151翻转字符串里的单词 2021-04-20T23:50:01+00:00 题目描述</h2> 给定一个字符串，逐个翻转字符串中的每个单词。 说明：无空格字符构成一个单词；输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括；如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。 示例： 输入：s = " Bob Loves Alice " 输出："Alice Loves Bob" </code></pre> 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/reverse-words-in-a-string 解题思路</h2> 1. 无情的API调用工程师</h3> 字符串的分解拼接，大多数高级语言本身或者其标准库内，都有对应的实现，这题可以考虑直接分解字符串s，翻转后再合并成字符串，以Python为例。 class Solution: def reverseWords(self, s: str) -> str: return ' '.join(reversed(s.split())) </code></pre> 一行搞定，简单明了，Python真是拯救头发的好语言。 时间复杂度: O(n)</li> 空间复杂度: O(n)</li> </ul> 用Rust也能写，就是复杂一点。 impl Solution { pub fn reverse_words(s: String) -> String { s.trim().split_whitespace().map(|x| x.to_string()).collect::<Vec<String>>().into_iter().rev().collect::<Vec<String>>().join(" ") } } </code></pre> 2. 双端队列或者栈</h3> 涉及到翻转的问题，可以考虑用栈的前进后出的特性来解决，此题中遍历原字符串，拆分单词，压入栈中，然后弹出组成新字符串即可。 不过Python中的双端队列效率也挺高，按照左端插入的方式，也能得到类似的效果，将单词一个个压入队列头部，最后转成字符串处理。 class Solution: def reverseWords(self, s: str) -> str: left = 0 right = len(s) - 1 # 去掉字符串开头的空白字符 while left <= right and s[left] == ' ': left += 1 # 去掉字符串末尾的空白字符 while left <= right and s[right] == ' ': right -= 1 d = collections.deque() word = [] # 将单词push到队列的头部 while left <= right: if s[left] == ' ' and word: d.appendleft(''.join(word)) word = [] elif s[left] != ' ': word.append(s[left]) left += 1 d.appendleft(''.join(word)) return ' '.join(d) </code></pre> 时间复杂度O(n)</li> 空间复杂度O(n)</li> </ul> 还没学到Rust该怎么写双端队列，后面学会了再来补充一下。 leetcode打卡-0088合并两个有序数组 2021-04-20T18:13:01+00:00 最近开始找工作，面试遇到不止一次合并有序数组/链表这种题了，这里也记录一下，感觉考察频率还挺高。 题目描述</h2> 给你两个有序整数数组nums1和nums2，请你将nums2合并到nums1中，使nums1成为一个有序数组。 初始化nums1和nums2的元素数量分别为m和n。你可以假设nums1的空间大小等于m+n，这样它就有足够的空间保存来自nums2的元素。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/merge-sorted-array 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 解题思路</h2> 1. 合并后再排序</h3> 直接将num2放到num1的剩余空间中，然后对合并后的数组进行排序，这样很简单直观。 class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anything, modify nums1 in-place instead. """ nums1[m:] = nums2[::] nums1.sort() return None </code></pre> 但是这样做就没有用到题目中“有序数组”这个条件了，即使第二步调用的是Python标准库中的sort，前面步骤用切片优化，效率也不是很好。 时间复杂度: O((m+n)log(m+n))</li> 空间复杂度: O(1)</li> </ul> 2. 辅助数组 + 双指针</h3> 阅读题目里的“有序数组”这个条件，可以先建立一个辅助数组tmp，用两个指针p1和p2分别从头遍历num1与num2，依次对比p1和p2所指向值得大小，按顺序将值放入tmp中；遍历完成后，将tmp的值再copy给nums1即可。 class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anything, modify nums1 in-place instead. """ p1 = 0 p2 = 0 p = 0 tmp = [0] * (m + n) while p1 < m and p2 < n: if nums1[p1] <= nums2[p2]: tmp[p] = nums1[p1] p1 += 1 else: tmp[p] = nums2[p2] p2 += 1 p += 1 if p1 == m: tmp[p1 + p2:] = nums2[p2:] elif p2 == n: tmp[p1 + p2:] = nums1[p1:m] nums1[::] = tmp[::] return None </code></pre> 时间复杂度O(m+n)</li> 空间复杂度O(m+n)</li> </ul> 3. 原地合并 + 双指针（从后向前）</h3> 鉴于题目中明确指出“nums1的空间大小等于m+n”，即num1后面的空余空间是足够容纳num2的n个元素的，利用这个条件，可以不申请辅助数组，从两个数组的有效位尾部开始向前遍历，直接将两者对比的结果放到空余空间中。 class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anything, modify nums1 in-place instead. """ p = m + n - 1 while m and n: if nums1[m-1] >= nums2[n-1]: nums1[p] = nums1[m-1] m -= 1 else: nums1[p] = nums2[n-1] n -= 1 p -= 1 nums1[:n] = nums2[:n] return None </code></pre> 这样就避免了辅助空间的申请，可以适当降低一点空间复杂度。 时间复杂度O(m+n)</li> 空间复杂度O(1)</li> </ul> 顺便练习一下Rust impl Solution { pub fn merge(nums1: &mut Vec<i32>, m: i32, nums2: &mut Vec<i32>, n: i32) { let mut i = (m - 1) as usize; let mut j = (n - 1) as usize; let mut p = i + j + 1; while i < (m as usize) && j < (n as usize) { if nums1[i] >= nums2[j] { nums1[p] = nums1[i]; i -= 1; } else { nums1[p] = nums2[j]; j -= 1; } p -= 1; } if j >= 0 { nums1[..j+1].copy_from_slice(&nums2[0..j+1]); } } } </code></pre> leetcode打卡-0080删除有序数组中的重复项II 2021-04-19T16:02:01+00:00 题目描述</h2> 给你一个有序数组nums，请你原地删除重复出现的元素，使每个元素最多出现两次，返回删除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用O(1)额外空间的条件下完成。 来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array-ii 解题思路</h2> 1. 通用套路</h3> 这题和leetcode第26题</a>-删除数组中重复数，几乎一样的思路，26题是只保留1个，此题是保留2个，已经在这里</a>记录过题解。 由于是保留2个相同数字，对于前2个数字，我们可以直接保留。</li> 对于后面的任意数字，能够保留的前提是：与当前写入的位置前面的第2个元素进行比较，不相同则保留。</li> </ul> 将问题衍生至保留k个数字，则可以扩展为： 在有序数组的前k个元素里，每种数字都会符合不超过k个的条件；反向思考，一个数字与写入位置的第前k个元素对比，如果相同，证明写入位置之前已经写满了k个当前元素，那么写入位置就需要寻找一个新元素写入了，如果不同，就把当前元素复制过去补位。 所以，通用的Python实现代码如下： def process(nums, k): # idx记录最初的写入位置，直接保留了前k位 idx = k # 从第k位往后遍历，判断是否满足上面的第二条推定 for x in nums[k:]: if nums[idx-k] != x: nums[idx] = x idx += 1 return idx </code></pre> 时间复杂度O(n)</li> 空间复杂度O(1)</li> </ul> 那么这题的题解就可以写成： # Python3实现 class Solution: def removeDuplicates(self, nums: List[int]) -> int: idx = 2 for x in nums[2:]: if nums[idx-2] != x: nums[idx] = x idx += 1 return idx </code></pre> 练习一下Rust impl Solution { pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 { if nums.is_empty() { return 0; } if nums.len() <= 2 { return nums.len() as i32; } let mut i = 2; for j in 2..nums.len() { if nums[i-2] != nums[j] { nums[i] = nums[j]; i += 1; } } i as i32 } } </code></pre> 总结</h2> 参考之前的题解，注意总结顺序遍历中“保留逻辑”的套路。 leetcode打卡-0027移除元素 2021-04-19T01:52:01+00:00 题目描述</h2> 给你一个数组nums和一个值val，你需要原地移除所有数值等于val的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用O(1)额外空间并原地修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/remove-element 解题思路</h2> 1. 双指针</h3> 这题和leetcode第26题</a>几乎一样的思路，已经在这里</a>记录过题解。 用一个慢指针slow指向有效数组的最后一个位置，用来记录符合条件的数组尾部，用一个快指针fast顺序遍历数组。 当fast指针所指的值与val不一致时，将slow后一位的值改为fast指向的值，slow前进一位，fast继续遍历即可。 # Python实现 class Solution: def removeElement(self, nums: List[int], val: int) -> int: # 双指针法：同删除相同元素方法一样 j = 0 for i in range(len(nums)): if nums[i] != val: nums[j] = nums[i] j += 1 return j </code></pre> 顺便练习一下Rust impl Solution { pub fn remove_element(nums: &mut Vec<i32>, val: i32) -> i32 { if nums.is_empty() { return 0; } let mut i = 0; for j in 0..nums.len() { if nums[j] != val { nums[i] = nums[j]; i += 1; } } i as i32 } } </code></pre> 总结</h2> 对于这种字符串、数组之类的可以直接遍历的题目，利用具体要求提炼出“保留逻辑”，将这种逻辑应用到遍历中的每一个位置即可。 leetcode打卡-0026删除数组中重复项 2021-04-18T23:52:01+00:00 题目描述</h2> 给你一个有序数组nums，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用O(1)额外空间的条件下完成。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array 解题思路</h2> 1. 双指针</h3> 按照正常思维思考这题，可以划分一个额外的临时数组tmp，从头遍历原始数组nums，不断地比较，将新元素放进tmp里，不过题目要求原地删除，所以需要简单修改一下，将新元素直接放到原始nums里去，占用以前元素的位置。 用一个慢指针slow指向有效数组的最后一个位置，用来记录不重复数组的尾部，用一个快指针fast顺序遍历数组。 当fast与slow所指的值不一致时，证明这是两个不重复元素，将slow后一位的值改为fast指向的值，slow前进一位，fast继续遍历即可，最后返回长度即为slow+1。 # Python实现 class Solution: def removeDuplicates(self, nums: List[int]) -> int: if nums == []: return 0 i = 0 length = len(nums) for j in range(1, length): if nums[i] != nums[j]: i += 1 nums[i] = nums[j] return i + 1 </code></pre> 顺便练习一下Rust impl Solution { pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 { if nums.is_empty() { return 0; } let mut i = 0; for j in 1..nums.len() { if nums[i] != nums[j] { i += 1; nums[i] = nums[j]; } } i as i32 + 1 } } </code></pre> 2. 通用套路思维</h3> 如果将原问题的「最多保留1位」修改为「最多保留k位」，问题会更有通用性，例如leetcode第80题</a>。 这个想法来自于宫水三叶</a>的题解，很巧妙，此处参考引证一下。 由于是保留k个相同数字，对于前k个数字，我们可以直接保留。</li> 对于后面的任意数字，能够保留的前提是：与当前写入的位置前面的第k个元素进行比较，不相同则保留。</li> </ul> 第一条很好理解，因为这是有序数组，所以前k个元素里，每种数字都会符合不超过k个的条件；第二条，就是反向思考，一个数字与写入位置的第前k个元素对比，如果相同，证明写入位置之前已经写满了k个当前元素，那么写入位置就需要寻找一个新元素写入了，如果不同，就把当前元素复制过去补位。 所以，通用的Python实现代码如下： def process(nums, k): # idx记录最初的写入位置，直接保留了前k位 idx = k # 从第k位往后遍历，判断是否满足上面的第二条推定 for x in nums[k:]: if nums[idx-k] != x: nums[idx] = x idx += 1 return idx </code></pre> 总结</h2> 双指针的方法很容易想到，在处理字符串问题是比较常用，不过后面的通用解法，它是建立在“数组有序”且“保留逻辑”的基础上，可以作为解决这种字符串问题的套路尝试。 配置Pylance和clangd插件优化vscode下Python和C++的开发体验 2020-12-13T00:56:01+00:00 今天折腾了一下Pylance和clangd插件，用vscode写Python、C和C++的体验好了不少，记录流程以备忘。 Pylance插件</h2> 在vscode的插件商店直接下载安装Pylance</a>就可以了，它依赖于之前的Python</a>插件，这个很简单。 相比与Python插件，Pylance主要是在代码补全和参数提示上更加友好，其他方面，像类型检查、引用跳转以及docstrings上也做得不错，不过代码调试、格式化之类的工作还是要交给Python插件完成。 启用Pylance的方法是，在设置里将Python插件的languageServer选取为Pylance，对应的json格式配置为： "python.languageServer": "Pylance" </code></pre> Pylance默认的配置已经比较好使了，不过额外的输入时类型检查默认是关闭的，可以简单修改成basic，还有个strict模式，感觉似乎过于严格了，修改的配置为： "python.analysis.typeCheckingMode": "basic" </code></pre> 这样配置后，敲Python代码也很愉悦了。 clangd插件</h2> 论坛里看到有人推荐clangd插件代替微软的C/C++插件，去商店把这个clangd</a>下载来体验了一下，看发布者名字，应该是LLVM官方提供的。 clangd是LLVM项目的一个language server，在Qt Creator中默认集成了，对于C/C++代码的补全、提示都很友好。 安装好clangd插件后，第一次打开C/C++代码时，插件会检查系统有无安装clangd，如果没有，可以根据提示直接下载，一步到位。 clangd插件默认的配置项比较少，但是部分配置是可以通过命令行参数形式，在clangd启动时传给它的，这样就很灵活了，对应的vscode配置项是clangd.arguments</code>。例如，我的Windows系统下装的编译器有msvc、minGW和clang，为了让clangd使用minGW的配置、头文件、库等，需要给clangd传递“–query-driver”参数，对应插件的配置是如下，clangd启动时，列表内的这行配置就传递给了它。 "clangd.arguments": [ "--query-driver=D:\\HeavyProgram\\Qt\\Tools\\mingw810_64\\bin\\g" ] </code></pre> 配置Compilation Database</h3> 根据clangd配置页</a>的说法，clangd需要通过Compilation Database</code>来查找AST之类的索引信息，这是一份json格式的文件，默认文件名为“compile_commands.json”，所以在让clangd工作之前，先得生成这个文件，具体的Compilation Database</code>说明可以查看LLVM官方文档</a>。 目前有很多工具都能生成Compilation Database</code>，我比较习惯用CMake，手动生成需要使用cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1</code>参数，好在vscode的CMake插件</a>默认是会生成它的。 由于clangd会在项目根目录查找compile_commands.json</code>，而CMake插件自动生成的文件一般是在build目录下，这就需要修改插件的copyCompileCommands</code>配置，让它把该文件复制到项目根目录下，配置如下： "cmake.copyCompileCommands": "${workspaceFolder}/compile_commands.json" </code></pre> 这样每次CMake生成后，compile_commands.json</code>文件就自动出现在工作区根目录，clangd插件再根据这个文件做相应的初始化配置。 关于Debug</h3> clangd的代码补全、提示等是比微软官方的C/C++插件</a>快速而且友好很多，但是并未提供调试功能，所以想要debug还是需要C/C++插件的配合。 装好C/C++插件后，为了防止它的IntelliSense功能与clangd插件冲突，需要把这些冲突配置项全部关闭，只用它来作为调试使用的插件，需要的配置项如下： "C_Cpp.autocomplete": "Disabled", "C_Cpp.errorSquiggles": "Disabled", "C_Cpp.intelliSenseEngine": "Disabled", "C_Cpp.formatting": "Disabled" </code></pre> 这样，clangd与C/C++这两个插件就可以同时工作了，一个用于写代码，一个用于调试。 给MobaXterm写了个专业版许可证生成器 2020-12-06T02:03:01+00:00 用MobaXterm代替Xshell很久了，免费版体验十分不错，目前Github上也有了关于它的注册码生成器MobaXterm-keygen</a>。 看了一下这个注册机的源码，mobaxterm的许可证生成原理很简单，主要是通过字符翻转，结合用户名、版本类型、用户数以及版本号生成的字符串，将它保存到名为Pro.key的文件中，再用zip方式将其压缩成名为Custom.mxtpro的文件。最终把这个Custom.mxtpro放置到MobaXterm根目录既可，MobaXterm运行时，若检查到有这个许可证，即会改变工作模式，切换成专业版。 因为Github上只提供了Python脚本，这里用Qt/C++给它写了个带UI的版本，方便使用，实际运行效果如下： 完成后在放入MobaXterm根目录后效果如图所示： MobaXterm是个很优秀的产品，在其免费版中依然提供了较为完善的功能，使用专业版的话，最好还是应该支持付费购买。 关于单例模式在C++下的实现方式 2020-12-01T23:13:01+00:00 最近学习C++的时候，看到了一些关于全局变量使用上的优劣点，其中有些资料中认为单例模式是更好的实现，单例可认为是更优雅的全局变量。因为此模式是用来确保一个类仅存在一个实例，并提供对此唯一实例的全局访问节点，更为方便的是，它为对象的分配、销毁提供了控制，同时也能避免污染全局命名空间。 在C++中实现单例</h2> C++中实现单例方法主要是通过隐藏构造函数来实现的。 简单实现的基本步骤</h3> 单例模式对外提供的接口，每次调用时返回类的同一个实例，考虑到C++的语言特性，设计单例类的实现步骤可以如下： 为了防止客户端自由创建新的实例，应该防止编译器自动声明公有的构造函数，所以需要将默认构造函数声明为私有或保护。</li> 防止通过复制方式生成第二个实例，则需要将拷贝构造函数和赋值运算符也声明为私有或保护。</li> 增加一个静态私有的指针变量，指向当前类。</li> 提供静态的对外接口，让客户端获得上一步中单例类的指针，从而获得实例对象。不过考虑到客户端可以通过指针删除此对象，因此返回引用似乎更加稳妥。</li> </ol> C++代码的简单实现</h3> 通过上面的步骤，写出的代码如下所示： class Singleton { protected: Singleton(const std::string value) : m_name(value) {} static Singleton instance; std::string m_name; public: Singleton(Singleton &other) = delete; void operator=(const Singleton &) = delete; static Singleton getInstance(const std::string &value); std::string value() const { return m_name; } }; Singleton Singleton::instance = nullptr; Singleton Singleton::getInstance(const std::string &value) { if (instance == nullptr) { instance = new Singleton(value); } return instance; } </code></pre> 通过上面的代码中的getInstance方法，尝试简单生成多个实例，会发现它们其实是同一个实例。因为其中的实例化操作检查，如果instance不为null，获得的就还是第一次实例化的instance，这样便达到了单例模式的目的。 线程安全的单例模式</h3> 上述的简单模式在单线程下可以正常运行，但是考虑到程序可能是在多线程的情况下执行，例如用下面的代码进行测试： void ThreadFoo() { // 延迟初始化 std::this_thread::sleep_for(std::chrono::milliseconds(1000)); Singleton singleton = Singleton::getInstance("FOO"); std::cout << singleton->value() << " "; } void ThreadBar() { std::this_thread::sleep_for(std::chrono::milliseconds(1000)); Singleton singleton = Singleton::getInstance("BAR"); std::cout << singleton->value() << " "; } int main() { std::cout << "RESULT: "; std::thread t1(ThreadFoo); std::thread t2(ThreadBar); t1.join(); t2.join(); return 0; } </code></pre> 最终执行结果可能是RESULT: BAR FOO </code>，也可能是RESULT: FOO BAR </code>，或者输出两个相同值。如果两个值相同，证明它们是同一个实例，不同的情况，则说明两个线程创建了两个不同的Singleton实例，所以它不是线程安全的。 为确保线程安全，常用的方案之一就是加锁，对Singletion类加锁改造的代码如下： class Singleton { private: static Singleton instance; static std::mutex m_mutex; protected: Singleton(const std::string value) : m_value(value) {} ~Singleton() {} std::string m_value; public: Singleton(Singleton &other) = delete; void operator=(const Singleton &) = delete; static Singleton getInstance(const std::string &value); std::string value() const { return m_value; } }; Singleton Singleton::instance = nullptr; std::mutex Singleton::m_mutex; /** * 调用getInstance时会获得锁，保证线程安全 / Singleton Singleton::getInstance(const std::string &value) { std::lock_guard<std::mutex> lock(m_mutex); if (instance == nullptr) { instance = new Singleton(value); } return instance; } </code></pre> 这样测试结果就会变成RESULT: BAR BAR </code>或者RESULT: FOO FOO </code>，从而保证了线程安全。 使用双检查锁改善线程安全单例的性能问题</h3> 上面的代码虽然确保了线程安全，但是getInstance方法每次被调用时，都会请求加锁，如果实际场景中客户端并未频繁请求此方法，则不用考虑对它进行优化。 但是出于API设计的责任主要在设计者而不是客户端的考虑，不应该建议客户端只调用一次方法，而应该针对性能场景改进这个单例的设计，减少多次请求锁而造成的开销。 所以此时，可以在请求锁前再添加一次判断，如果实例存在，则直接返回实例对象。这样多线程在第一次调用方法时，会进行请求锁的操作，而在其后的同样操作中，就跳过了锁操作。 使用双检查锁改造后的getInstance方法如下： Singleton Singleton::getInstance(const std::string &value) { if (instance == nullptr) { std::lock_guard<std::mutex> lock(m_mutex); if (instance == nullptr) { instance = new Singleton(value); } } return instance; } </code></pre> 双检查锁的弊端：编译器reorder</h3> 在instance = new Singleton(value)</code>这句代码中，其实是假定机器做了如下三件事： 在堆上为Singleton对象分配空间；</li> 在此空间上初始化对象；</li> 返回此对象的指针，即让instance指向这块空间。</li> </ol> 历史上很长一段时间，编译器的优化策略，使得代码并不是完全按照这个顺序执行的（包括其它编程语言），有可能2、3步骤会互换次序，所以多线程环境，两个线程A、B第一次调用getInstance方法时，可能发生这样的事情： 线程A进入，此时instance为null，A获得锁，完成了step1、step3，此时A的时间片用完，线程A被挂起；</li> 线程B进入，先判断instance，此时instance由于线程A的关系，并不是nullptr，则线程B直接获得了instance实例；</li> 而此时instance只是指向了分配的空间，该空间并未执行初始化，所以线程B想利用instance执行对象操作，都是不合法的。</li> </ol> C++11后对于reorder的解决</h3> 像Java与C#之类的编程语言，在早期通过加入volatile解决reorder问题，msvc 2005版本也是加入了volatile，但这样的C++实现就无法跨平台。 在文章《Double-Checked Locking is Fixed In C++11》</a>中，介绍了通过获取与释放内存fence的方法来避免reorder，改造后的Singleton类是这样的： std::atomic<Singleton > Singleton::instance; std::mutex Singleton::m_mutex; /** * 调用getInstance时会获得锁，保证线程安全 / Singleton Singleton::getInstance(const std::string &value) { Singleton tmp = instance.load(std::memory_order_relaxed); std::atomic_thread_fence(std::memory_order_acquire); //获取内存fence if (instance == nullptr) { std::lock_guard<std::mutex> lock(m_mutex); tmp = instance.load(std::memory_order_release); if (tmp == nullptr) { tmp = new Singleton(value); std::atomic_thread_fence(std::memory_order_release); //释放内存fence instance.store(tmp, std::memory_order_relaxed); } } return tmp; } </code></pre> 从逻辑上这样处理，使得操作愈发复杂，它的流程示意如下： C++11标准中更简洁的做法</h3> 在C++11标准中，静态局部变量是只会初始化一次，并且还是线程安全的，所以更简洁的思路是从语言特性方向简化，将上面的检查逻辑完全跳过，直接使用静态局部变量作为实例返回。代码如下： class Singleton { protected: Singleton(const std::string value) : m_value(value) {} std::string m_value; public: Singleton(Singleton &other) = delete; void operator=(const Singleton &) = delete; static Singleton &getInstance(const std::string &value) { // 在这里提供一个静态局部变量 static Singleton instance(value); return instance; } std::string value() const { return m_value; } }; </code></pre> 这种写法大大减少了代码量，简洁而且跨平台，不过只能在支持C++11标准的编译器下执行。在C++11之前，这个写法的结果并不一定正确，因为C++11标准规定了，当一个线程正在初始化一个变量的时候，其他线程必须得等到该初始化完成以后才能访问它。 不使用延迟初始化的方案</h3> 再仔细思考上述实现方法，它们涉及到的线程安全问题，主要是在初始化的时候，由于资源竞争导致的，因为延迟初始化给了不同线程调用同一个接口的机会。如果使用的单例属性相对固定，可以考虑不使用延迟初始化，在主线程运行时直接先生成一个实例，就避免了不同线程之间的竞争。可以在最初的方案上简单修改： class Singleton { protected: Singleton(const std::string value) : m_name(value) {} static Singleton instance; std::string m_name; public: Singleton(Singleton &other) = delete; void operator=(const Singleton &) = delete; static Singleton getInstance(); std::string value() const { return m_name; } }; // 这里提前初始化它 Singleton Singleton::instance = new Singleton("FOO"); Singleton Singleton::getInstance() { return instance; } </code></pre> 单例模式的缺点</h2> 虽然开始说了单例模式的的优点，但是单例模式也只是一种优雅的全局状态维护的方式，我们始终需要考虑，是否需要全局状态。 它可能会在API中引入难以重构的依赖，同时也使得单元测试变得困难。另外，单例模式违反了单一职责原则，因为它同时实现了了两个职责：只有一个实例，以及提供一个访问该实例的全局节点。 所以，是否使用单例模式，还是要考虑到实际的场景，再做决定。 在Windows下配置MinGW版Qt的Clang编译器 2019-09-21T23:02:01+00:00 今天在Windows下安装MinGW版本的Qt5时，发现mkspecs目录下有了win32-clang-g++这个文件夹，看起来MinGW版的qmake似乎也支持Clang的spec了，下面记录了一下验证和配置的过程。 下载与安装Windows版Clang</h1> Clang的安装可以选择下面任意一种方式。 使用LLVM官网预编译版本</h2> 在LLVM Download Page</a>页面可以下载LLVM官方预编译好的LLVM Windows包（写这篇时，最新的包是9.0.0）。这个包里面主要包含Clang, LLD, compiler-rt, 还有一些别的LLVM tools之类的，直接安装就可以了。 使用Qt的预编译版本</h2> 在Qt Downloads</a>页面可以下载Qt官方预编译好的libClang Windows包（写这篇时，最新的包是8.0.1）。这个包里面主要包含Clang以及一些基本的Clang工具。我这里下载的是libclang-release_80-based-windows-mingw_64.7z</code>，解压后将bin路径加入系统环境变量以方便正常使用。 手动编译</h2> 如果想对编译选项做一些调整，可以手动编译LLVM项目，不过略微耗时了，可以参考LLVM官方文档</a>编译使用。 配置Clang的C++标准库</h1> 由于LLVM的标准库libc++并不支持Windows平台，所以Clang需要配置一下，让它使用Qt目录下MinGW的标准库。以LLVM官网的预编译包为例，直接编译下面这段代码： #include <iostream> using namespace std; int main() { cout << "Hello World!" << endl; return 0; } </code></pre> 会显示fatal error: 'iostream' file not found</code>的错误，而且我们敲一下clang++ -v</code>，结果如下： clang version 9.0.0 (tags/RELEASE_900/final) Target: x86_64-pc-windows-msvc Thread model: posix InstalledDir: D:\HeavyProgram\LLVM\bin </code></pre> 可以看到LLVM官网预编译的Clang默认Target为x86_64-pc-windows-msvc</code>，是配合msvc编译器使用的，要让Clang使用MinGW，需要为clang指定命令行选项–target，这里可以使用--target=x86_64-pc-windows-gnu</code>、--target=x86_64-w64-mingw32</code>，或者--target=x86_64-w64-windows-gnu</code>。（如果是使用上面Qt预编译版本的Clang则不需要此操作，默认为x86_64-w64-windows-gnu</code>）。 所以如果在命令行下执行Clang的话，也需要把MinGW的bin目录加入环境变量，这样Clang就会通过g++来寻找头文件与库文件，此操作可以直接set PATH</code>或者手动添加。而在Qt Creator中执行则不需要，那里已经配置好了环境。 在Qt Creator中配置Clang</h1> 配置编译器选项</h2> 在Qt Creator编译器中添加Clang的路径并应用，如图所示：注：如果使用的是Qt预编译版的Clang则只需要让Qt Creator自动发现即可，无需手动添加，LLVM官网的Clang才需要手动添加编译器以使ABI对应。 配置一个新的Kits</h2> 这里我直接克隆了一个，将编译器选项都改为Clang后，还要注意将Qt mkspec改为win32-clang-g++</code>。如图所示：此处选择GDB而非LLDB作为调试器，是因为LLVM预编译版的ABI不对应，如果有ABI对应的LLDB版本，也可以选择它作为调试器。 配置CMAKE选项（可选）</h2> 如果是使用LLVM官网预编译的Clang则需要此步骤，否则可跳过。在CMake Configuration中添加这两行，用以配合Clang的target： CMAKE_CXX_FLAGS:STRING=--target=x86_64-w64-windows-gnu CMAKE_C_FLAGS:STRING=--target=x86_64-w64-windows-gnu </code></pre> 如图所示： 完成上述步骤后，就可以在MinGW版的Qt中使用Clang编译器了，同时支持QMake与CMake。 对于Android 7.0以上版本设备的抓包方法 2018-08-06T23:50:01+00:00 最近在一台Android 8.0设备上用fiddler抓包公司app时发现无法解析包内容，换用charles也是同样的结果，于是稍微研究了一下这背后的原因。 通过查阅Android Developer文档，发现在网络安全性配置</a>一节中，有如下描述： 一般情况下，应用信任所有预装 CA。如果有预装 CA 签发欺诈性证书，则应用将面临被中间人攻击的风险。有些应用通过限制信任的 CA 集或通过证书固定来选择限制其接受的证书集。 </blockquote> An app that does not want to trust all CAs trusted by system can instead specify its own reduced set of CAs to trust. This protects the app from fraudulent certificates issued by any of the other CAs. </blockquote> 于是出于安全性考虑，在面向 Android 7.0（API 级别 24）及更高版本应用的默认安全配置如下所示： <base-config cleartextTrafficPermitted="true"> <trust-anchors> <certificates src="system" /> </trust-anchors> </base-config> </code></pre> 而面向 Android 6.0（API 级别 23）及更低版本应用的默认配置如下所示： <base-config cleartextTrafficPermitted="true"> <trust-anchors> <certificates src="system" /> <certificates src="user" /> </trust-anchors> </base-config> </code></pre> 通过对比可以看出，在7.0之后的版本里，对证书的信任级别默认是系统级别，从某种意义上来说相当于减小了对于证书信任程度的粒度，app可以选择不信任我们手动安装的的fiddler或者charles证书，这就是问题所在，以至于基于https的通信中，中间人身份不被信任，所以无法解析包内容。 关于解决方法，也是非常简单，可以征求app开发人员的意见，修改app中network_security_config.xml</code>的配置，使应用信任我们所需要的证书，然后在AndroidManifest.xml</code>中添加一个区块，包含network_security_config.xml</code>的路径即可，一般如下所示： <?xml version="1.0" encoding="utf-8"?> <manifest ... > <application android:networkSecurityConfig="@xml/network_security_config" ... > ... </application> </manifest> </code></pre> 基于实验目的，我简单粗暴反编译了一下app，修改默认配置为Android 6.0的配置，果然可以在7.0之后的设备上正常抓包了。 在python3中使用异步方法处理并发 2018-07-19T23:50:01+00:00 随着python 3.7版本的正式发布，async/await终于也变成了关键字，从python 3.5引入这个新语法以来，已经过了3年，python异步编程也逐渐变成了重要的概念。 之前我一般使用线/进程池来处理并发，现在是时候学习一下标准库的异步框架了。 1. 传统的同步方法处理IO问题</h3> 由于python中GIL锁的存在，传统的计算密集型事务一般采用多进程模型，而IO密集型则多用相对轻量一点多线程模型。例如常见的一种场景，爬虫大批量下载内容的时候，线程池是一种常用的技术。 下面先用普通的同步方法下载一组图片，这里简单起见使用wallhaven上的图片，一方面是因为它的url定义很简单，另一方面这个站点在我这里连接比较慢，容易体现出各种方法的差异性，简单起见，实现下载的函数使用了requests库。（注：2020年，wallhaven已经更改了链接样式，请使用其它站点或方法测试。） # -- coding: utf-8 -- import requests # 演示用代码，简单起见假设路径都已经存在 save_folder = os.path.abspath('./imgs/') def sync_fetch_img(id): """根据图片id下载，使用同步方法，不验证ssl以节省时间.""" ul = f'https://wallpapers.wallhaven.cc/wallpapers/full/wallhaven-{id}.jpg' img_data = requests.get(ul, verify=False) if img_data.status_code != 200: return img_name = f'sync-wallhaven-{id}.jpg' img_path = os.path.join(save_folder, img_name) with open(img_path, 'wb') as f: f.write(img_data.content) print(f'Download complete - {id}.jpg') def sync_fetch_all_imgs(): """按顺序同步下载所有图片.""" for current_id in range(30000, 30050): sync_fetch_img(current_id) </code></pre> 在网络环境稳定的情况下，使用这种方法下载了49张图片，多次平均之后花费时间是42.9s。 2. 多线/进程处理IO的并发问题</h3> 这里简单起见就直接使用线程池了，当然进程池效率区别也不大，sync_fetch_img函数沿用上面的，主要原理就是在线程池中取出线程并发地发送请求。 def concurrent_fetch_all_imgs(modes): """使用进/线程池下载所有图片.""" if modes == 'p': from concurrent.futures import ProcessPoolExecutor as img_executor elif modes == 't': from concurrent.futures import ThreadPoolExecutor as img_executor else: print('Modes only support "p" or "t".') return with img_executor(max_workers=None) as executor: # 当max_worker设置为None时，线程池的worker数目使用处理器数目乘以5，进程池为处理器数 executor.map(sync_fetch_img, range(30000, 30050)) </code></pre> 在5个线程的情况下，下载时间的平均值为22.9s。 3. 基于标准库asyncio的异步处理方法</h3> asyncio实际上是由python中的yield一步一步演化来的，先用asyncio配合aiohttp这个异步网络库试一试，主要就是异步发送请求，无需等待，异步的获取结果这种过程。 import aiohttp async def async_fetch_image(loop, id): """根据图片id下载，使用异步方法.""" url = f'https://wallpapers.wallhaven.cc/wallpapers/full/wallhaven-{id}.jpg' # 同理不验证ssl async with aiohttp.ClientSession(loop=loop) as session: async with session.get(url, ssl=False) as response: if response.status != 200: return img_name = f'async-wallhaven-{id}.jpg' img_path = os.path.join(save_folder, img_name) # 流式下载分块写入相对稳妥一点 with open(img_path, 'wb') as fd: while True: chunk = await response.content.read() if not chunk: break fd.write(chunk) print(f'Download complete - {id}.jpg') </code></pre> 这里实现了一个基本的异步下载函数，关于它的使用方法就是把它放到事件循环里执行，写法相当简洁，如下所示： import platform import asyncio # 使用uvloop比默认的事件循环效率高一点 if platform.system() != 'Windows': import uvloop asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) dl_loop = asyncio.get_event_loop() dl_loop.run_until_complete( asyncio.gather((async_fetch_image(dl_loop, id) for id in range(30000, 30050)))) </code></pre> 在这种异步处理的情况下，下载时间的平均值为22.9s。 4. 关于结果的分析</h3> 第一种方案里同步获取，图片一张一张地下载，效率较低；第二种方案里实际上启动了5个线程，理论上速度会接近第一种的5倍，但实际上只是2倍左右，查看当时网络统计，发现是因为测试环境的小水管带宽倍跑慢了，制约了速度的上限；同理，第三种也是受到了网络带宽的约束，因此耗时与第二种相同。 下次需要找个更好的网络环境再测一遍。 C语言基础之预处理机制 2017-10-25T23:52:01+00:00 写这篇的原因，是前两天半夜拉肚子时，突然一个大二的学弟在QQ上找我问了这个问题，想想人家凌晨还在学习，真是有点惭愧；另一方面，大半年不写C语言，有点儿生疏了，做一下记录。 学弟最近在学习二叉树，他想用C语言实现，大致内容就是在一个名为BiTree.h</code>的头文件里定义了二叉树的节点结构体BNode</code>，另外两个头文件Queue.h</code>和Stack.h</code>由于也需要使用这个结构，所以都分别都有#include "BiTree.h"</code>，最后主文件1.c</code>里先后引用了Queue.h</code>和Stack.h</code>。 看起来结构如下图，于是他在VS环境下编译执行时，就会报错 — “BNode”:“struct“类型重定义。 这个问题很容易明白，头文件实际上被源文件包含了两次，所以就会报“重定义”错误。 最直接的解决方法就是条件编译，例如在BiTree.h</code>里这样编写： #ifndef _BITREE_H #define _BITREE_H / * xxx / #endif </code></pre> 这样就消除了多重包含的危险，当头文件第一次被包含时，它被正常处理，_BITREE_H</code>被定义成一个空串，当然也可以改变写法定义成别的。如果头文件再次被包含，由于_BITREE_H</code>已经被定义了，这个头文件的内容将被忽略，_BITREE_H</code>起到了一个标识的作用。 这大概就是条件编译的原理了。 C语言的编译过程包括：预处理、编译、汇编和链接。其中预处理阶段主要是在源码编译前，做一些文本性质的处理操作。例如插入被#include</code>指令包含的文件内容、定义替换#define</code>指令定义的符号、删除注释，以及判断条件编译指令中的条件，以确认某些部分是否要被编译。 1 文件包含</h2> 预处理器处理#include</code>指令时，做的事情一般非常简单，删除这条指令，并用被引用文件的内容替换掉它即可，所以上文中出现的重定义问题就是由此引起。 而且如果是头文件被包含，则其中的内容都要被编译，一旦头文件被多个源文件包含，就会被完整重复编译多次，这还是会产生一点儿开销的。因此考虑到效率，以及程序模块化的原则，只把必要的声明放在一个头文件中，用多个粒度小的源文件，代替一个大粒度的源文件，是很有必要的。一方面维护程序时，定位起来比较方便；另一方面，可以减小意外访问的几率。 1.1 库文件包含</h3> 库文件的包含语法一般使用尖括号，例如常见的: #include <stdio.h></code>。 至于预处理器去哪里寻找库文件，这取决于编译器的文档定义，以及使用的操作系统环境。 当然，大多数编译器也有命令行选项，用以指定头文件函数库的位置，我们可以自己添加目录。 1.2 本地文件包含</h3> 本地文件的包含语法一般使用双引号，例如上文的: #include "BiTree.h"</code>。 通常处理本地头文件的方法是在源文件当前的目录查找，如果未找到，则继续查询标准位置。使用相对位置则会在相对于本源文件的位置查找。 C语言的编译器也支持绝对路径的写法，类UNIX系统中绝对路径以/</code>开头，而windows环境以\</code>开头，预处理器如果发现包含的是绝对路径，则会跳过正常的查找顺序，直接查找该绝对路径位置的头文件。 1.3 嵌套文件包含</h3> 上文开始处的例子就是文件的嵌套包含，在大型项目中，使用的头文件会非常多，就很难避免这种情况，解决问题的方法可以使用前文中的条件编译。 但是即使如此，预处理依然会读入整个头文件，虽然它的内容最终还是被忽略。但是这个机制会拖慢整个编译速度，所以如果能做到的话，尽量减少头文件的多重包含是最好的。 2 条件编译</h2> 编译的时候，如果能够选择某个语句或者代码块是否被编译，会显得比较方便，例如调试代码的部分，只有在调试的时候会被编译，正常使用的时候，又会忽略它们。 C语言中，条件编译机制可以满足这一点，它的基本结构是由#if</code>与#endif</code>构成的判断代码块，如下所示: #if 常量表达式1 可执行代码块1 #elif 条件2 常量表达式2 #elif xxx ... #endif </code></pre> 如果我们想编译某一块，只要使用#define 常量表达式xxx 1</code>即可，想要忽略则定义成0，这样虽然代码依然保留，但是编译器会根据条件选择性地处理。 另一个方面，这个特性可以用来处理判断一个符号是否被定义，即#if defined(symbol)</code>与#if !defined(symbol)</code>，不过我们一般用它的等价形式来写，即#ifdef</code>与#ifndef</code>。 3 宏</h2> 由于预处理器处理#define</code>的机制主要是文本替换，所以我们可以通过这个机制将参数替换到文本中，这种实现叫做宏。 一些C语言笔试题里常会考到宏机制中的坑，例如： #include<stdio.h> #define ADD(X) X+X int main() { int m = 10 ADD(2); printf("m = %d\n", m); return 0; } </code></pre> 这个程序原意是要计算10(2+2)</code>的结果，但是由于宏函数也是文本替换，所以实际上计算中是这样的：102+2</code>，结果就大不相同了，因此定义宏函数时最好加上括号。 为了方便识别，约定俗称的宏写法是全大些字母。 宏函数与普通函数相比，它的执行速度更快，因为普通函数存在函数调用与函数返回的开销；宏函数的参数是替换得来的，与类型无关，但普通函数的参数是类型相关的。 另一方面，宏定义的末尾是不要分号的，因为它被替换为文本之后，这个分号就截断了原有的语句。 基本排序算法之希尔排序的Python实现 2017-09-27T23:52:01+00:00 希尔排序(Shell Sort)也是插入类排序的一种，因DL.Shell提出而得名，因为直接插入排序每次只能移动一位，效率因此大打折扣，而且直接诶插入排序在元素有序时效率最高，希尔排序针对这一特点做了改进。 希尔排序的核心思想是将元素序列按照下标增量分割成几个子序列，对这几个子序列分别进行直接插入排序，完成一趟排序后使得元素序列变得相对有序，于是对分组使用直接插入排序的效率变高，再逐渐减小增量值重复前面的操作，这样便提高了整体的排序效率。 用Python3的方法很简单实现，代码如下： def shell_sort(lists): """希尔排序""" gap = len(lists) // 2 while gap > 0: for i in range(gap, len(lists)): temp = lists[i] j = i - gap while j >= 0 and lists[j] > temp: lists[j + gap] = lists[j] j -= gap lists[j + gap] = temp gap //= 2 return lists </code></pre> 可以看出，这里使用的初始步长为元素列表的一半，将列表分为两组后，分别进行了直接插入排序，然后在将步长折半，重复操作直到步长为1。其实也可以有另外的更高效的步长选择，这在希尔排序的维基百科上有相关讨论。 随机生成10000个数测试一下，结果如下图所示： 结果显示，希尔排序相比直接插入排序，效率大大提高了。 希尔排序的时间复杂度为O(Nlog2N)，而且是不稳定的排序，因为它在不断的分组交换过程中，可能会改变已有相同值的顺序。 基本排序算法之直接插入排序的Python实现 2017-09-17T20:20:01+00:00 前两篇中，无论是冒泡排序还是快速排序，他们的核心思路都是“交换”，通过一系列的“交换”过程，使得数据有序归位。除了基于交换类的排序，常见的还有插入类的排序，例如直接插入排序。 直接插入排序的思想也很“直接”：每次排序将一个待排序的元素作为关键字，将这个关键字按照顺序插入前面已经有序的元素序列中，直到插入完成。 一般情况下的做法是，从第一个元素开始，此时第一个元素便是有序序列的唯一元素，然后将第二个元素插入这个“有序序列”，然后第三个，以此类推即可。 于是用Python3的方法很容易实现，代码如下： def insert_sort(lists): """直接插入排序""" length = len(lists) for i in range(1, length): temp = lists[i] j = i - 1 while j >= 0 and lists[j] > temp: lists[j + 1] = lists[j] j -= 1 lists[j + 1] = temp return lists </code></pre> 可以看出，先是在有序序列中找到不大于关键字的位置，然后将关键字插入，在插入的这一过程中，依然是基于交换的，但由于该算法的基本思想是一次次的插入，所以一般不归为交换类排序。 随机生成10000个数测试一下，结果如下图所示： 结果显示直接插入排序只是比冒泡排序略快一点而已，比快速排序要慢很多，更不用和sorted方法比了。 分析直接插入排序的时间复杂度： 考虑最坏的情况，整个原始序列是逆序的，则每次内层循环都要完整执行一遍，总的执行次数达到n(n-1)/1，所以时间复杂度是O(n²)；</li> 最好的情况是原始序列本身有序，则内层循环不执行，所以时间复杂度是O(n)。</li> </ol> 综合两种请情况来看，直接插入排序的时间复杂度为O(n²)，并不是一种高效的算法，但是其实现相对简单，适用于小规模的数据处理。 在上面的实现中，不会对相同的值做交换，因此这种插入排序的实现是稳定的。 基本排序算法之快速排序的Python实现 2017-09-06T23:02:01+00:00 上一篇中简单实现了冒泡排序，但顾名思义，快速排序的效率会高一如果待排序list中元素数目为0或1这返回；</li> 在list中任取一个元素作为枢纽(pivot)；</li> 改pivot将list分割成两部分，小于对small_list与greater_list重复上述 </ol> 基于这种原理，很容易用Python3的方法实现如下： </code></pre> 随机生成5个数测试一下，结果如下图所示： 可以看出虽然排序结果没有问题首先解决计时的问题，这是pytho 另一方面，由于这个实现开辟了 </code></pre> 这样直接在原列表里操作，当然 相比第二种冒泡排序，确实快了在别的一些编程语言里，我们可快速排序中，选取枢纽元其实也另一方面，相比冒泡排序，快速稳定性：稳定排序算法会让原本 </blockquote> 而快速排序可能会改变原有稳定基本排序算法之冒泡排序的Python实现 2017-09-02T23:02:01+00:00 是这种基于反复交换的算法，每次只比较相邻的两个数，处理大规模数据时效率相当低下，这时候另一种交换算法 - 快速排序就有用武之地了。些，其原理也很简单，是在交换算法中使用“分治法”的思想，大致如下： 等于pivot的元素列表作为small_list，大于pivot的作为greater_list；</li> 步骤，递归调用直至无法分割。此时得到最终排序后的order_list。</li> z-code">def quick_sort1(lists): """快速排序的递归实现""" less = [] greater = [] if list_check(lists) is False: return lists pivot = lists.pop() for val in lists: if val <= pivot: less.append(val) else: greater.append(val) return quick_sort1(less) + [pivot] + quick_sort1(greater) ，但是递归的过程导致装饰器反复计时，以及先为空的列表也被反复打印提示。 n语法糖引起的，用@time_usage</code>修饰的quick_sort1函数，其实相当于quick_sort1 = time_usage(quick_sorted1)</code>，于是递归的时候每次都要在它的作用域内执行时间函数，所以这里就不用语法糖实现它，而改成time_usage(quick_sort1)(RAND_LIST)</code>直接调用就可以了。 新的空间，导致递归中不停的出现空列表，所以会打印出一堆提示来，所以将它改成“就地”排序的操作，即在被分割的列表里直接交换元素，而不把它们存在新的列表里，改进后代码如下： z-code">def quick_sort2(lists): """不需要额外开辟空间的快速排序""" if list_check(lists) is False: return lists quicksort_helper(lists, 0, len(lists)-1) class="z-meta z-function z-python">def quicksort_helper(lists, first, last): """另一种递归实现""" if list_check(lists) is False: return lists if first < last: splitpoint = partition(lists, first, last) quicksort_helper(lists, first, splitpoint - 1) quicksort_helper(lists, splitpoint + 1, last) class="z-meta z-function z-python">def partition(lists, first, last): """按枢纽点分割列表并返回分割点""" pivotvalue = lists[last] leftmark = first rightmark = last - 1 flags = False while not flags: while leftmark <= rightmark and lists[leftmark] <= pivotvalue: leftmark += 1 while lists[rightmark] >= pivotvalue and rightmark >= leftmark: rightmark -= 1 if rightmark < leftmark: flags = True else: lists[leftmark], lists[rightmark] = lists[rightmark], lists[leftmark] pivotvalue, lists[leftmark] = lists[leftmark], pivotvalue return leftmark 也直接改变了原本的列表元素顺序，下面用它与第二种冒泡排序以及内置sorted函数对比一下效率，使用990个随机数得出的结果如下： 一些，但是如果我们使用大的数据量，例如当排序10000个数时，发现其会报错，内容为RecursionError: maximum recursion depth exceeded in comparison</code>，因为已经超出了python的默认的递归深度，虽然我们可以用import sys; sys.setrecursionlimit(20000)</code>这种方法将递归深度加大，但是这并不是一种优雅的做法。 以使用尾递归来实现快速排序，但是python并没有尾递归优化，所以这里并不是明智的选择；递归中的这种问题大多可以转化成迭代去解决，但是由于需要利用栈手动保存中间变量，实际效率会降低一些，这里就不去实现了。 会影响算法的执行效率，目前对此算法常用的选取枢纽元的方法为“三数中值分割法”，即选取左端、右端以及中心位置上的三个元素的中值作为枢纽元。 排序属于不稳定排序，这里引用维基百科对于稳定性的解释： 有相等键值的纪录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。 的键值对顺序，因此是不稳定的。 最近因为业务需要，开始学习Python，作为C/C++程序员，一开始写Python总是忍不住在每行后面加个‘;’。当然除了语法，还是要把基本的数据结构和算法都简单的复习一遍的，下面开始从几类常见的排序开始实现，虽然python自带的sorted方法很好用，但是可以用自己的方法与它做一下比较。以下的代码均在Python 3.6环境下验证通过，排序对象为整形列表，按照由小到大的方式排序。 冒泡排序的原理非常简单，就是个双层循环的过程，列表元素像水里的一串气泡，第一趟冒泡从第一个气泡开始，与它相邻的气泡做比较，大的气泡交换到上面去，这个冒泡的过程就是内循环，需要n-1次。每经过一趟冒泡的过程，可以使一个最大的元素冒出来，需要排序的元素数目就会减1，如果列表里面有n个元素，则冒n-1次就可以完成全部过程，这就是外循环。 基于这种原理，用Python3的方法实现如下： def bubble_sort1(lists): """冒泡排序""" if list_check(lists) is False: return lists for i in range(len(lists) - 1): for j in range(len(lists) - i - 1): if lists[j] > lists[j + 1]: lists[j], lists[j + 1] = lists[j + 1], lists[j] return lists </code></pre> 可以看出这个二层循环的过程，在最坏的情况下，时间复杂度为O(n²)，但是换一种思路，如果有一趟冒泡并没有发生交换，我们就可以确定此时列表已经是有序的了，不需要再去执行下一趟的冒泡过程。于是可以设置一个flag用来记录交换是否发生，则可以将算法优化如下： def bubble_sort2(lists): """冒泡排序添加flag版""" if list_check(lists) is False: return lists for i in range(len(lists) - 1): flag = True for j in range(len(lists) - i - 1): if lists[j] > lists[j + 1]: lists[j], lists[j + 1] = lists[j + 1], lists[j] flag = False if flag: return lists return lists </code></pre> 为了比较这两种算法，以及与Python自带的sorted方法的效率，下面用一个装饰器来计算函数执行时间。代码如下： def time_usage(func): """时间计算函数""" def wrapper(*args, **kwargs): """用装饰器和timeit提高计算精度""" start_time = timeit.default_timer() ret = func(*args, **kwargs) use_time = timeit.default_timer() - start_time print('{} elapsed time: {} seconds!'.format(func.name, use_time)) return ret return wrapper </code></pre> 然后从0~20000之间取10000个随机整数组成列表进行排序并统计时间，完整代码如下： # -- coding:utf-8 -- """常见排序算法的Python实现""" import timeit import numpy.random as nprnd RAND_LIST = nprnd.randint(20000, size=10000).tolist() def list_check(lists): """list类型入参检查函数""" if not isinstance(lists, list): print('Only support list!') return False if not lists: print('The list is empty!') return False def time_usage(func): """时间计算函数""" def wrapper(*args, **kwargs): """用装饰器和timeit提高计算精度""" start_time = timeit.default_timer() ret = func(*args, **kwargs) use_time = timeit.default_timer() - start_time print('{} elapsed time: {} seconds!'.format(func.name, use_time)) return ret return wrapper @time_usage def bubble_sort1(lists): """冒泡排序""" if list_check(lists) is False: return lists for i in range(len(lists) - 1): for j in range(len(lists) - i - 1): if lists[j] > lists[j + 1]: lists[j], lists[j + 1] = lists[j + 1], lists[j] return lists @time_usage def bubble_sort2(lists): """冒泡排序添加flag版""" if list_check(lists) is False: return lists for i in range(len(lists) - 1): flag = True for j in range(len(lists) - i - 1): if lists[j] > lists[j + 1]: lists[j], lists[j + 1] = lists[j + 1], lists[j] flag = False if flag: return lists return lists if name == 'main': time_usage(sorted)(RAND_LIST) SORT_LIST = copy.deepcopy(RAND_LIST) bubble_sort1(SORT_LIST) SORT_LIST = copy.deepcopy(RAND_LIST) bubble_sort2(SORT_LIST) </code></pre> 执行一下比较它们的效率： 可以看出事与愿违，第二种反而比第一种慢了一点点，多次排序比较后依然如此，作为对比我又用C++去实现了一遍，结果是一样的，如下图所示，第二种比第一种慢一点点： 其原因可能是因为flag只有在大部分数都排序好的情况下才用得上，对于这种大规模随机数，每次循环的过程中都要对flag的赋值与判断，占用的时间累积起来却是得不偿失。 但是不管是哪种冒泡排序，同内置的sorted函数的0.003s执行时间相比，效率仍然低了几个数量级。 冒泡排序的实现简单，适合教科书中详解循环的用法，但是它效率低下，在数据规模很小的场景下使用比较方便，对于大规模数据的处理，还是需要考虑使用别的排序方法。 在openSUSE上搭建hexo博客并启用SSL的科学姿势 2017-07-17T16:02:01+00:00 1. 前言</h1> 最近看见 ChicagoVPS</a>在搞活动，没忍住又剁了一个，xen架构的Windows Server 2016，当然，用了一会儿之后，还是给它格掉装了个openSUSE Tumbleweed，毕竟已经习惯了。闲着也是闲着，一台vps只跑个ss似乎有点浪费，看着硬盘里躺了许久的旧blog存档包，打算重新开始写些东西，就当日常记录用吧。 2. 搭建Hexo博客</h1> 之前的旧博客是基于wordpress搭建的，鉴于没有太多有价值的东西，还是让它躺在硬盘里安息吧。相比起使用了世界上最好的编程语言的wp框架，基于nodejs的hexo轻量了不少，用起来也方便，下面简要记录一下搭建过程。 2.1 openSUSE下环境准备</h3> 新装的openSUSE TW Server预装的软件包不多，首先需要手动装一下nodejs和git。（注：目前2020年，最好把nodejs6换成更高版本，例如nodejs12） sudo zypper in git-core nodejs6 </code></pre> 2.2 安装hexo并发布</h3> 然后使用npm安装hexo主体程序，这里直接用sudo只是为了演示，其实并不友好，推荐先使用官方对于npm的权限说明</a>进行配置。 sudo npm install -g hexo-cli </code></pre> 下面建立一个blog文件夹用来作为hexo的根目录，这里使用了openSUSE通用的路径，并设置相应的权限。 cd /srv/www/htdocs sudo mkdir blog sudo chown roger:users blog/ </code></pre> 接下来将这个blog文件夹初始化。 hexo init blog cd blog npm install </code></pre> 生成一篇默认的文章。 hexo g </code></pre> 安装hexo server，启用一下看看是否成功。 npm install hexo-server --save hexo server </code></pre> 默认端口号是4000，为了方便起见，临时关掉了SUSE的防火墙，访问 http://服务器ip:4000</code> ，可以看到hexo博客可以访问了。（注：2020年，openSUSE默认的防火墙已经由SuSEfirewall2变成了firewalld） sudo systemctl stop SuSEfirewall2 </code></pre> 3. 添加域名解析</h1> 下面开始给blog加个域名，这里使用的是二级域名blog.imoe.cat，直接使用阿里云的DNS，之前已经配置过A记录，只用给二级域名加个CNAME记录就行了。当然，这里也可以使用CDN之类的服务来操作，优化访问速度。 4. 添加SSL证书</h1> 这年头，不用个https都不好意思发自己的链接，奈何囊中羞涩，就选用了Let’s Encrypt</a>的免费证书。其实一些CDN服务商也会提供免费SSL证书，例如CloudFlare</a>，方便起见可以优先考虑使用它。 4.1 配置openSUSE环境</h3> openSUSE新系统下，先把pip装上，不然后面会报错。 sudo zypper in python2-pip </code></pre> 4.2 使用Let’s Encrypt</h3> 然后下载Let’s Encrypt并配置，注意这里要使用root权限，后面按要求输入邮件、域名之类的就可以了，多个域名使用逗号或者空格分开。证书会生成在 /etc/letsencrypt/live/XXX域名/</code> 的目录里，下面步骤会用到。 cd ~/Downloads/ git clone https://github.com/letsencrypt/letsencrypt sudo ./letsencrypt-auto certonly --standalone </code></pre> （可选）如果域名已经配置过Let’s Encrypt证书，这里就无法通过了，先去配置过的机器上删除掉它。 sudo ./certbot-auto delete </code></pre> 5. 配置nginx服务器</h1> 接下来用nginx作为server，并配置https。 5.1 安装nginx</h3> sudo zypper in nginx </code></pre> 将80和443端口加入防火墙例外。 sudo emacs /etc/sysconfig/SuSEfirewall2 </code></pre> 修改FW_SERVICES_EXT_TCP，将80与443端口加入，即 FW_SERVICES_EXT_TCP="80 443"</code> 。 5.2 修改nginx的配置</h3> 首先修改默认配置文件，主要是配置线程以及压缩方式之类的，注释掉了server内容，server块另行配置，直接上代码。 sudo emacs /etc/nginx/nginx.conf </code></pre> user nginx nginx; worker_processes 4; error_log /var/log/nginx/error.log; events { worker_connections 1024; use epoll; } http { include mime.types; default_type application/octet-stream; sendfile on; keepalive_timeout 65; gzip on; include conf.d/.conf; include vhosts.d/.conf; } </code></pre> 出于维护的方便性考虑，为blog单独建立一个配置文件，放置server块相关内容。 cd /etc/nginx mkdir vhosts.d sudo emacs vhosts.d/blog.imoe.conf </code></pre> 这个配置文件内容如下，可以看出主要内容是将80端口转发到443端口，这样就可以将http访问强制跳转到https了，不过很多CDN服务商会提供这项功能，所以并不一定需要这样写，接下来就是添加了上面步骤生成的ssl证书。 server { listen 80; server_name blog.imoe.cat; return 301 https://$server_name$request_uri; } # HTTPS server # server { listen 443 ssl; server_name blog.imoe.cat; ssl_certificate /etc/letsencrypt/live/imoe.cat/fullchain.pem; ssl_certificate_key /etc/letsencrypt/live/imoe.cat/privkey.pem; ssl_session_cache shared:SSL:1m; ssl_session_timeout 5m; ssl_ciphers "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH"; ssl_prefer_server_ciphers on; location / { root /srv/www/htdocs/blog/public/; index index.html index.htm; } access_log /var/log/nginx/imoe.cat.access.log; # 访问日志 error_log /var/log/nginx/imoe.cat.error.log; # 错误日志 } </code></pre> 5.3 启用nginx</h3> 先使用nginx -t看看配置文件是否可用，没问题的话就可以启用nginx了。 sudo systemctl enable nginx #开机启用nginx服务 sudo systemctl start nginx #启动nginx </code></pre> 6. 结语</h1> 至此，博客已经可以正常访问使用了，具体的blog配置可以参考hexo的官方文档</a>，就希望以后不会再咕咕咕了。 第一篇 2017-07-17T13:23:16+00:00 以前的wp博客已经打包放在硬盘里很久了，暂时也没有维护的打算，就让它躺在那里好了。这是新的。希望不会再次弃掉了。

阿毛的blog

zola-将博客从hexo迁移到zola并部署至Cloudflare Pages

迁移Docker Volume的本地目录

一些清理工作</h2> 确认新的ollama容器可以正常工作后，清理掉旧的ollama容器释放硬盘空间。</p> docker</span></span> volume rm ollama</span> </span></code></pre>

关于pytest框架的fixture参数化实践踩坑记录

初步尝试</h2> 直接写一个方法去加载这些数据很简单，例如定义名为load_data</code>的方法，在测试用例里调用它，即可直接使用数据：</p>

后记</h2> Fixtures 和 parametrization机制使得测试数据与测试方法分离开来，数据分离使得测试代码尽可能的简化，让测试的重用性与健壮性更强了。</p> 但是使用起来还是要理解它们的运行流程和实现机制，否则很容易踩坑。</p>

在CentOS7.x环境上安装Python3.11

确认Python版本</h2> source</span></span> ~</span></span>/.bashrc</span> </span>python3</span></span> --</span>version</span></span> &&</span> pip</span></span> --</span>version</span></span> </span></code></pre> </p> 刷新环境变量，确认版本正确即可。</p>

在CentOS7.x环境上编译安装Git2.x版本的简要记录

leetcode打卡-1720解码异或后的数组

总结</h2> 几种位运算的基本规则要记牢。</p>

leetcode打卡-0633平方数之和

解题思路</h2>

总结</h2> 这题本来是可以用费马平方和定理来解的，虽然会简化计算，但是那样就变成了一个数学问题，所以还是用双指针的方式来写了。</p>

leetcode打卡-0019删除链表的倒数第N个结点

题目描述</h2> 给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。</p>

解题思路</h2>

总结</h2> 单链表由于其方向上的一致性，运用双指针解法时候一般优先考虑快慢指针。</p>

Python3中不同方式建立已知长度数组的效率

leetcode打卡-0049字母异位词分组

解题思路</h2>

leetcode打卡-0056合并区间

leetcode打卡-0209长度最小的子数组

解题思路</h2>

leetcode打卡-0151翻转字符串里的单词

解题思路</h2>

leetcode打卡-0088合并两个有序数组

解题思路</h2>

leetcode打卡-0080删除有序数组中的重复项II

解题思路</h2>

总结</h2> 参考之前的题解，注意总结顺序遍历中“保留逻辑”的套路。</p>

leetcode打卡-0027移除元素

解题思路</h2>

总结</h2> 对于这种字符串、数组之类的可以直接遍历的题目，利用具体要求提炼出“保留逻辑”，将这种逻辑应用到遍历中的每一个位置即可。</p>

leetcode打卡-0026删除数组中重复项

解题思路</h2>

总结</h2> 双指针的方法很容易想到，在处理字符串问题是比较常用，不过后面的通用解法，它是建立在“数组有序”且“保留逻辑”的基础上，可以作为解决这种字符串问题的套路尝试。</p>

配置Pylance和clangd插件优化vscode下Python和C++的开发体验

给MobaXterm写了个专业版许可证生成器

关于单例模式在C++下的实现方式

在C++中实现单例</h2> C++中实现单例方法主要是通过隐藏构造函数来实现的。</p>

在Windows下配置MinGW版Qt的Clang编译器

下载与安装Windows版Clang</h1> Clang的安装可以选择下面任意一种方式。</p>

配置编译器选项</h2> 在Qt Creator编译器中添加Clang的路径并应用，如图所示： 注：如果使用的是Qt预编译版的Clang则只需要让Qt Creator自动发现即可，无需手动添加，LLVM官网的Clang才需要手动添加编译器以使ABI对应。</p>

对于Android 7.0以上版本设备的抓包方法

在python3中使用异步方法处理并发

C语言基础之预处理机制

基本排序算法之希尔排序的Python实现

基本排序算法之直接插入排序的Python实现

基本排序算法之快速排序的Python实现

基本排序算法之冒泡排序的Python实现

在openSUSE上搭建hexo博客并启用SSL的科学姿势

一些清理工作</h2>
确认新的ollama容器可以正常工作后，清理掉旧的ollama容器释放硬盘空间。</p>
`docker</span></span> volume rm ollama</span> </span></code></pre>`

后记</h2>
Fixtures 和 parametrization机制使得测试数据与测试方法分离开来，数据分离使得测试代码尽可能的简化，让测试的重用性与健壮性更强了。</p>
但是使用起来还是要理解它们的运行流程和实现机制，否则很容易踩坑。</p>

确认Python版本</h2>
`source</span></span> ~</span></span>/.bashrc</span> </span>python3</span></span> --</span>version</span></span> &&</span> pip</span></span> --</span>version</span></span> </span></code></pre> </p> 刷新环境变量，确认版本正确即可。</p>`

总结</h2>
几种位运算的基本规则要记牢。</p>

总结</h2>
这题本来是可以用费马平方和定理来解的，虽然会简化计算，但是那样就变成了一个数学问题，所以还是用双指针的方式来写了。</p>

题目描述</h2>
给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。</p>

总结</h2>
单链表由于其方向上的一致性，运用双指针解法时候一般优先考虑快慢指针。</p>

总结</h2>
参考之前的题解，注意总结顺序遍历中“保留逻辑”的套路。</p>

总结</h2>
对于这种字符串、数组之类的可以直接遍历的题目，利用具体要求提炼出“保留逻辑”，将这种逻辑应用到遍历中的每一个位置即可。</p>

总结</h2>
双指针的方法很容易想到，在处理字符串问题是比较常用，不过后面的通用解法，它是建立在“数组有序”且“保留逻辑”的基础上，可以作为解决这种字符串问题的套路尝试。</p>

在C++中实现单例</h2>
C++中实现单例方法主要是通过隐藏构造函数来实现的。</p>

下载与安装Windows版Clang</h1>
Clang的安装可以选择下面任意一种方式。</p>

配置编译器选项</h2>
在Qt Creator编译器中添加Clang的路径并应用，如图所示：注：如果使用的是Qt预编译版的Clang则只需要让Qt Creator自动发现即可，无需手动添加，LLVM官网的Clang才需要手动添加编译器以使ABI对应。</p>