Leetcode Longest Consecutive Sequence

最新推荐文章于 2025-08-10 09:12:36 发布

rosepicker

最新推荐文章于 2025-08-10 09:12:36 发布

阅读量297

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 文章标签： leetcode

本文链接：https://blog.youkuaiyun.com/rosepicker/article/details/74562774

leetcode 专栏收录该内容

124 篇文章

订阅专栏

本文介绍了一种寻找整数数组中最长连续元素序列的算法，并提供了两种实现方式：一种使用哈希映射，确保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.

代码如下：

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        map<int,int> hashMap;
        int result = 0;
        for(int i=0;i<num.size();i++)
        {
            if(hashMap.find(num[i]) == hashMap.end())
            {
                int left=0,right = 0;
                if(hashMap.find(num[i]-1) == hashMap.end())
                    left = 0;
                else
                    left = hashMap[num[i]-1];
                
                if(hashMap.find(num[i]+1) == hashMap.end())
                    right = 0;
                else
                    right = hashMap[num[i]+1];
                
                hashMap[num[i]] = right+left+1;
                result = max(result,right+left+1);
                
                hashMap[num[i]-left] = right+left+1;
                hashMap[num[i]+right] = left+right+1;
            }
            else
                continue;
        }
        return result;
    }
};

对数据结构进行修改，代码如下：

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        unordered_map<int,int> hashMap;
        int result = 0;
        for(int i=0;i<num.size();i++)
        {
            if(hashMap.find(num[i]) == hashMap.end())
            {
                int left=0,right = 0;
                if(hashMap.find(num[i]-1) == hashMap.end())
                    left = 0;
                else
                    left = hashMap[num[i]-1];
                
                if(hashMap.find(num[i]+1) == hashMap.end())
                    right = 0;
                else
                    right = hashMap[num[i]+1];
                
                hashMap[num[i]] = right+left+1;
                result = max(result,right+left+1);
                
                hashMap[num[i]-left] = right+left+1;
                hashMap[num[i]+right] = left+right+1;
            }
            else
                continue;
        }
        return result;
    }
};

另一种方法，就是先排序然后求连续子序列即可，代码如下：

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        if (nums.size() == 0) {
            return 0;
        }
        sort(nums.begin(), nums.end());
        int len = 0;
        int temp = 1;
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] == nums[i - 1]) continue;
            if (nums[i] == nums[i - 1] + 1) {
                temp++;
            } else {
                len = max(len, temp);
                temp = 1;
            }
        }
        len = max(len, temp);
        return len;
    }
};