leetcode 128. 最长连续序列

128. 最长连续序列

🤡错解，20250314

class Solution {
public:
    //错解，比如[-1000000000,1,2,3,9,1000000000]输出1
    int longestConsecutive(vector<int>& nums) {
        int size = nums.size();
        if(size == 0)  return 0;
        int minNum = *(min_element(nums.begin(),nums.end()));
        int maxNum = *(max_element(nums.begin(),nums.end()));
        vector<int> minBase(100001);//表示从minNum ~ minNum + 100000
        vector<int> maxBase(100001);//表示从maxNum - 100000 ~ maxNum
        for(int &n : nums){
            if(n >= minNum && n <= minNum + 100000)  ++minBase[n - minNum];
        }
        for(int &n : nums){
            if(n >= maxNum - 100000 && n <= maxNum)  ++maxBase[n - maxNum + 100000];
        }

        int res = 0;
        for(int i = 0,flag = 0;i < 100001;){
            while(flag < 100001 && minBase[flag] == 0)  ++flag;//将flag移动到第一个非0位置
            i = flag;
            while(i < 100001 && minBase[i] != 0) ++i;
            res = max(res,i - flag);
            flag = i;
        }
        for(int i = 0,flag = 0;i < 100001;){
            while(flag < 100001 && maxBase[flag] == 0)  ++flag;//将flag移动到第一个非0位置
            i = flag;
            while(i < 100001 && maxBase[i] != 0) ++i;
            res = max(res,i - flag);
            flag = i;
        }
        
        return res;
    }
};

灵神题解：

 

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        int res = 0; // 用于存储最长连续序列的长度
        unordered_set<int> st(nums.begin(), nums.end()); // 将数组转换为哈希集合，方便快速查找
        
        // 遍历哈希集合中的每个元素
        for (int &x : st) {
            // 如果当前元素x的前一个数x-1存在集合中，说明x不是连续序列的起点，跳过
            if (st.contains(x - 1))  continue;
            
            // 如果x是连续序列的起点，则开始寻找这个连续序列的长度
            int y = x + 1; // 从x的下一个数开始查找
            
            // 循环查找y是否在集合中，直到找不到为止
            while (st.contains(y)) {
                y++; // 如果y存在，继续找下一个数
            }
            
            // 循环结束后，y是第一个不在集合中的数，所以连续序列的长度是y - x
            res = max(res, y - x); // 更新最长连续序列的长度
        }
        
        return res; // 返回最长连续序列的长度
    }
};

 

20251204重做

class Solution {
    public int longestConsecutive(int[] nums) {
        HashSet<Integer> numSet = new HashSet<>();
        for(int n : nums)  numSet.add(n);
        int longgestLen = 0;
        for(int n : numSet){
            if(numSet.contains(n-1))  continue;
            int currentNum = n;
            while(numSet.contains(currentNum + 1))  ++currentNum;
            longgestLen = Math.max(longgestLen,currentNum - n + 1);
        }
        return longgestLen;
    }
}

 

比上一个方法进一步优化

class Solution {
    public int longestConsecutive(int[] nums) {
        HashSet<Integer> numSet = new HashSet<>();
        for(int n : nums)  numSet.add(n);
        int longgestLen = 0;
        int sizeSet = numSet.size();//不同数字的个数
        for(int n : numSet){
            if(numSet.contains(n-1))  continue;//保证本次循环的n是数字链的开头
            int currentNum = n;
            while(numSet.contains(currentNum + 1))  ++currentNum;
            longgestLen = Math.max(longgestLen,currentNum - n + 1);
            if(longgestLen * 2 >= sizeSet)  break;//不会再有比目前更大的数字链了
        }
        return longgestLen;
    }
}