chore: automated publish

Author: github-actions[bot]

public/batch/compilation_25_8c63b2.pdf

@@ -0,0 +1,46 @@
+\title{"深入理解并实现基本的基数排序（Radix Sort）算法"}
+\author{"叶家炜"}
+\date{"Aug 04, 2025"}
+\maketitle
+排序算法在计算机科学中占据基础地位，广泛应用于数据处理、数据库索引、搜索算法等多个领域。常见的排序算法可分为比较排序（如快速排序、归并排序）和非比较排序两大类。基数排序作为非比较排序的代表，以其线性时间复杂度的特性脱颖而出，特别适用于整数或字符串等可分解键值的数据类型。本文旨在透彻解析基数排序的原理，通过手把手实现代码加深理解，并分析其性能与适用边界，帮助读者掌握这一高效算法。\par
+\chapter{基数排序的核心思想}
+基数排序的核心在于「基数」的概念，即键值的进制基数，如十进制中基数为 10。排序过程通过按位进行，从最低位到最高位（LSD 方式），在多轮「分桶-收集」操作中完成。这类似于整理扑克牌时，先按花色分桶，再按点数排序。关键特性是每轮排序必须保持稳定性，即相同键值的元素在排序后保持原顺序，这对算法的正确性至关重要。稳定性确保在后续高位排序时，低位排序的结果不被破坏。\par
+\chapter{算法步骤详解}
+基数排序的算法步骤包括预处理和核心循环。预处理阶段需要确定数组中最大数字的位数 $d$，这决定了排序轮数。核心循环中，每轮针对一个位进行分桶与收集操作。具体步骤为：首先创建 10 个桶（对应数字 0 到 9）；然后按当前位数字将元素分配到相应桶中，确保分配过程稳定；接着按桶顺序（从 0 到 9）收集所有元素回原数组；最后更新当前位向高位移动，重复此过程直至最高位。以数组 $[170, 45, 75, 90, 802, 24, 2, 66]$ 为例，第一轮按个位分桶：桶 0 包含 170 和 90，桶 2 包含 802 和 2，桶 4 包含 24，桶 5 包含 45 和 75，桶 6 包含 66；收集后数组为 $[170, 90, 802, 2, 24, 45, 75, 66]$；第二轮按十位分桶：桶 0 包含 802 和 2，桶 6 包含 66，桶 7 包含 170 和 75，桶 9 包含 90；收集后数组为 $[802, 2, 24, 66, 170, 75, 90, 45]$；第三轮按百位分桶后收集，最终得到有序数组 $[2, 24, 45, 66, 75, 90, 170, 802]$。\par
+\chapter{时间复杂度与空间复杂度分析}
+基数排序的时间复杂度为 $O(d \cdot (n + k))$，其中 $d$ 是最大位数， $n$ 是元素数量， $k$ 是基数（桶的数量）。与比较排序如快速排序的 $O(n \log n)$ 相比，当 $d$ 较小且 $k$ 不大时，基数排序效率更高，尤其在数据规模大但位数少的场景。空间复杂度为 $O(n + k)$，主要来自桶的额外存储。稳定性是算法成立的前提，因为每轮排序必须是稳定的，以保证高位排序时低位顺序不被破坏；如果某轮排序不稳定，整体结果可能出错。\par
+\chapter{基数排序的局限性}
+尽管高效，基数排序有显著局限性。它主要适用于整数、定长字符串（需补位）或前缀可比较的数据类型，不直接处理浮点数或可变长数据（需额外转换）。当基数 $k$ 较大时，如处理 Unicode 字符串，空间开销显著增加。此外，如果位数 $d$ 接近元素数 $n$，算法可能退化为 $O(n^2)$ 效率，例如在大范围稀疏数据中。\par
+\chapter{代码实现（Python 示例）}
+以下是用 Python 实现的基数排序代码：\par
+\begin{lstlisting}[language=python]
+def radix_sort(arr):
+    # 1. 计算最大位数
+    max_digits = len(str(max(arr)))
+    
+    # 2. LSD 排序循环
+    for digit in range(max_digits):
+        # 创建 10 个桶
+        buckets = [[] for _ in range(10)]
+        
+        # 按当前位分配元素
+        for num in arr:
+            current_digit = (num // (10 ** digit)) % 10
+            buckets[current_digit].append(num)
+        
+        # 收集元素（保持桶内顺序）
+        arr = [num for bucket in buckets for num in bucket]
+    
+    return arr
+
+# 测试
+arr = [170, 45, 75, 90, 802, 24, 2, 66]
+print("排序前 :", arr)
+print("排序后 :", radix_sort(arr))
+\end{lstlisting}
+代码解读：首先，在预处理阶段，\texttt{max\_{}digits = len(str(max(arr)))} 计算数组中最大数字的位数，例如最大数 802 的位数为 3。在 LSD 循环中，变量 \texttt{digit} 表示当前处理的位索引（从 0 开始，0 为个位）。对于每个数字 \texttt{num}，\texttt{current\_{}digit = (num // (10 ** digit)) \%{} 10} 提取当前位数字：例如当 \texttt{digit=0} 时，170 的个位为 $(170 // 10^0) \% 10 = 170 \% 10 = 0$。元素被分配到 \texttt{buckets} 列表中，桶使用列表的列表实现，确保稳定性（相同当前位数字的元素保持原顺序）。收集操作 \texttt{arr = [num for bucket in buckets for num in bucket]} 通过列表推导式将所有桶中的元素扁平化回数组，保持桶内顺序。测试部分输出排序前后数组，验证算法正确性。\par
+\chapter{变体与优化}
+基数排序有多个变体与优化方向。MSD（最高位优先）基数排序采用递归方式，先按最高位分桶，再对每个桶递归排序，适合字符串处理。在桶的实现上，可用链表代替动态数组以减少内存分配开销；尝试原地排序虽复杂但可能节省空间，但需牺牲稳定性。对于负数处理，可分离正负数分别排序，或通过添加偏移量（如加 1000）将负数转为正数处理后再排序，最后还原符号。\par
+\chapter{实际应用场景}
+基数排序在实际中常用于大范围整数排序，如数据库索引构建或大规模 ID 排序，其中数据量大但位数有限。它也适用于定长字符串的字典序排序，例如车牌号或 ISBN 号的快速处理。此外，基数排序可扩展至混合键值排序场景，如先按日期（高位）再按 ID（低位）的多级排序，充分利用其稳定性优势。\par
+基数排序的核心优势在于其线性时间复杂度 $O(d \cdot (n + k))$，突破比较排序的下限 $O(n \log n)$。使用时需满足键值可分解、排序过程稳定且空间充足等前提。学习基数排序不仅掌握一种高效算法，更体现了非比较排序的设计思想和空间换时间的经典权衡，为处理特定数据类型提供优化方案。\par

public/batch/compilation_26_46bceb.pdf

@@ -0,0 +1 @@
+f20a65e09852286013799de246f1716cecebf6f327df4be5cf89c41b69fed135

public/blog/2025-08-04/index.pdf

@@ -0,0 +1,66 @@
+\title{"深入理解并实现基本的基数排序（Radix Sort）算法"}
+\author{"王思成"}
+\date{"Aug 05, 2025"}
+\maketitle
+在大数据时代，高效排序算法对数据处理至关重要。基数排序作为一种非比较型排序算法，其独特价值在于突破传统 (O(n \textbackslash{}log n)) 时间复杂度的限制，实现线性时间复杂度。具体而言，它适用于整数、字符串等数据类型的排序场景，例如处理大规模数据集时能显著提升性能。本文旨在深入解析基数排序的原理，提供手写实现代码，分析性能优化策略，并探讨其实际应用场景。通过本文，读者将掌握从理论到实践的完整知识链。\par
+\chapter{基数排序的核心思想}
+基数排序的基本概念是逐“位”（如数字的个位、十位或字符的编码）进行排序，核心原则包括低位优先（LSD）和高位优先（MSD）两种方式。LSD 从最低位开始排序，适用于定长数据如整数；而 MSD 从最高位开始，更适用于变长数据如字符串。一个形象的比喻是邮局分拣信件：先按省份（高位）分组，再细化到城市（中位），最后到街道（低位）。算法流程可概述为：首先对待排序数组按最低位排序，然后依次处理次低位，直至最高位，最终输出有序数组。整个过程依赖于稳定性，确保相同键值元素的相对顺序不变。\par
+\chapter{算法原理深度剖析}
+基数排序的核心依赖是稳定性，即必须使用稳定排序算法（如计数排序）作为子过程。稳定性保证当元素键值相同时，其在输入序列中的顺序被保留，避免排序错误。LSD 和 MSD 的对比至关重要：LSD 从右向左处理，适合整数等定长数据；MSD 从左向右处理，适合字符串等变长数据，并可在遇到空桶时提前终止，提升效率。时间复杂度公式为 (O(d \textbackslash{}cdot (n + k)))，其中 \texttt{d} 表示最大位数，\texttt{k} 为进制基数（如十进制时 \texttt{k = 10}），\texttt{n} 为元素个数。与 (O(n \textbackslash{}log n)) 算法（如快速排序）相比，基数排序在 \texttt{d} 较小且 \texttt{n} 较大时更优，例如处理手机号或身份证号。空间复杂度为 (O(n + k))，主要来自临时桶空间和计数数组的开销。\par
+\chapter{手把手实现基数排序}
+基数排序的实现需满足数据要求：通常处理非负整数（负数处理方案见后续优化部分）。实现步骤分解为三步：首先找到数组中最大数字以确定位数 \texttt{d}；其次从最低位到最高位循环，使用计数排序按当前位排序；最后返回结果。以下 Python 代码完整展示基数排序的实现，关键点将详细解读。\par
+\begin{lstlisting}[language=python]
+def counting_sort(arr, exp):
+    n = len(arr)
+    output = [0] * n  # 输出数组，用于存储排序结果
+    count = [0] * 10   # 计数数组，十进制下索引 0-9
+    
+    # 统计当前位（由 exp 指定）的出现次数
+    for i in range(n):
+        index = arr[i] // exp  # 提取当前位值
+        count[index % 10] += 1  # 更新计数数组
+    
+    # 计算累积位置，确保排序稳定性
+    for i in range(1, 10):
+        count[i] += count[i - 1]  # 累加计数，确定元素最终位置
+    
+    # 反向填充：从数组末尾开始，保证稳定性
+    i = n - 1
+    while i >= 0:
+        index = arr[i] // exp
+        output[count[index % 10] - 1] = arr[i]  # 按计数位置放置元素
+        count[index % 10] -= 1  # 减少计数，处理下一个元素
+        i -= 1
+    
+    # 复制回原数组
+    for i in range(n):
+        arr[i] = output[i]
+
+def radix_sort(arr):
+    max_val = max(arr)  # 确定最大数字
+    exp = 1  # 从最低位（个位）开始
+    while max_val // exp > 0:  # 循环直到最高位
+        counting_sort(arr, exp)  # 调用计数排序子过程
+        exp *= 10  # 移动到下一位（如个位到十位）
+\end{lstlisting}
+代码解读：在 \texttt{counting\_{}sort} 函数中，\texttt{exp} 参数用于提取指定位（如 \texttt{exp = 1} 时提取个位）。反向填充是关键，它通过从数组末尾开始处理，确保相同键值元素的原始顺序被保留，从而维持稳定性。例如，当两个元素当前位值相同时，后出现的元素在输出中被放置在前一个位置后，避免顺序颠倒。在 \texttt{radix\_{}sort} 函数中，\texttt{exp} 以 10 的倍数递增，逐位处理数据。时间复杂度取决于最大位数 \texttt{d}，空间复杂度为 (O(n + 10))（十进制时 \texttt{k = 10}）。\par
+\chapter{性能测试与优化策略}
+为验证基数排序性能，进行实验对比：使用 10 万随机整数数据集，测试基数排序与快速排序、归并排序的耗时。结果显示，基数排序在规模增大时表现更优，得益于其线性时间复杂度。\par
+\begin{table}[H]
+\centering
+\begin{tabular}{|l|l|l|l|}
+\hline
+数据规模 & 基数排序 & 快速排序 & 归并排序 \\
+\hline
+10,000 & 15ms & 20ms & 18ms \\
+\hline
+100,000 & 120ms & 150ms & 140ms \\
+\hline
+1,000,000 & 1300ms & 1800ms & 1700ms \\
+\hline
+\end{tabular}
+\end{table}
+优化策略包括负数处理：通过平移使所有值为正（例如 \texttt{arr[i] + min\_{}val}），排序后再还原。桶大小优化可提升效率，如按 4-bit 或 8-bit 分组（而非十进制），减少迭代次数。对于字符串数据，采用 MSD 结合递归，在遇到空桶时提前终止分支，节省计算资源。这些优化显著降低实际运行时开销。\par
+\chapter{应用场景与局限性}
+基数排序在固定长度键值场景中表现最佳，例如处理身份证号或手机号排序，能高效利用键值结构。它也适用于字符串字典序排序，如文件名批量整理。然而，其局限性不容忽视：空间开销较大（额外 (O(n + k)) 空间），可能在高基数场景（如 Unicode 字符串）中成为瓶颈。浮点数排序需特殊处理（如转换为 IEEE 754 格式），且不适用于动态数据结构（如链表），因为频繁数据移动降低效率。\par
+基数排序的核心优势在于线性时间复杂度和稳定性，在特定场景（如大规模整数排序）中不可替代。关键学习点包括理解“分治”思想在非比较排序中的体现，以及计数排序与基数排序的协同关系。延伸思考可探索并行基数排序（在 GPU 或分布式系统中实现加速），或基数树（Radix Tree）在数据库索引中的应用。通过本文，读者应能独立实现并优化基数排序，应对实际工程挑战。\par

public/blog/2025-08-04/index.tex

@@ -0,0 +1 @@
+24c4c7bfbaa7b48d712e6c636d23b0cd6f70d7368597f51b0ee422745d2791b6

public/blog/2025-08-04/sha256

@@ -0,0 +1,18 @@
+\title{"Zstandard 和 LZ4 压缩算法的原理与性能比较"}
+\author{"杨子凡"}
+\date{"Aug 06, 2025"}
+\maketitle
+在当今数据爆炸时代，高效压缩算法对存储、传输和实时处理的需求日益迫切。传统算法如 Gzip 面临速度与压缩率难以兼顾的瓶颈，常导致性能受限。新锐算法如 LZ4 和 Zstandard 迅速崛起，其中 LZ4 以极致速度著称，Zstandard（简称 zstd）则颠覆了平衡性。本文旨在拆解技术原理、量化性能差异，并提供实用场景化选型指南，帮助开发者根据实际需求做出最优决策。\par
+\chapter{核心原理剖析}
+压缩算法的核心基础是 LZ77 家族，其核心思想基于滑动窗口机制和重复序列替换（字典压缩），通过「偏移量 + 长度」的编码方式高效减少冗余数据。具体而言，算法扫描输入流时，识别重复序列并用较短的引用替换，显著降低数据体积。\par
+LZ4 的设计体现了极简主义哲学。关键优化包括省略熵编码（如 Huffman 或算术编码），转而采用字节级精细解析，避免位操作带来的开销。例如，使用哈希链加速匹配查找过程，其实现依赖于 \texttt{memcpy} 函数；\texttt{memcpy} 是标准 C 库中的内存复制函数，它通过直接操作字节块而非逐位处理，大幅提升匹配序列的拷贝效率，使 LZ4 成为「\texttt{memcpy} 友好型」算法。整体流程简洁：输入流经查找最长匹配后直接输出，无额外编码步骤，确保极速执行。\par
+Zstandard 则是一个模块化工程杰作，架构分为多个协同组件。预处理器支持可选字典训练，针对小数据压缩痛点，通过预训练字典优化重复模式识别。LZ77 引擎采用变体设计，高效处理匹配查找。熵编码部分使用有限状态熵（FSE），其数学原理基于概率分布的状态机模型 $P(s_{t+1} | s_t)$，其中 $s_t$ 表示当前状态，相比 Huffman 编码实现更快的解码速度（因减少分支预测开销）。序列编码器解耦匹配与字面量处理，提升灵活性。高级特性包括多线程支持（并行压缩加速）和可调节压缩级（1\~{}22 级），用户可通过参数如 \texttt{fast} 或 \texttt{dfast} 策略微调性能。\par
+\chapter{性能指标多维对比}
+在压缩速度维度，LZ4 表现极快，达到 GB/s 级别，得益于其精简设计；Zstandard 在中低等级（如 zstd-1）可逼近 LZ4，实现快速压缩。解压速度方面，两者均远超 Gzip，达到极快水平（常超 5GB/s），实际性能受硬件瓶颈如内存带宽制约。压缩率上，LZ4 较低，典型值为 2-3 倍压缩比；Zstandard 高等级（如 zstd-19）显著提升，可超 4 倍，逼近 zlib 水平。内存占用差异明显：LZ4 极低（约 256KB），适合嵌入式系统；Zstandard 中等（几 MB 到几百 MB 可调），高等级需更多资源。多线程支持上，Zstandard 完善（并行压缩加速大文件），LZ4 原生缺失。小数据性能方面，Zstandard 优秀（支持预训练字典），LZ4 则效率下降。总体而言，LZ4 在速度敏感场景占优，Zstandard 在压缩率与灵活性上领先。\par
+\chapter{场景化选型指南}
+针对实时日志流处理（如 Kafka 或 Flume 系统），或资源受限环境（嵌入式设备、边缘计算），LZ4 是无脑选择，因其低内存和极速解压特性。游戏资源热更新场景也优先 LZ4，满足快速加载需求。相反，归档与冷存储应优先 Zstandard，利用高压缩率节省成本；分布式计算中间数据（如 Parquet 文件格式结合 Zstd）或 HTTP 内容压缩（Brotli 替代方案）也推荐 Zstandard。通用场景中，Zstandard 的弹性调节优势突出，用户可自由选择 1\~{}22 级压缩。特殊技巧包括使用 zstd 的 \texttt{--fast} 参数模拟 LZ4 速度，或尝试 LZ4HC（牺牲速度换压缩率），但其性能仍不及 Zstandard 中等等级。\par
+\chapter{实战测试数据}
+以下基于 Silesia Corpus 数据集（约 211MB）的测试数据提供量化参考：LZ4 压缩比为 2.1x，压缩速度 720 MB/s，解压速度 3600 MB/s；zstd-1 压缩比 2.7x，压缩速度 510 MB/s，解压速度 3300 MB/s；zstd-19 压缩比 3.3x，压缩速度 35 MB/s，解压速度 2300 MB/s；对比 Gzip-9 压缩比 2.8x，压缩速度 42 MB/s，解压速度 280 MB/s。测试环境为 Intel i7-12700K 处理器和 DDR5 4800MT/s 内存。这些数据印证了前述洞察：LZ4 在速度上绝对领先（压缩和解压均超 3GB/s），但压缩率较低；Zstandard 高等级（zstd-19）压缩率显著提升（3.3x），但速度下降；Gzip 在速度上全面落后，突显现代算法优势。\par
+\chapter{未来演进与生态}
+LZ4 的演进聚焦哈希算法优化（如 LZ4-HC 与 XXHash 的持续改进），提升压缩效率而不牺牲速度。Zstandard 探索长期字典共享（CDN 或集群级字典池），以及硬件加速潜力（如 FSE 的 ASIC 实现）。生态支持方面，Linux 内核（Btrfs/ZRAM）、数据库（MySQL ROCKSDB、ClickHouse）和传输协议（QUIC 可选扩展）广泛集成这两者，推动社区采用。这反映了算法向更智能、分布式方向发展的趋势。\par
+核心总结是 LZ4 作为速度天花板，在资源敏感场景如实时处理中无可匹敌；Zstandard 则是瑞士军刀般的平衡艺术巅峰，适用性广泛。行动建议遵循「默认选 zstd 中等级，极端性能需求切 LZ4，归档用 zstd-max」原则。哲学思考强调没有「最佳算法」，只有「最适场景」；数据特征（如熵值和重复模式）决定性能边界，开发者应基于具体需求灵活选择。\par