chore: automated publish

Author: github-actions[bot]

public/blog/2025-05-03/index.pdf

@@ -0,0 +1,76 @@
+\title{"深入理解并实现基本的哈希表数据结构"}
+\author{"杨其臻"}
+\date{"May 03, 2025"}
+\maketitle
+在计算机科学中，高效的数据存储与检索始终是核心课题。当面对需要快速查找的场景时，传统数据结构如数组和链表往往显得力不从心——数组通过索引可以实现 $O(1)$ 访问，但难以处理动态键值；链表的顺序查找则需要 $O(n)$ 时间复杂度。哈希表通过将键映射到存储位置的创新设计，在理想情况下实现了接近常数的操作效率，广泛应用于数据库索引、缓存系统和现代编程语言的字典结构中。\par
+\chapter{哈希表的基本原理}
+哈希表的本质是通过哈希函数建立键（Key）与存储位置（Bucket）之间的映射关系。其三大核心组件包括：将任意数据类型转换为整数的哈希函数、存储实际数据的桶数组，以及处理不同键映射到同一位置时的冲突解决机制。\par
+哈希函数的设计直接影响整体性能。一个优秀的哈希函数需要满足三个特性：确定性（相同输入必得相同输出）、均匀性（输出值在桶数组范围内均匀分布）和高效性（计算速度快）。例如对于字符串键，可以采用 ASCII 码加权求和后取模的简单方法：\par
+\begin{lstlisting}[language=python]
+def _hash(self, key):
+    hash_value = 0
+    for char in key:
+        hash_value += ord(char)
+    return hash_value % self.capacity
+\end{lstlisting}
+这段代码将每个字符的 ASCII 值累加后对桶容量取模，确保结果落在有效索引范围内。但这种简单方法容易导致不同字符串产生相同哈希值（如「abc」与「cba」），因此实际工程中常采用更复杂的多项式滚动哈希。\par
+\chapter{从零实现哈希表}
+我们选择链地址法作为冲突解决方案，即每个桶存储一个链表（Python 中用列表模拟）。哈希表类的基本结构如下：\par
+\begin{lstlisting}[language=python]
+class HashTable:
+    def __init__(self, capacity=10):
+        self.capacity = capacity
+        self.size = 0
+        self.load_factor_threshold = 0.75
+        self.buckets = [[] for _ in range(capacity)]
+\end{lstlisting}
+初始化时创建指定容量的桶数组，每个桶初始化为空列表。\verb!load_factor_threshold! 用于触发动态扩容，当元素数量与容量的比值（负载因子）超过该阈值时自动扩容。\par
+\textbf{插入操作}需要处理键已存在时的更新逻辑：\par
+\begin{lstlisting}[language=python]
+def insert(self, key, value):
+    index = self._hash(key)
+    bucket = self.buckets[index]
+    for i, (k, v) in enumerate(bucket):
+        if k == key:
+            bucket[i] = (key, value)  # 更新已有键
+            return
+    bucket.append((key, value))       # 新增键值对
+    self.size += 1
+    if self.size / self.capacity > self.load_factor_threshold:
+        self._resize()
+\end{lstlisting}
+遍历链表检查键是否存在，若存在则更新值，否则追加新节点。插入后检查负载因子，超过阈值则调用 \verb!_resize! 方法进行扩容。\par
+\textbf{动态扩容}通过创建新桶数组并重新哈希所有现有元素实现：\par
+\begin{lstlisting}[language=python]
+def _resize(self):
+    new_capacity = self.capacity * 2
+    new_buckets = [[] for _ in range(new_capacity)]
+    old_buckets = self.buckets
+    self.buckets = new_buckets
+    self.capacity = new_capacity
+    self.size = 0
+    
+    for bucket in old_buckets:
+        for key, value in bucket:
+            self.insert(key, value)  # 重新插入元素
+\end{lstlisting}
+这里选择双倍扩容策略，重新插入时利用已有的 \verb!insert! 方法简化实现，但实际工程中会直接操作新桶以提高效率。\par
+\chapter{性能分析与优化}
+在理想情况下（无哈希冲突），哈希表的插入、查找、删除操作时间复杂度均为 $O(1)$。但最坏情况下（所有键哈希冲突），时间复杂度退化为 $O(n)$。性能表现主要取决于两个关键参数：\par
+\begin{itemize}
+\item \textbf{负载因子} $\lambda = \frac{n}{m}$（$n$ 为元素数量，$m$ 为桶数量）\begin{enumerate}
+\item 经验表明当 $\lambda > 0.75$ 时冲突概率显著增加
+\end{enumerate}
+
+\item \textbf{哈希函数质量}：衡量指标是产生不同哈希值的分布均匀程度
+\end{itemize}
+与红黑树等平衡二叉树相比，哈希表在随机访问速度上占优，但无法支持范围查询和有序遍历。Java 的 \verb!HashMap! 在链表长度超过阈值（默认为 8）时会将链表转换为红黑树，将最坏情况时间复杂度从 $O(n)$ 优化为 $O(\log n)$。\par
+\chapter{实际应用案例}
+Python 的字典类型是哈希表的经典实现。CPython 采用开放寻址法解决冲突，使用伪随机探测序列寻找空槽位。其设计特点包括：\par
+\begin{enumerate}
+\item 初始容量为 8 的稀疏数组
+\item 哈希函数针对不同数据类型优化
+\item 当三分之二桶被占用时触发扩容
+\end{enumerate}
+Redis 数据库的哈希类型采用 ziplist 和 hashtable 两种编码方式。当元素数量超过 512 或单个元素大小超过 64 字节时，ziplist 会转换为标准的哈希表结构以提升性能。\par
+哈希表凭借其接近常数的操作效率，成为构建高性能系统的基石技术。但其性能对哈希函数高度敏感，且存在内存占用较大、无法保证遍历顺序等局限。在需要快速查找且不要求数据有序性的场景下，哈希表通常是最佳选择。对于进阶学习者，建议探索一致性哈希算法在分布式系统中的应用，以及完美哈希在静态数据集上的优化实践。\par

public/blog/2025-05-03/index.tex

@@ -0,0 +1 @@
+40f0fcebcc74e826830b634a8b4bee8f70615ac868d40cbecf9dc2a73b4db6ed