Java详解LeetCode 热题 100(03):LeetCode 128. 最长连续序列（Longest Consecutive Sequence）详解

于 2025-04-29 00:24:32 发布
阅读量1k 收藏 8
点赞数 31
分类专栏： LeetCode 热题 100+多种思路+java实现 文章标签： leetcode 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yk_dflkg/article/details/147541631
版权

文章目录

1. 题目描述

给定一个未排序的整数数组 nums，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1：

输入：nums = [100,4,200,1,3,2]
输出：4
解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

示例 2：

输入：nums = [0,3,7,2,5,8,4,6,0,1]
输出：9
解释：最长数字连续序列是 [0,1,2,3,4,5,6,7,8]。它的长度为 9。

提示：

  • 0 <= nums.length <= 10^5
  • -10^9 <= nums[i] <= 10^9

2. 理解题目

这道题要求我们从一个未排序的数组中找出最长的连续数字序列的长度。注意，这里的"连续"是指数值上连续（如1,2,3,4），而非原数组中的位置连续。

关键点：

  1. 数组未排序
  2. 连续是指数值上连续（相邻数字之差为1）
  3. 要求时间复杂度为O(n)
  4. 原数组中可能包含重复元素

3. 解法一：排序法

3.1 思路

最直观的方法是先对数组进行排序，然后遍历排序后的数组，计算连续序列的长度：

  1. 对数组进行排序
  2. 初始化当前连续序列长度为1，最长连续序列长度为0（空数组情况）
  3. 遍历排序后的数组：
    • 如果当前元素与前一个元素相同，跳过（去重）
    • 如果当前元素与前一个元素差值为1，连续序列长度加1
    • 否则，重置当前连续序列长度为1
    • 更新最长连续序列长度

3.2 Java代码实现

import java.util.Arrays;

public class Solution {
    public int longestConsecutive(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        // 对数组进行排序
        Arrays.sort(nums);
        
        int currentStreak = 1;  // 当前连续序列长度
        int longestStreak = 1;  // 最长连续序列长度
        
        for (int i = 1; i < nums.length; i++) {
            // 跳过重复元素
            if (nums[i] == nums[i - 1]) {
                continue;
            }
            
            // 检查是否连续
            if (nums[i] == nums[i - 1] + 1) {
                currentStreak++;
            } else {
                // 重置当前连续序列长度
                currentStreak = 1;
            }
            
            // 更新最长连续序列长度
            longestStreak = Math.max(longestStreak, currentStreak);
        }
        
        return longestStreak;
    }
}

3.3 代码详解

  1. 首先检查输入是否为空，如果是，返回0（没有连续序列）
  2. 使用 Arrays.sort() 对数组进行排序
  3. 初始化 currentStreak 为1（当前遍历的连续序列长度）
  4. 初始化 longestStreak 为1（最长连续序列长度）
  5. 从第二个元素开始遍历排序后的数组：
    • 如果当前元素与前一个元素相同，跳过（去重）
    • 如果当前元素正好比前一个元素大1，表示连续序列继续，currentStreak 加1
    • 否则，连续序列中断，重置 currentStreak 为1
    • 每次迭代后，更新 longestStreak 为当前找到的最长序列长度
  6. 最后返回 longestStreak

3.4 复杂度分析

  • 时间复杂度：O(n log n)，其中n是数组长度。排序需要O(n log n)时间，遍历排序后的数组需要O(n)时间。
  • 空间复杂度：O(1)，仅使用了常数级别的额外空间。（注意：某些排序算法可能使用O(n)的额外空间）

3.5 适用场景

排序法简单直观，易于理解和实现。当数组长度不是特别大，且对时间复杂度要求不太严格时，可以考虑使用此方法。

3.6 优缺点

优点：

  • 代码简洁，易于理解
  • 实现简单，不需要额外的数据结构

缺点：

  • 时间复杂度为O(n log n)，不满足题目要求的O(n)
  • 排序会改变原数组的结构（如果要求保持原数组不变，需要额外空间复制）

4. 解法二：哈希集合法

4.1 思路

为了达到O(n)的时间复杂度，我们可以使用哈希集合（HashSet）来优化查找过程：

  1. 将所有元素放入哈希集合，去除重复元素
  2. 对于每个元素x，检查x-1是否在集合中
  3. 如果x-1不在集合中，说明x可能是连续序列的起点
  4. 从x开始，查找连续的序列x, x+1, x+2, …, x+y
  5. 更新最长连续序列的长度

