LeetCode 219题解析：哈希表实现存在重复元素II

1. 题目解析与需求理解

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

题目给出的函数原型是：

c复制bool containsNearbyDuplicate(int* nums, int numsSize, int k)

其中：

• nums是输入的整数数组
• numsSize是数组的长度
• k是允许的最大索引差

举个例子，对于输入nums = [1,2,3,1]，k = 3，因为第一个1和最后一个1的索引差是3（0和3），所以返回true。如果k = 2，则返回false。

2. 解题思路分析

2.1 暴力解法分析

最直观的解法是使用双重循环遍历数组，对于每个元素，检查其后k个元素中是否有相同的值。这种方法的时间复杂度是O(n*k)，在k较大时效率很低。

c复制// 暴力解法示例
bool containsNearbyDuplicate(int* nums, int numsSize, int k) {
    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;
}

2.2 哈希表优化思路

更高效的解法是使用哈希表来记录元素及其索引。我们可以在遍历数组时，维护一个大小为k+1的滑动窗口，使用哈希表存储窗口内的元素。这样可以将时间复杂度降低到O(n)。

具体步骤：

1. 初始化一个空的哈希表
2. 遍历数组中的每个元素
3. 对于当前元素，检查是否已存在于哈希表中
4. 如果存在且索引差≤k，返回true
5. 否则，更新哈希表中该元素的索引
6. 如果哈希表大小超过k，移除最早加入的元素

3. C语言实现详解

3.1 哈希表的选择与实现

在C语言中，标准库没有提供现成的哈希表实现，我们需要自己实现一个简单的哈希表。这里我们使用开放寻址法来处理哈希冲突。

c复制#define HASH_SIZE 10000

typedef struct {
    int key;
    int val;
} HashItem;

typedef struct {
    HashItem* items[HASH_SIZE];
} HashTable;

// 哈希函数
unsigned int hash(int key) {
    return (unsigned int)(key) % HASH_SIZE;
}

// 初始化哈希表
void hashInit(HashTable* table) {
    for (int i = 0; i < HASH_SIZE; i++) {
        table->items[i] = NULL;
    }
}

// 插入元素
void hashInsert(HashTable* table, int key, int val) {
    unsigned int h = hash(key);
    while (table->items[h] != NULL) {
        h = (h + 1) % HASH_SIZE;
    }
    HashItem* item = (HashItem*)malloc(sizeof(HashItem));
    item->key = key;
    item->val = val;
    table->items[h] = item;
}

// 查找元素
HashItem* hashFind(HashTable* table, int key) {
    unsigned int h = hash(key);
    while (table->items[h] != NULL) {
        if (table->items[h]->key == key) {
            return table->items[h];
        }
        h = (h + 1) % HASH_SIZE;
    }
    return NULL;
}

// 删除元素
void hashRemove(HashTable* table, int key) {
    unsigned int h = hash(key);
    while (table->items[h] != NULL) {
        if (table->items[h]->key == key) {
            free(table->items[h]);
            table->items[h] = NULL;
            return;
        }
        h = (h + 1) % HASH_SIZE;
    }
}

3.2 完整解题代码实现

基于上述哈希表实现，我们可以写出完整的解题代码：

c复制bool containsNearbyDuplicate(int* nums, int numsSize, int k) {
    if (numsSize <= 1 || k <= 0) return false;
    
    HashTable table;
    hashInit(&table);
    
    for (int i = 0; i < numsSize; i++) {
        HashItem* item = hashFind(&table, nums[i]);
        if (item != NULL && i - item->val <= k) {
            // 清理哈希表内存
            for (int j = 0; j < HASH_SIZE; j++) {
                if (table.items[j] != NULL) {
                    free(table.items[j]);
                }
            }
            return true;
        }
        hashInsert(&table, nums[i], i);
        
        // 维护滑动窗口大小不超过k
        if (i >= k) {
            hashRemove(&table, nums[i - k]);
        }
    }
    
    // 清理哈希表内存
    for (int j = 0; j < HASH_SIZE; j++) {
        if (table.items[j] != NULL) {
            free(table.items[j]);
        }
    }
    
    return false;
}

4. 复杂度分析与优化

4.1 时间复杂度分析

• 暴力解法：O(n*k)
• 哈希表解法：O(n)，因为每个元素最多被插入、查找和删除一次

4.2 空间复杂度分析

哈希表解法需要额外的O(min(n,k))空间来存储哈希表，因为滑动窗口的大小最多为k+1。

4.3 进一步优化思路

1. 使用更高效的哈希函数减少冲突
2. 对于小范围的整数，可以使用数组代替哈希表
3. 考虑使用C++的unordered_map（如果允许使用C++）

5. 边界条件与测试用例

5.1 常见边界条件

1. 空数组或单元素数组
2. k=0的情况
3. 数组中所有元素都相同
4. 数组中所有元素都不同
5. 重复元素刚好在k+1的位置

5.2 测试用例示例

c复制void test() {
    int nums1[] = {1,2,3,1};
    assert(containsNearbyDuplicate(nums1, 4, 3) == true);
    
    int nums2[] = {1,0,1,1};
    assert(containsNearbyDuplicate(nums2, 4, 1) == true);
    
    int nums3[] = {1,2,3,1,2,3};
    assert(containsNearbyDuplicate(nums3, 6, 2) == false);
    
    int nums4[] = {99,99};
    assert(containsNearbyDuplicate(nums4, 2, 2) == true);
    
    int nums5[] = {1};
    assert(containsNearbyDuplicate(nums5, 1, 1) == false);
    
    printf("All test cases passed!\n");
}

6. 常见问题与调试技巧

6.1 内存泄漏问题

在C语言实现哈希表时，容易忘记释放内存。确保在函数返回前释放所有分配的哈希表项。

6.2 哈希冲突处理

开放寻址法可能导致聚集现象，可以通过以下方式优化：

1. 使用更好的哈希函数
2. 二次探测代替线性探测
3. 当负载因子过高时重建哈希表

6.3 性能调优技巧

1. 对于小规模数据，暴力解法可能更快
2. 可以预先检查k是否大于等于numsSize-1，这种情况下问题简化为检查是否有重复元素
3. 使用更紧凑的数据结构，如位图（如果元素范围有限）

7. 实际应用场景

这类滑动窗口与哈希表结合的技术在实际开发中有广泛应用：

1. 网络数据流分析：检测短时间内重复的请求
2. 日志分析：找出短时间内出现的重复错误
3. 缓存实现：LRU缓存淘汰算法与本题思路类似
4. 基因组分析：寻找特定距离内的重复序列

8. 扩展思考

8.1 类似题目推荐

1. LeetCode 217 - 存在重复元素（更简单的基础版）
2. LeetCode 220 - 存在重复元素 III（增加了值的限制）
3. LeetCode 76 - 最小覆盖子串（更复杂的滑动窗口问题）

8.2 算法模式识别

本题体现了两个重要的算法模式：

1. 滑动窗口技术：维护一个动态的窗口区间
2. 哈希表快速查找：实现O(1)时间复杂度的查找

掌握这两种技术可以解决一大类数组/字符串处理问题。

8.3 不同语言实现对比

在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

这种实现更简洁，但理解底层原理（哈希表实现）对于性能优化和解决更复杂问题很有帮助。