LeetCode-Longest Consecutive Sequence

本文介绍了一种算法,用于在未排序的整数数组中找到最长的连续整数序列。通过使用哈希集合,该算法能够在O(n)复杂度内解决问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

For example,
Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.

Your algorithm should run in O(n) complexity.

Solution:

Code:

<span style="font-size:14px;">class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        const int length = num.size();
        if (length == 0 || length == 1) return length;
        unordered_set<int> s;
        for (int i = 0; i < length; ++i)
            s.insert(num[i]);
        int result = 1, count, temp;
        for (int i = 0; i < length; ++i)
            if (s.find(num[i]) != s.end()) {
                temp = num[i];
                s.erase(temp);
                count = 1;
                while (s.find(temp-1) != s.end()) {
                    --temp;
                    ++count;
                    s.erase(temp);
                }
                temp = num[i];
                while (s.find(temp+1) != s.end()) {
                    ++temp;
                    ++count;
                    s.erase(temp);
                }
                result = max(result, count);
            }
        return result;
    }
};</span>



<think>嗯,我现在需要把这个C++的代码转换成C语言的代码,实现相同的功能。首先,我得仔细理解原来的代码逻辑。原题是找到最长连续序列的长度,对吧?原代码用了unordered_set来存储所有数字,然后遍历每个数字,如果当前数字是序列的起点(即没有比它小1的数字存在),就不断向后查找连续的数字,统计长度。最后更新最长长度。 那C语言里没有unordered_set这样的数据结构,得自己实现类似的功能。可能需要用哈希表或者数组来模拟集合。不过考虑到效率,用哈希表可能更合适。但是C标准库没有现成的哈希表,得自己写一个简单的。或者,如果数字的范围不大,可以用数组来标记存在性。不过题目里数字可能很大,用数组的话空间可能不够。所以还是得用哈希表。 首先,我需要一个哈希表结构,支持插入和查找操作。C语言中可以用链表来处理冲突,或者用开放寻址法。开放寻址法可能实现起来简单一些?或者链表更直观?不过时间可能比较紧,链表实现可能更直接。 然后,原代码中的unordered_set被用来存储所有数字,之后遍历每个元素。在C中,我需要创建一个哈希表,将所有数字插入进去。然后,同样遍历每个数字,检查是否是序列的起点,然后向后查找。 接下来,考虑哈希表的结构。比如,定义一个结构体,包含键和是否存在的标志。或者,可以简单使用一个动态数组来存储所有唯一的数字,然后进行排序,再找最长连续序列?不过原题解的方法时间复杂度是O(n),而排序的话会是O(n log n),可能不符合题目要求。所以必须按照原方法的O(n)时间复杂度来实现。 所以必须用哈希表。那如何实现哈希表呢?或许可以使用uthash这个库?但用户要求给出必要的头文件,可能希望用标准库实现。不过标准C没有哈希表,所以可能需要自己实现一个简单的哈希表结构。 或者,考虑到时间,可能可以先将数组排序,然后遍历找最长连续序列。但这样的话时间复杂度是O(n log n),但题目可能希望更优的解法。不过原题的解法是O(n)的,所以可能需要用哈希表。 那现在问题转化为如何在C中实现一个哈希集合,支持O(1)时间的插入和查询。这时候可能需要使用uthash,这是一个常用的库,但需要包含头文件"uthash.h"。但用户可能希望不依赖第三方库,所以需要自己实现。 或者,假设用户允许使用uthash的话,那么代码会更简洁。但可能题目希望用纯C的标准库,所以需要自己写一个哈希表。 不过自己实现一个完整的哈希表可能比较复杂,尤其是处理冲突。这里可能需要简化问题,比如使用开放寻址法中的线性探测,或者双重哈希等。 或者,考虑到时间限制,这里可能采用另一种方法:将原数组中的所有元素存入一个动态数组,然后去重,再遍历。但原题解的方法关键在于利用哈希集合快速判断是否存在相邻元素,所以去重后的数组可能还是需要快速查找,所以还是需要哈希表。 看来无论如何,必须实现哈希表结构。所以现在需要设计一个哈希表的结构,支持插入和存在检查。 首先,定义哈希表的结构。比如,每个节点包含一个整数值和一个标记表示是否存在。或者,可以用一个结构体数组,每个位置存储一个值和一个状态(是否被占用)。 或者,使用链表法处理冲突。每个哈希表的槽位是一个链表的头指针。当插入一个值时,计算哈希值,找到对应的槽位,然后遍历链表,如果值不存在,则添加到链表。 例如,定义一个结构体HashNode,包含int num,和next指针。哈希表是一个数组,每个元素是HashNode*。哈希函数可以是简单的取模运算。 但这样实现起来代码会比较长,需要处理链表的插入和查找。 或者,使用uthash库,这是一个单文件头文件库,可以方便地集成到代码中。但用户可能需要独立的代码,不依赖外部文件。不过如果允许的话,使用uthash会比较方便。 假设用户允许使用uthash,那么代码可以这样写: 包含uthash.h,然后定义一个结构体作为哈希表的元素: struct hash_table { int key; UT_hash_handle hh; }; 然后,插入和查询都可以用HASH_FIND_INT和HASH_ADD_INT等宏。 但原题解中的unordered_set存储所有数字,所以需要将所有数字插入哈希表。然后遍历每个元素,检查是否存在num-1,如果不存在,则开始向后查找。 这样,在C语言中,可以这样做: 1. 将所有数字插入哈希表。 2. 遍历哈希表中的每个元素。 3. 对于每个元素,如果不存在num-1,则开始向后计数,直到找不到更大的数为止。 4. 记录最长的连续长度。 使用uthash的话,遍历哈希表的元素可以使用HASH_ITER宏。 这样,整个代码的结构会比较接近原C++代码。 但用户可能希望不使用第三方库,那么必须自己实现哈希表。这可能比较复杂,但为了符合题目要求,可能需要这样做。 或者,另一种思路是,先对数组进行排序,然后遍历数组,统计连续序列的长度。但这样时间复杂度是O(n log n),可能不符合题目要求的O(n)。不过题目可能没有明确要求时间复杂度,但原题解的方法更优,所以需要尽量保持。 不过假设用户希望的是正确的功能,那么可能可以接受排序的方法,但需要明确说明。或者,必须按照原题解的O(n)方法。 现在回到问题,用户要求将C++代码转换为C,实现相同的功能。所以必须使用哈希表来达到O(n)的时间复杂度。 现在,我需要自己实现一个哈希表。例如,使用开放寻址法,处理冲突。 哈希表的大小可以选择一个质数,例如100003或者类似的,根据输入数组的大小动态调整。或者,可以动态扩容,但这会增加复杂度。这里可能可以预先分配较大的空间,比如初始大小为1e5,或者动态计算。 不过,这可能比较复杂。或者,可以使用一个固定大小的哈希表,但这样当数据量大时,冲突会较多,影响效率。但为了简化代码,可能可以接受。 例如,定义哈希表的结构: #define HASH_SIZE 1000003 typedef struct { int key; bool exists; } HashEntry; HashEntry hashTable[HASH_SIZE]; 然后,哈希函数可以是abs(num) % HASH_SIZE。处理冲突时,使用线性探测,即如果当前位置被占用,就检查下一个位置,直到找到空位或相同的键。 插入函数:计算哈希值,找到对应的位置。如果该位置已经被占用且键相同,则无需插入。否则,找到下一个空的位置,插入键,并标记存在。 查找函数:计算哈希值,然后线性探测,直到找到键或者空位置。 但这样的实现可能需要处理很多情况,代码量较大。但为了转换原代码的功能,必须实现这样的结构。 但这样的话,整个代码会比较长,尤其是处理哈希表的插入和查询。 或者,考虑到在C语言中,可以使用动态数组来存储所有唯一的元素,然后使用标准库的bsearch来进行查找。例如,将所有数字存入数组,排序,去重,然后对于每个元素,检查是否存在num-1,如果不存在,则开始向后查找。此时,查找可以用二分查找。但这样的话,时间复杂度是O(n log n),因为排序需要O(n log n),而每个元素的查找是O(log n)。但原题解的算法是O(n),所以这可能不符合要求。 但用户可能希望的是正确实现功能,而时间效率可能不是首要考虑。或者,题目可能允许这样的解法。但原题解的解法更优,所以可能需要按原方法转换。 那回到哈希表的实现。为了简化,可能可以使用一个较大的哈希表,并使用开放寻址法处理冲突。例如: #define TABLE_SIZE 1000003 typedef struct { int num; bool exists; } HashEntry; HashEntry hashTable[TABLE_SIZE]; 初始化时将所有exists设为false。 哈希函数可以用num mod TABLE_SIZE,但要注意负数的情况。例如,可以先将num转为unsigned,再mod。 插入函数: void insert(int num) { unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { return; // 已存在 } hash = (hash + 1) % TABLE_SIZE; // 线性探测 } hashTable[hash].num = num; hashTable[hash].exists = true; } 查找函数: bool contains(int num) { unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { return true; } hash = (hash + 1) % TABLE_SIZE; } return false; } 但这样的实现可能存在问题,比如当哈希表已满时,无法插入。但假设输入的数据量不大,或者TABLE_SIZE足够大,可以避免这种情况。或者,动态调整哈希表的大小,但这会增加代码复杂度。 在本题中,假设输入数据量不大,或者TABLE_SIZE足够大,可以处理所有情况。 所以,整个C代码的结构大致如下: 包含必要的头文件,如stdio.h,stdlib.h,stdbool.h。 定义哈希表的结构和函数。 然后,主函数或者某个处理函数中,读取输入,插入哈希表,然后遍历每个元素,检查是否是序列的起点,计算长度,更新最大值。 但原代码中的num_set是遍历每个元素,而哈希表中的元素可能有很多冲突后的位置,所以需要遍历原始数组中的元素吗?或者需要遍历哈希表中的所有有效元素? 原C++代码中,遍历的是num_set中的每个元素,即每个唯一的值。所以在C中,需要将输入数组中的所有元素插入哈希表,并且遍历所有唯一的元素。但哈希表的实现可能无法直接遍历所有元素,因为开放寻址法中的元素是分散的。这时候可能需要维护一个单独的数组来存储所有唯一的元素,或者在插入时记录。 或者,可以先将输入数组中的所有元素插入哈希表,然后遍历原始数组中的每个元素,但这样可能会有重复元素,导致多次处理同一个数字。所以需要去重,或者在处理时跳过已经处理过的数字。 或者,维护一个动态数组unique_nums,每次插入哈希表时,如果元素不存在,则添加到unique_nums中。这样,遍历unique_nums数组中的每个元素即可。 这可能更高效。例如: 在插入哈希表的时候,如果元素是新插入的,就将它添加到unique_nums数组中。这样,unique_nums数组保存所有唯一的元素,之后遍历这个数组即可。 所以,修改插入函数,返回是否成功插入,从而在外部维护unique_nums数组。 例如: bool insert(int num, int* unique_count, int** unique_nums) { // 插入哈希表,返回是否插入成功(即是否是新元素) unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { return false; // 已存在 } hash = (hash + 1) % TABLE_SIZE; } hashTable[hash].num = num; hashTable[hash].exists = true; // 添加到unique_nums数组 (*unique_count)++; *unique_nums = realloc(*unique_nums, (*unique_count) * sizeof(int)); (*unique_nums)[(*unique_count)-1] = num; return true; } 但这会增加代码的复杂度,因为需要动态数组的管理。或者,在插入哈希表的同时,维护一个动态数组来保存所有唯一的元素。这可能更简单,因为遍历的时候只需要遍历这个数组即可。 所以,整体步骤是: 1. 读取输入数组。 2. 将所有元素插入哈希表,并记录唯一的元素到unique_nums数组。 3. 遍历unique_nums数组中的每个元素,处理逻辑与原C++代码相同。 这样,C代码的结构大致如下: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define TABLE_SIZE 1000003 typedef struct { int num; bool exists; } HashEntry; HashEntry hashTable[TABLE_SIZE]; void insert(int num) { unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { return; } hash = (hash + 1) % TABLE_SIZE; } hashTable[hash].num = num; hashTable[hash].exists = true; } bool contains(int num) { unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { return true; } hash = (hash + 1) % TABLE_SIZE; } return false; } int longestConsecutive(int* nums, int numsSize) { // 初始化哈希表 for (int i = 0; i < TABLE_SIZE; i++) { hashTable[i].exists = false; } int* unique_nums = NULL; int unique_count = 0; // 插入所有数字到哈希表,并收集唯一元素 for (int i = 0; i < numsSize; i++) { int num = nums[i]; unsigned int hash = (unsigned int)num % TABLE_SIZE; bool found = false; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { found = true; break; } hash = (hash + 1) % TABLE_SIZE; } if (!found) { hashTable[hash].num = num; hashTable[hash].exists = true; // 添加到unique_nums数组 unique_count++; unique_nums = realloc(unique_nums, unique_count * sizeof(int)); unique_nums[unique_count - 1] = num; } } int longestStreak = 0; for (int i = 0; i < unique_count; i++) { int num = unique_nums[i]; if (!contains(num - 1)) { int currentNum = num; int currentStreak = 1; while (contains(currentNum + 1)) { currentNum++; currentStreak++; } if (currentStreak > longestStreak) { longestStreak = currentStreak; } } } free(unique_nums); return longestStreak; } int main() { // 示例输入 int nums[] = {100, 4, 200, 1, 3, 2}; int numsSize = sizeof(nums) / sizeof(nums[0]); int result = longestConsecutive(nums, numsSize); printf("最长连续序列的长度是: %d\n", result); // 应输出4 return 0; } 这样,代码可能可以工作。但可能存在一些问题: 1. TABLE_SIZE可能不够大,导致哈希冲突过多,影响性能,甚至导致死循环。例如,当插入的元素数量接近TABLE_SIZE时,线性探测可能需要很久才能找到空位,或者无法找到,导致插入失败。或者,当TABLE_SIZE不够大时,无法插入所有元素,导致错误。 因此,可能需要动态调整哈希表的大小,或者使用更大的TABLE_SIZE。比如,将TABLE_SIZE设置为更大的值,如1e6+3。或者,改用动态分配的哈希表,并在需要时扩容。 但为了简化代码,这里暂时使用一个足够大的固定大小,假设输入数据量不是特别大。 另一个问题是,contains函数中的哈希计算可能与插入时的哈希计算方式不同,但由于插入和查找使用相同的哈希函数,应该没问题。 此外,初始化哈希表时,需要在每次调用longestConsecutive函数时重置哈希表的状态。例如,在函数开始时,将所有exists设为false。这可能比较耗时,如果TABLE_SIZE很大。例如,如果TABLE_SIZE是1e6+3,每次都要遍历整个数组,这会花费一定时间。 可能的优化是,在插入时,不需要全局的哈希表,而是动态创建,并在函数结束时释放。或者,在函数内部动态分配哈希表,并在结束时释放。例如,在longestConsecutive函数中动态分配HashEntry数组: HashEntry* hashTable = calloc(TABLE_SIZE, sizeof(HashEntry)); 然后在函数结束时free(hashTable)。这样,每次函数调用都重新分配和释放内存,避免全局变量的问题。但这样会增加内存分配的开销。 可能更好的方式是动态分配哈希表,并在函数中使用。例如,修改代码: int longestConsecutive(int* nums, int numsSize) { // 动态分配哈希表 HashEntry* hashTable = calloc(TABLE_SIZE, sizeof(HashEntry)); // ...其他代码 free(hashTable); } 这样可以避免全局变量的问题,但需要更大的内存分配。 综上,将哈希表改为动态分配的,并在函数内部处理。 修改后的代码: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define TABLE_SIZE 1000003 typedef struct { int num; bool exists; } HashEntry; void insert(HashEntry* hashTable, int num) { unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { return; } hash = (hash + 1) % TABLE_SIZE; } hashTable[hash].num = num; hashTable[hash].exists = true; } bool contains(HashEntry* hashTable, int num) { unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { return true; } hash = (hash + 1) % TABLE_SIZE; } return false; } int longestConsecutive(int* nums, int numsSize) { if (numsSize == 0) return 0; HashEntry* hashTable = calloc(TABLE_SIZE, sizeof(HashEntry)); int* unique_nums = NULL; int unique_count = 0; // 插入所有数字到哈希表,并收集唯一元素 for (int i = 0; i < numsSize; i++) { int num = nums[i]; unsigned int hash = (unsigned int)num % TABLE_SIZE; bool found = false; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { found = true; break; } hash = (hash + 1) % TABLE_SIZE; } if (!found) { hashTable[hash].num = num; hashTable[hash].exists = true; // 添加到unique_nums数组 unique_count++; unique_nums = realloc(unique_nums, unique_count * sizeof(int)); unique_nums[unique_count - 1] = num; } } int longestStreak = 0; for (int i = 0; i < unique_count; i++) { int num = unique_nums[i]; if (!contains(hashTable, num - 1)) { int currentNum = num; int currentStreak = 1; while (contains(hashTable, currentNum + 1)) { currentNum++; currentStreak++; } if (currentStreak > longestStreak) { longestStreak = currentStreak; } } } free(hashTable); free(unique_nums); return longestStreak; } int main() { // 示例输入 int nums[] = {100, 4, 200, 1, 3, 2}; int numsSize = sizeof(nums) / sizeof(nums[0]); int result = longestConsecutive(nums, numsSize); printf("最长连续序列的长度是: %d\n", result); // 应输出4 return 0; } 这样,每次调用函数时动态分配哈希表,处理完成后释放,避免全局变量的干扰。 现在,测试代码是否正确。例如,示例输入应该得到4。另外,处理空输入时返回0。 但可能存在一些问题: 1. 哈希表的冲突处理可能导致插入失败,当哈希表已满时,但假设TABLE_SIZE足够大,可以处理所有输入。 2. unique_nums数组是否正确收集了所有唯一的元素。例如,当插入哈希表时,必须确保只有唯一的元素被添加到unique_nums数组。这在代码中是成立的,因为当插入哈希表时,如果发现元素已经存在,则不会添加到unique_nums。 3. contains函数是否正确,例如,当哈希表中有元素时,是否能正确找到。 综上,这样的代码应该可以工作。但可能在极端情况下(如大量数据)出现性能问题,但在一般的题目测试用例下应该可以接受。 最后,为代码添加必要的注释,说明各个部分的功能,头文件,输入输出示例等。</think>以下是转换后的C语言代码实现,包含必要的头文件、输入输出示例及注释: ```c #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define TABLE_SIZE 1000003 // 哈希表大小,需足够大以减少冲突 typedef struct { int num; // 存储的数值 bool exists; // 标记该位置是否被占用 } HashEntry; // 插入数值到哈希表 void insert(HashEntry* hashTable, int num) { unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) return; // 已存在则直接返回 hash = (hash + 1) % TABLE_SIZE; // 线性探测解决冲突 } hashTable[hash].num = num; hashTable[hash].exists = true; } // 检查数值是否存在于哈希表 bool contains(HashEntry* hashTable, int num) { unsigned int hash = (unsigned int)num % TABLE_SIZE; while (hashTable[hash].exists) { if (hashTable[hash].num == num) return true; hash = (hash + 1) % TABLE_SIZE; } return false; } int longestConsecutive(int* nums, int numsSize) { if (numsSize == 0) return 0; // 处理空数组 HashEntry* hashTable = calloc(TABLE_SIZE, sizeof(HashEntry)); // 动态分配哈希表 int* unique_nums = NULL; // 存储唯一元素的动态数组 int unique_count = 0; // 唯一元素个数 // 将所有数字插入哈希表并收集唯一元素 for (int i = 0; i < numsSize; i++) { int num = nums[i]; unsigned int hash = (unsigned int)num % TABLE_SIZE; bool found = false; while (hashTable[hash].exists) { if (hashTable[hash].num == num) { found = true; break; } hash = (hash + 1) % TABLE_SIZE; } if (!found) { hashTable[hash].num = num; hashTable[hash].exists = true; // 添加到唯一元素数组 unique_count++; unique_nums = realloc(unique_nums, unique_count * sizeof(int)); unique_nums[unique_count - 1] = num; } } int longestStreak = 0; // 遍历所有唯一元素寻找最长连续序列 for (int i = 0; i < unique_count; i++) { int num = unique_nums[i]; if (!contains(hashTable, num - 1)) { // 仅当num是序列起点时处理 int currentNum = num; int currentStreak = 1; // 向后查找连续数字 while (contains(hashTable, currentNum + 1)) { currentNum++; currentStreak++; } if (currentStreak > longestStreak) { longestStreak = currentStreak; } } } free(hashTable); // 释放哈希表内存 free(unique_nums); // 释放唯一数组内存 return longestStreak; } int main() { // 示例输入 int nums[] = {100, 4, 200, 1, 3, 2}; int numsSize = sizeof(nums) / sizeof(nums[0]); int result = longestConsecutive(nums, numsSize); printf("最长连续序列的长度是: %d\n", result); // 输出应为4 return 0; } ``` ### 代码说明: 1. **哈希表实现** 使用线性探测法解决冲突,通过`TABLE_SIZE`控制哈希表大小。`insert()`和`contains()`函数分别用于插入和查询操作。 2. **去重处理** 插入过程中自动过滤重复元素,并将唯一元素存储在动态数组`unique_nums`中。 3. **核心逻辑** - 遍历所有唯一元素,仅当当前元素是某个连续序列的起点时(即`num-1`不存在),向后统计连续序列长度。 - 时间复杂度为$O(n)$,空间复杂度为$O(n)$。 ### 输入输出示例: 输入:`[100, 4, 200, 1, 3, 2]` 输出:`最长连续序列的长度是: 4` 解释:最长连续序列是`[1, 2, 3, 4]`,长度为4。 ### 注意事项: - 哈希表大小`TABLE_SIZE`需根据实际数据范围调整,确保足够大以避免频繁冲突。 - 动态数组`unique_nums`在每次插入新元素时使用`realloc`扩展内存,可能有一定性能开销。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值