这种方法的核心思想是只从可能的序列起点开始查找，避免重复计算。

4.2 Java代码实现

import java.util.HashSet;
import java.util.Set;

public class Solution {
    public int longestConsecutive(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        // 将所有元素加入集合，去除重复元素
        Set<Integer> numSet = new HashSet<>();
        for (int num : nums) {
            numSet.add(num);
        }
        
        int longestStreak = 0;
        
        // 遍历集合中的每个元素
        for (int num : numSet) {
            // 如果num-1不在集合中，num可能是连续序列的起点
            if (!numSet.contains(num - 1)) {
                int currentNum = num;
                int currentStreak = 1;
                
                // 查找以num开始的连续序列
                while (numSet.contains(currentNum + 1)) {
                    currentNum++;
                    currentStreak++;
                }
                
                // 更新最长连续序列长度
                longestStreak = Math.max(longestStreak, currentStreak);
            }
        }
        
        return longestStreak;
    }
}

4.3 代码详解

  1. 首先检查输入是否为空，如果是，返回0
  2. 创建一个 HashSet 并将数组中所有元素添加到集合中（自动去除重复元素）
  3. 初始化 longestStreak 为0
  4. 遍历 HashSet 中的每个元素：
    • 对于每个元素 num，检查 num-1 是否在集合中
    • 如果 num-1 不在集合中，说明 num 可能是一个连续序列的起点
    • 从 num 开始，不断检查 num+1, num+2, … 是否在集合中
    • 计算从 num 开始的连续序列长度 currentStreak
    • 更新 longestStreak 为当前找到的最长序列长度
  5. 最后返回 longestStreak

4.4 复杂度分析

  • 时间复杂度：O(n)，其中n是数组长度。
    • 将元素加入哈希集合需要O(n)时间
    • 虽然有嵌套循环，但内层while循环的总执行次数不会超过n，因为每个数字只会被访问一次
    • 所以总时间复杂度为O(n)
  • 空间复杂度：O(n)，哈希集合中存储了所有元素。

4.5 正确性证明

为什么这种方法的时间复杂度是O(n)？

乍看起来，算法中有嵌套循环，可能会被误认为是O(n²)。但实际上：

  1. 外层循环最多执行n次（哈希集合的大小）
  2. 对于每个元素，内层的while循环只有在该元素是连续序列的起点时才执行
  3. 每个元素最多只会被访问一次（在某个连续序列中）
  4. 因此，所有元素总共最多被访问2次，时间复杂度为O(n)

4.6 适用场景

哈希集合法满足题目要求的O(n)时间复杂度，适用于各种规模的输入数据。这是解决此问题的最优方法。

5. 解法三：哈希表记忆法

5.1 思路

我们还可以使用哈希表来存储每个元素作为端点的连续序列长度，并通过合并相邻序列来计算最长连续序列：

  1. 使用哈希表，键为数字，值为以该数字为端点的连续序列长度
  2. 遍历数组，对于每个元素：
    • 检查它是否已存在于哈希表中，如果是，跳过
    • 查找左右相邻数字（x-1和x+1）的序列长度
    • 计算包含当前数字的连续序列长度
    • 更新当前数字及其序列端点的长度
    • 更新最长连续序列长度

5.2 Java代码实现

import java.util.HashMap;
import java.util.Map;

public class Solution {
    public int longestConsecutive(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        // 哈希表：键为数字，值为以该数字为端点的连续序列长度
        Map<Integer, Integer> map = new HashMap<>();
        int longest = 0;
        
        for (int num : nums) {
            // 如果该数字已经存在于哈希表中，跳过
            if (map.containsKey(num)) {
                continue;
            }
            
            // 查找左侧相邻数字的序列长度
            int left = map.getOrDefault(num - 1, 0);
            // 查找右侧相邻数字的序列长度
            int right = map.getOrDefault(num + 1, 0);
            
            // 当前数字所在连续序列的总长度
            int sum = left + right + 1;
            
            // 更新最长连续序列长度
            longest = Math.max(longest, sum);
            
            // 更新当前数字在哈希表中的值
            map.put(num, sum);
            
            // 更新当前序列左右端点的值
            // 注意：中间的数字不需要更新，因为它们不会再被作为新序列的起点或终点
            map.put(num - left, sum);
            map.put(num + right, sum);
        }
        
        return longest;
    }
}

