LeetCode 219题：哈希表解决存在重复元素II问题

Fesgrome

markdown复制## 1. 题目解析与解题思路

LeetCode 219题"存在重复元素 II"是一道经典的数组处理题目，要求判断数组中是否存在两个相同的元素，且它们的下标差不超过给定的k值。这道题在面试中经常出现，因为它很好地考察了对哈希表这种数据结构的理解和应用能力。

题目具体要求：给定一个整数数组nums和一个整数k，如果数组中存在两个不同的索引i和j，使得nums[i] == nums[j]且abs(i - j) <= k，则返回true；否则返回false。

### 1.1 暴力解法分析

最直观的解法是使用双重循环遍历所有可能的元素对：
```c
for (int i = 0; i < numsSize; i++) {
    for (int j = i + 1; j <= i + k && j < numsSize; j++) {
        if (nums[i] == nums[j]) {
            return true;
        }
    }
}
return false;

这种解法的时间复杂度是O(n*k)，当k接近n时会退化为O(n²)，在LeetCode上会超时。我们需要寻找更优的解法。

1.2 哈希表优化思路

哈希表（散列表）可以在O(1)时间内完成元素的查找操作。我们可以维护一个哈希表，存储元素值到其最近出现位置的映射。遍历数组时，对于每个元素：

检查是否已经在哈希表中存在
如果存在且当前下标与存储下标的差≤k，返回true
否则更新哈希表中该元素的值为当前下标

这种解法的时间复杂度是O(n)，空间复杂度也是O(n)，是典型的空间换时间策略。

2. C语言实现详解

2.1 哈希表结构设计

C语言没有内置的哈希表实现，我们需要自己设计。对于这个问题，可以使用开放寻址法的简单哈希表：

c复制#define HASH_SIZE 10000

typedef struct {
    int key;
    int value;
} HashNode;

HashNode hashTable[HASH_SIZE];

2.2 哈希函数与冲突解决

我们使用简单的取模法作为哈希函数，线性探测解决冲突：

c复制int hash(int key) {
    return (key % HASH_SIZE + HASH_SIZE) % HASH_SIZE;
}

void insert(int key, int value) {
    int idx = hash(key);
    while (hashTable[idx].key != 0 && hashTable[idx].key != key) {
        idx = (idx + 1) % HASH_SIZE;
    }
    hashTable[idx].key = key;
    hashTable[idx].value = value;
}

int get(int key) {
    int idx = hash(key);
    while (hashTable[idx].key != 0) {
        if (hashTable[idx].key == key) {
            return hashTable[idx].value;
        }
        idx = (idx + 1) % HASH_SIZE;
    }
    return -1; // 表示未找到
}

2.3 完整解题代码

c复制#include <stdbool.h>
#include <stdlib.h>

#define HASH_SIZE 10000

typedef struct {
    int key;
    int value;
} HashNode;

HashNode hashTable[HASH_SIZE];

int hash(int key) {
    return (key % HASH_SIZE + HASH_SIZE) % HASH_SIZE;
}

void insert(int key, int value) {
    int idx = hash(key);
    while (hashTable[idx].key != 0 && hashTable[idx].key != key) {
        idx = (idx + 1) % HASH_SIZE;
    }
    hashTable[idx].key = key;
    hashTable[idx].value = value;
}

int get(int key) {
    int idx = hash(key);
    while (hashTable[idx].key != 0) {
        if (hashTable[idx].key == key) {
            return hashTable[idx].value;
        }
        idx = (idx + 1) % HASH_SIZE;
    }
    return -1;
}

bool containsNearbyDuplicate(int* nums, int numsSize, int k) {
    // 清空哈希表
    for (int i = 0; i < HASH_SIZE; i++) {
        hashTable[i].key = 0;
        hashTable[i].value = 0;
    }
    
    for (int i = 0; i < numsSize; i++) {
        int prevPos = get(nums[i]);
        if (prevPos != -1 && i - prevPos <= k) {
            return true;
        }
        insert(nums[i], i);
    }
    return false;
}

3. 算法优化与边界处理

3.1 哈希表大小选择

哈希表大小HASH_SIZE的选择很重要：

太小会导致冲突频繁，影响性能
太大会浪费内存空间
一般选择比最大可能元素数量稍大的质数

对于LeetCode的测试用例，10000是一个合理的选择。在实际工程中，可能需要动态调整哈希表大小。

3.2 负数处理

注意哈希函数中对负数的处理：

c复制return (key % HASH_SIZE + HASH_SIZE) % HASH_SIZE;

这种写法确保无论key是正是负，都能得到合法的数组下标。

3.3 滑动窗口优化

当k远小于n时，可以维护一个大小为k+1的滑动窗口，使用哈希集合存储窗口内的元素：

c复制bool containsNearbyDuplicate(int* nums, int numsSize, int k) {
    if (k == 0) return false;
    
    int left = 0;
    for (int right = 0; right < numsSize; right++) {
        if (right - left > k) {
            // 从哈希表中移除nums[left]
            left++;
        }
        // 检查nums[right]是否在哈希表中
        // 如果在则返回true
        // 否则添加到哈希表
    }
    return false;
}

这种实现的空间复杂度可以优化到O(k)，但C语言实现起来更复杂。

4. 测试用例与调试技巧

4.1 典型测试用例

基础用例：
- 输入：[1,2,3,1], k=3
- 输出：true
- 解释：nums[0]和nums[3]相同，3-0=3≤k
无重复用例：
- 输入：[1,2,3,1], k=2
- 输出：false
- 解释：相同元素间隔3>k
边界用例：
- 输入：[1], k=0
- 输出：false
- 解释：单个元素不可能有重复

4.2 调试技巧

打印哈希表状态：

c复制void printHashTable() {
    for (int i = 0; i < 10; i++) { // 只打印前10个
        printf("[%d] key=%d, value=%d\n", i, hashTable[i].key, hashTable[i].value);
    }
}

检查哈希冲突：
记录哈希表的总查询次数和冲突次数，评估哈希函数效率。
内存检查：
确保哈希表访问不会越界，特别是在处理负数时。

5. 复杂度分析与扩展思考

5.1 时间复杂度分析

哈希表解法：

插入和查找操作平均O(1)
遍历数组O(n)
总体O(n)

暴力解法：

最坏情况下O(n²)

5.2 空间复杂度分析

哈希表解法：

需要存储n个元素的索引
最坏情况下O(n)

滑动窗口优化：

只需要存储k+1个元素
O(k)

5.3 扩展思考

如果数组很大但重复元素很少，如何优化空间？
- 可以考虑使用更紧凑的数据结构
- 或者只在发现重复时才分配空间
如果k值很大但内存有限？
- 可以考虑外部排序+扫描的方法
- 或者分批处理数据
分布式环境下如何解决？
- 需要设计分布式的哈希表实现
- 考虑数据分片和一致性哈希

6. 实际工程中的应用

这类算法在实际工程中有广泛应用场景：

缓存系统：判断最近k次访问中是否有重复
数据流处理：检测短时间内重复的事件
基因组分析：寻找特定距离内的重复序列
抄袭检测：检测文档中相近位置的相似内容

在实现生产级代码时，还需要考虑：

哈希表的动态扩容
更高效的哈希函数
线程安全处理
内存管理优化

提示：在面试中遇到这类问题时，建议先阐述暴力解法，然后逐步优化，展示思考过程比直接给出最优解更重要。

7. 常见错误与解决方法

哈希表未初始化：
- 症状：随机返回true/false
- 解决：在函数开始处清空哈希表
负数处理不当：
- 症状：数组越界或错误结果
- 解决：使用正确的哈希函数处理负数
边界条件遗漏：
- k=0的情况
- 空数组的情况
- 所有元素都相同的情况
哈希冲突过多：
- 症状：超时
- 解决：增大哈希表尺寸或改进哈希函数
下标计算错误：
- 症状：差1错误
- 解决：仔细检查i和j的关系，必要时画图辅助

8. 性能优化实战

对于追求极致性能的场景，可以尝试以下优化：

内联哈希函数：

c复制#define GET_HASH(key) ((key % HASH_SIZE + HASH_SIZE) % HASH_SIZE)

使用更快的哈希算法：
如MurmurHash或CityHash，但要考虑实现复杂度
减少条件判断：
重构代码逻辑减少分支预测失败
循环展开：
对关键循环进行手动展开
使用位运算替代取模：
当HASH_SIZE是2的幂时，可以用&代替%

c复制#define HASH_SIZE 16384  // 2^14
#define GET_HASH(key) ((key) & (HASH_SIZE-1))

缓存友好访问：
优化内存访问模式，提高缓存命中率

9. 不同语言实现对比

虽然本文聚焦C语言实现，但了解其他语言的实现方式也有助于深入理解：

Python实现（使用字典）：

python复制def containsNearbyDuplicate(nums, k):
    seen = {}
    for i, num in enumerate(nums):
        if num in seen and i - seen[num] <= k:
            return True
        seen[num] = i
    return False

Java实现（使用HashMap）：

java复制public boolean containsNearbyDuplicate(int[] nums, int k) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        if (map.containsKey(nums[i]) && i - map.get(nums[i]) <= k) {
            return true;
        }
        map.put(nums[i], i);
    }
    return false;
}

C++实现（使用unordered_map）：

cpp复制bool containsNearbyDuplicate(vector<int>& nums, int k) {
    unordered_map<int, int> map;
    for (int i = 0; i < nums.size(); i++) {
        if (map.count(nums[i]) && i - map[nums[i]] <= k) {
            return true;
        }
        map[nums[i]] = i;
    }
    return false;
}