5.3 代码详解

  1. 首先检查输入是否为空，如果是，返回0
  2. 创建一个 HashMap，键为数字，值为以该数字为端点的连续序列长度
  3. 初始化 longest 为0
  4. 遍历数组中的每个元素：
    • 如果该数字已存在于哈希表中，跳过（避免重复处理）
    • 获取左侧相邻数字（num-1）的序列长度
    • 获取右侧相邻数字（num+1）的序列长度
    • 计算包含当前数字的连续序列总长度 sum = left + right + 1
    • 更新最长连续序列长度 longest
    • 更新当前数字在哈希表中的值为 sum
    • 更新当前序列左右端点在哈希表中的值为 sum
  5. 最后返回 longest

5.4 复杂度分析

  • 时间复杂度：O(n)，其中n是数组长度。遍历数组一次，每次哈希表操作的时间复杂度为O(1)。
  • 空间复杂度：O(n)，哈希表最多存储n个元素。

5.5 适用场景

哈希表记忆法也能达到O(n)的时间复杂度，适用于大规模输入数据。与哈希集合法相比，实现稍复杂，但理论上可以减少某些场景下的重复计算。

6. 解法四：并查集法

6.1 思路

并查集（Union-Find）是一种处理元素分组的高效数据结构，我们可以用它来解决此问题：

  1. 创建并查集，每个数字初始为独立的集合
  2. 遍历数组，将相邻的数字合并到同一个集合中
  3. 最后，找出最大集合的大小，即为最长连续序列的长度

6.2 Java代码实现

import java.util.*;

public class Solution {
    public int longestConsecutive(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        // 创建并查集
        Map<Integer, Integer> parent = new HashMap<>();
        Map<Integer, Integer> size = new HashMap<>();
        Set<Integer> numSet = new HashSet<>();
        
        // 初始化并查集
        for (int num : nums) {
            if (!numSet.contains(num)) {
                parent.put(num, num);  // 每个元素的父节点初始为自己
                size.put(num, 1);      // 每个集合的初始大小为1
                numSet.add(num);       // 添加到集合中去重
            }
        }
        
        // 合并相邻的集合
        for (int num : numSet) {
            // 检查num+1是否存在，如果存在则合并
            if (numSet.contains(num + 1)) {
                union(parent, size, num, num + 1);
            }
        }
        
        // 查找最大集合的大小
        int maxSize = 0;
        for (int s : size.values()) {
            maxSize = Math.max(maxSize, s);
        }
        
        return maxSize;
    }
    
    // 查找操作，返回元素x的根节点
    private int find(Map<Integer, Integer> parent, int x) {
        if (parent.get(x) != x) {
            // 路径压缩
            parent.put(x, find(parent, parent.get(x)));
        }
        return parent.get(x);
    }
    
    // 合并操作，将元素x和元素y所在的集合合并
    private void union(Map<Integer, Integer> parent, Map<Integer, Integer> size, int x, int y) {
        int rootX = find(parent, x);
        int rootY = find(parent, y);
        
        if (rootX != rootY) {
            // 合并两个集合，将较小的集合合并到较大的集合
            if (size.get(rootX) < size.get(rootY)) {
                parent.put(rootX, rootY);
                size.put(rootY, size.get(rootX) + size.get(rootY));
            } else {
                parent.put(rootY, rootX);
                size.put(rootX, size.get(rootX) + size.get(rootY));
            }
        }
    }
}

6.3 代码详解

  1. 首先检查输入是否为空，如果是，返回0
  2. 创建三个映射表：
    • parent：存储每个元素的父节点
    • size：存储以每个元素为根的集合的大小
    • numSet：用于去除重复元素
  3. 初始化并查集：
    • 每个元素的父节点初始为自己
    • 每个集合的初始大小为1
  4. 遍历去重后的元素集合，合并相邻的集合：
    • 如果num+1存在，则将num和num+1所在的集合合并
  5. 查找最大集合的大小
  6. find方法用于查找元素的根节点，采用路径压缩优化
  7. union方法用于合并两个集合，采用按大小合并的优化

6.4 复杂度分析

  • 时间复杂度：O(n)，其中n是数组长度。
    • 初始化并查集需要O(n)时间
    • 合并操作总共执行不超过n次
    • 查找操作的平均时间复杂度接近O(1)（使用路径压缩后）
    • 总时间复杂度为O(n)
  • 空间复杂度：O(n)，需要三个大小为O(n)的映射表。

6.5 适用场景

并查集法适用于需要动态连接元素的场景，尤其是当问题可以转化为"将相邻元素合并到同一组"的形式时。这种方法在处理大规模数据时也很高效。

7. 特殊情况和边界处理

在实现解决方案时，我们需要考虑以下特殊情况：

  1. 空数组：当输入为null或空数组时，应返回0。

    if (nums == null || nums.length == 0) {
    return 0;
}

  2. 数组只有一个元素：此时最长连续序列长度为1。

    if (nums.length == 1) {
    return 1;
}

  3. 数组中有重复元素：需要去除重复元素再计算。哈希集合法和哈希表法已经考虑了这一点。

  4. 数值溢出：输入范围是[-10^9, 10^9]，可能需要考虑整数溢出问题。不过在常见的编程语言中，如Java的整数范围足够处理这些数值。

  5. 极长序列：如果连续序列非常长，接近数组大小，各种方法的性能可能会有差异。哈希集合法和哈希表法在这种情况下都能有效处理。

8. 性能优化与改进

8.1 哈希集合法的预分配优化

如果知道数组大小，可以预分配哈希集合的容量，减少哈希冲突和再哈希操作：

Set<Integer> numSet = new HashSet<>(nums.length);

8.2 减少不必要的检查

在哈希集合法中，我们可以提前检查是否需要继续查找：

int longestStreak = 0;
for (int num : numSet) {
    if (!numSet.contains(num - 1)) {
        int currentNum = num;
        int currentStreak = 1;
        
        // 提前检查可能的最大长度
        if (longestStreak > nums.length - numSet.indexOf(num)) {
            continue;  // 不可能产生更长的序列了
        }
        
        while (numSet.contains(currentNum + 1)) {
            currentNum++;
            currentStreak++;
        }
        
        longestStreak = Math.max(longestStreak, currentStreak);
    }
}

注意：上述优化在实际中可能无法实现，因为HashSet不支持indexOf操作。这只是一个思路示例。

8.3 并行计算

对于非常大的数组，可以考虑使用并行计算：

// 使用Java 8的并行流
public int longestConsecutive(int[] nums) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    
    Set<Integer> numSet = Arrays.stream(nums).boxed().collect(Collectors.toSet());
    
    return numSet.parallelStream()
            .filter(num -> !numSet.contains(num - 1))
            .mapToInt(num -> {
                int currentStreak = 1;
                while (numSet.contains(num + currentStreak)) {
                    currentStreak++;
                }
                return currentStreak;
            })
            .max()
            .orElse(0);
}

9. 完整的 Java 解决方案

以下是整合了各种优化的哈希集合法完整解决方案：

import java.util.HashSet;
import java.util.Set;

class Solution {
    public int longestConsecutive(int[] nums) {
        // 处理边界情况
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        if (nums.length == 1) {
            return 1;
        }
        
        // 将所有元素加入集合，去除重复元素
        Set<Integer> numSet = new HashSet<>(nums.length);
        for (int num : nums) {
            numSet.add(num);
        }
        
        int longestStreak = 0;
        
        // 遍历集合中的每个元素
        for (int num : numSet) {
            // 如果num-1不在集合中，num是连续序列的起点
            if (!numSet.contains(num - 1)) {
                int currentNum = num;
                int currentStreak = 1;
                
                // 查找以num开始的连续序列
                while (numSet.contains(currentNum + 1)) {
                    currentNum++;
                    currentStreak++;
                }
                
                // 更新最长连续序列长度
                longestStreak = Math.max(longestStreak, currentStreak);
                
                // 优化：如果找到的序列长度等于集合大小，不可能有更长的序列
                if (currentStreak == numSet.size()) {
                    break;
                }
            }
        }
        
        return longestStreak;
    }
}

10. 实际应用与扩展

10.1 应用场景

最长连续序列问题在以下场景中有实际应用：

  1. 数据分析：查找数据集中的连续区间
  2. 网络分析：查找连续的网络节点或IP地址
  3. 游戏开发：检测连续的游戏元素（如连珠游戏）
  4. 时间序列分析：查找连续的时间点或事件

10.2 扩展问题

  1. 最长连续递增序列：查找数组中最长的严格递增连续子序列

    // 例如：[1,3,5,4,7] 中最长连续递增序列是 [1,3,5]，长度为3
public int findLengthOfLCIS(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    
    int maxLength = 1;
    int currentLength = 1;
    
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] > nums[i - 1]) {
            currentLength++;
            maxLength = Math.max(maxLength, currentLength);
        } else {
            currentLength = 1;
        }
    }
    
    return maxLength;
}

  2. 连续序列的范围：不仅返回长度，还返回序列的起点和终点

    public int[] longestConsecutiveRange(int[] nums) {
    if (nums == null || nums.length == 0) return new int[]{0, 0, 0};
    
    Set<Integer> numSet = new HashSet<>();
    for (int num : nums) numSet.add(num);
    
    int longestStreak = 0;
    int start = 0;
    int end = 0;
    
    for (int num : numSet) {
        if (!numSet.contains(num - 1)) {
            int currentNum = num;
            int currentStreak = 1;
            
            while (numSet.contains(currentNum + 1)) {
                currentNum++;
                currentStreak++;
            }
            
            if (currentStreak > longestStreak) {
                longestStreak = currentStreak;
                start = num;
                end = currentNum;
            }
        }
    }
    
    return new int[]{longestStreak, start, end};
}

11. 常见问题与解答

11.1 为什么不能用排序法？

排序法虽然简单，但时间复杂度为O(n log n)，不满足题目要求的O(n)。当数据量大时，性能差异会很明显。

11.2 哈希集合法为什么是O(n)时间复杂度？

虽然有嵌套循环，但内层循环对每个元素最多只执行一次，所以总操作次数不超过2n，时间复杂度为O(n)。

11.3 如何处理大规模数据？

对于非常大的数据集：

  • 使用哈希集合法或并查集法，它们都是O(n)复杂度
  • 考虑并行计算
  • 如果数据无法一次加载到内存，可以分批处理

11.4 如何优化空间使用？

如果空间有限，可以：

  • 使用原地排序法，虽然时间复杂度为O(n log n)
  • 使用位图（Bitmap）表示元素是否存在，适用于元素范围有限的情况
  • 使用基本类型数组而不是对象集合

12. 测试用例

为了验证解决方案的正确性，以下是一些测试用例：

public class LongestConsecutiveSequenceTest {
    public static void main(String[] args) {
        Solution solution = new Solution();
        
        // 测试用例1：基本测试
        int[] nums1 = {100, 4, 200, 1, 3, 2};
        testAndPrint(solution, nums1, "测试用例1");
        
        // 测试用例2：更长的序列
        int[] nums2 = {0, 3, 7, 2, 5, 8, 4, 6, 0, 1};
        testAndPrint(solution, nums2, "测试用例2");
        
        // 测试用例3：空数组
        int[] nums3 = {};
        testAndPrint(solution, nums3, "测试用例3");
        
        // 测试用例4：只有一个元素
        int[] nums4 = {1};
        testAndPrint(solution, nums4, "测试用例4");
        
        // 测试用例5：重复元素
        int[] nums5 = {1, 1, 2, 2, 3, 3, 4, 4};
        testAndPrint(solution, nums5, "测试用例5");
        
        // 测试用例6：负数元素
        int[] nums6 = {-7, -6, -5, -4, -3, -2, -1, 0, 1};
        testAndPrint(solution, nums6, "测试用例6");
        
        // 测试用例7：不连续元素
        int[] nums7 = {5, 10, 15, 20, 25};
        testAndPrint(solution, nums7, "测试用例7");
    }
    
    private static void testAndPrint(Solution solution, int[] nums, String caseName) {
        int result = solution.longestConsecutive(nums);
        System.out.println(caseName + ":");
        System.out.println("输入: " + Arrays.toString(nums));
        System.out.println("输出: " + result);
        System.out.println();
    }
}

13. 总结与技巧

13.1 解题要点

  1. 理解连续序列的定义：数值上连续，而非位置上连续
  2. 时间复杂度要求：需要O(n)算法，排除排序等O(n log n)的方法
  3. 使用哈希结构：利用哈希表/集合O(1)的查找特性
  4. 避免重复计算：只从可能的起点开始查找
  5. 正确处理特殊情况：空数组、单元素数组、重复元素等

13.2 常用技巧

  1. 哈希查找：将元素放入哈希集合，实现O(1)时间查找
  2. 序列端点识别：通过检查num-1是否存在来识别序列起点
  3. 增量扩展：从起点开始，不断检查下一个数是否存在
  4. 数据去重：使用集合自动去除重复元素
  5. 路径压缩：在并查集中优化查找操作

13.3 面试技巧

在面试中遇到此类问题时：

  1. 先讨论简单解法（如排序法），说明你理解问题
  2. 分析简单解法的时间复杂度，指出不满足O(n)的要求
  3. 提出使用哈希集合的优化方法
  4. 解释为什么哈希集合法是O(n)而非O(n²)
  5. 考虑并讨论特殊情况和边界条件
  6. 如果有时间，可以提及并查集等其他解法

14. 参考资料

2023华为OD机试真题 Java 实现【最长连续子序列】
sybh的博客
10-06 118
1：简单的双指针法的应用，两指针初始都指向最左处，右指针不断右移，计算两个指针区间内的子序列之和，分三种情况，1：大于target, 则左指针右移。2：等于target，满足条件，记录一下。3：小于target，右指针继续右移。给定整数sum，求长度最长的连续子序列，使他们的和等于sum，返回此子序列的长度如果没有满足要求的序列，返回-1。1,2,3和4,2两个序列均能满足要求，所以最长的连续序列为1,2,3，因此结果为3.在读入数据量大的情况下，格式1的速度会快些。没有满足要求的子序列，返回-1。
实现最长连续递增序列算法 Java
TechPulseZ的博客
08-14 325
然后通过遍历数组，判断当前元素与前一个元素的大小关系，更新maxLength和记录最长连续递增序列的起始索引和结束索引。最长连续递增序列是指数组中连续递增的元素构成的最长子序列。在本文中，我们将讨论如何使用Java语言来实现一个高效的算法来找到给定数组中的最长连续递增序列，并提供相应的源代码。以上就是使用Java语言实现最长连续递增序列算法的方法和代码。通过这种算法，我们可以高效地找到数组中的最长连续递增序列。希望本文能对你有所帮助！最长连续递增序列的起始索引为：0。最长连续递增序列的结束索引为：3。
最长连续序列(java)
用来自己学习，复习
11-18 791
给定一个未排序的整数数组nums，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。请你设计并实现时间复杂度为O(n)的算法解决此问题。4最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。9。
力扣（LeetCode） 128.最长连续序列（java）
Cnc2014的博客
04-18 558
给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。 请你设计并实现时间复杂度为O(n) 的算法解决此问题。
Java：寻找最长连续序列
布说在见的博客
09-01 1111
通过实施上述策略，我们成功设计出一个算法以识别最长的连续数列。在这个算法中，使用HashSet来存储数组内的元素，从而实现对任意数字的迅速查找。同时，通过判断当前元素是否属于连续序列的起点，有效地计算出了最长连续序列的长度。经过严格的单元测试，代码的准确性和稳定性得到了验证。在处理大规模数据集时，本方法展现了卓越的性能，显示出高效性和实用性的双重优势。
LeetCode（128）：最长连续序列 Longest Consecutive Sequence（Java）
NJU_ChopinXBP的博客
08-10 520
2019.8.10 #程序员笔试必备# LeetCode 从零单刷个人笔记整理（持续更新） 这道题要求在线性的时间复杂度里，从乱序的数组中找出最长的连续序列。由于常规排序算法的复杂度都要o（nlogn），因此排序的路子基本不能用了。只能考虑空间换时间，能实现o（n）的方法一般可以考虑动态规划+桶/哈希表。 找出最大最小元素，第一次遍历利用桶排序的方法将每一个遍历到的元素放进桶中，第二次遍历找出连...
python-leetcode面试题解之第128题最长连续序列-题解.zip
05-07
LeetCode的第128题，名为"Longest Consecutive Sequence"，要求找到给定无序整数数组中，最长的连续整数序列的长度。例如，对于输入数组 [100, 4, 200, 1, 3, 2]，最长连续序列是 [1, 2, 3, 4]，其长度为4。 首先，...
LeetCode 热题100题解（Java版本）
最新发布
编程小鹏的博客
04-21 1246
使用HashMap，遍历数组，判断当前元素的“补数”是否存在，如果存在直接返回结果，否则在Map中记录当前元素及其下标。 2、字母异位词分组 3、最长连续序列 先使用HashSet去重，如果对当前元素x存在x-1，那么肯定从x-1开始算序列长度会更长，所以当x-1存在时，就跳过x，去计算x-1。 二、双指针 1、移动零 不用双指针，先将非0数重新放入nums，最后放入0。 2、盛最多水的容器 3、三数之和 排序+双指针 4、接雨水 三、滑动窗口 1、无重复字符的最长子串 如果
【LeetCode最详尽解答】128_最长连续序列 Longest-Consecutive-Sequence
weixin_53765658的博客
06-13 1713
欢迎收藏Star我的Machine Learning Blog:https://github.com/purepisces/Wenqing-Machine_Learning_Blog。如果收藏star, 有问题可以随时与我交流, 谢谢大家！首先，我们需要找到每个递增序列的起始位置，并且舍弃重复的值。所以先使用 将 转换为一个集合。集合中的每个值可能是起始位置，也可能只是序列的一部分。我们只需要找到起始值。考虑列表 。如果不只找起始点，它会计算从 ，， 等开始的序列，导致 (O(n2)(O(n^2)(O(
js-leetcode题解之128-longest-consecutive-sequence.js
11-04
其中，问题编号128的“最长连续序列”(Longest Consecutive Sequence)是其中的一个经典问题。该问题要求编写一个函数，找出数组中未排序的最长连续元素序列的长度。针对这一问题，使用JavaScript编写一个高效的解法...
java数据结构与算法刷题-----LeetCode128. 最长连续序列
殷志鹏的博客
02-13 694
【代码】java数据结构与算法刷题-----LeetCode128. 最长连续序列。
leetcode hot100【LeetCode 128. 最长连续序列】java实现
DataCrafter的博客
10-26 345
LeetCode 128. 最长连续序列
03、最长连续数列：给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度
Elastic开源社区
11-03 1004
给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
最长连续序列(java)_128
weixin_46580067的博客
11-01 250
最长序列
最长连续序列（力扣热题HOT100 之 力扣128）Java
m0_49499183的博客
04-13 1064
目录 一、题目描述 二、思路讲解 三、Java代码实现 四、思路优化 五、优化代码 一、题目描述 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。 示例 1： 输入：nums = [100,4,200,1,3,2] 输出：4 解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。 示例 2： 输入：nums = [0,3,7,2,5,8,4,6,...
128.最长连续序列（java）
m0_37605197的博客
04-07 488
题目描述 给定一个未排序的整数数组，找出最长连续序列的长度。 要求算法的时间复杂度为 O(n)。 示例: 输入: [100, 4, 200, 1, 3, 2] 输出: 4 解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。 方法一：哈希表 class Solution { public int longestConsecutive(int[] nums) { ...
算法Java—B组实战篇之求数组中最长连续子序列
Matthew_mcc的博客
03-27 399
给定一段数组，求出该数组中最长连续增长的子序列。 解题思路：这题对索引的理解要比较好，考察索引。 /** * @author Matthew * @create 2021-03-27 9:30 */ public class case05_LianXuZuiChangZiXuLie { public static void main(String[] args) throws IOException { //从键盘上先输入数组总长度，回车之后再输入该数组用空格分开，结束回车
329. 矩阵中的最长递增路径c_实例讲解：最长公共子序列问题
weixin_39598472的博客
11-23 304
最长公共子序列（Longest-Common-Subsequence）是寻找两个字符串中共同的最长子序列。对于一个数列S，如果分别是多个或者多个已经数列的子序列，且它是所有符合此条件序列中最长的，则序列S则为被称为最长公共子序列。相比最长公共子序列，还有一个类似的最长公共子串（Longest-Common-Substring），两者比较相似，不同点在于其中最长公共子串针对的是连续的子序列，例如：a...
LeetCode-128.最长连续序列（相关话题：并查集）
weixin_38823568的博客
12-22 807
给定一个未排序的整数数组，找出最长连续序列的长度。 要求算法的时间复杂度为 O(n)。 示例: 输入: [100, 4, 200, 1, 3, 2] 输出: 4 解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。 并查集：初始时，让每个元素都作为一个含有单元素的集合存在 然后按照一定顺序处理每个元素，将同一组的元素（此题中即为相邻数字）所在的集合合并 此题中，用M...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

全栈凯哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值