最长连续序列

题目介绍

力扣128题：https://leetcode-cn.com/problems/longest-consecutive-sequence/

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
进阶：你可以设计并实现时间复杂度为 O(n) 的解决方案吗？

分析

要寻找连续序列，关键在于找到当前数的“下一个数”（或者叫“后继”）。如果有后继，就在数组中继续找，每找到一个后继，当前序列长度就加1；直到找不到时，就得到了以当前数开始的、最长的连续序列长度。

方法一：暴力法

最简单的实现，就是遍历所有数据，对每一数据都找从它开始的最长连续序列。寻找连续序列，就是要不停寻找后继。而判断后继是否存在，又要在数组中进行遍历寻找。
代码演示如下：

// 方法一：暴力法
public int longestConsecutiveSequence1(int[] nums){
    // 定义一个变量，保存当前最长连续序列的长度
    int maxLength = 0;

    // 遍历数组，以每个元素作为起始点，寻找连续序列
    for (int i = 0; i < nums.length; i++){
        // 保存当前元素作为起始点
        int currNum = nums[i];
        // 保存当前连续序列长度
        int currLength = 1;

        // 寻找后续数字，组成连续序列
        while ( contains(nums, currNum + 1) ){
            currLength ++;
            currNum ++;
        }

        // 判断当前连续序列长度是否为最大
        maxLength = currLength > maxLength ? currLength : maxLength;
    }

    return maxLength;
}

    // 定义一个方法，用于在数组中寻找某个元素
 public boolean contains(int[] nums, int x){
     for (int num: nums){
         if (num == x)
             return true;
     }
     return false;
 }

复杂度分析

• 时间复杂度：O(N^{3)。我们定义了外层循环遍历数组，内层循环不停寻找后继；另外，在内层循环中每次要判断后继是否存在，还需要遍历数组查找。所以总计是O(N}3)。
• 空间复杂度：O(1)。过程中只用到了一些辅助的临时变量。

方法二：哈希表改进

用哈希表（Hash Set）来保存数组中的元素，可以快速判断元素是否存在。这样contains可以优化为常数时间复杂度。

代码实现如下：

// 方法二：利用哈希表改进
public int longestConsecutiveSequence2(int[] nums){
    // 定义一个变量，保存当前最长连续序列的长度
    int maxLength = 0;

    // 定义一个HashSet，保存所有出现的数值
    HashSet<Integer> hashSet = new HashSet<>();

    // 1. 遍历所有元素，保存到HashSet
    for (int num: nums){
        hashSet.add(num);
    }

    // 2. 遍历数组，以每个元素作为起始点，寻找连续序列
    for (int i = 0; i < nums.length; i++){
        // 保存当前元素作为起始点
        int currNum = nums[i];
        // 保存当前连续序列长度
        int currLength = 1;

        // 寻找后续数字，组成连续序列
        while ( hashSet.contains(currNum + 1) ){
            currLength ++;
            currNum ++;
        }

        // 判断当前连续序列长度是否为最大
        maxLength = currLength > maxLength ? currLength : maxLength;
    }

    return maxLength;
}

复杂度分析

• 时间复杂度：O(N^2)。 将数组元素保存入HashSet需要。后面由于简化了内层循环中判断后继的过程，只耗费O(1)时间，所以最终是内外两重循环，最坏情况下时间复杂度为O(N^2)。
• 空间复杂度：O(N)。我们用到了一个Hash Set来保存数组元素，排除部分重复数据，这仍然需要耗费O(N)的内存空间。

方法三：哈希表进一步优化

仔细分析上面的算法过程，我们会发现其中执行了很多不必要的枚举。
例如，我们已经寻找过x开始的连续序列，已知有一个 x,x+1,x+2,⋯,x+y 的连续序列。现在要继续寻找x+1开始的连续序列，算法会重新寻找它的后继x+2，而这个过程我们已经做过了。
并且，我们可以确定，这种情况得到的结果（连续序列的长度），肯定不会优于以x 为起点的答案。因此这部分处理完全没有必要，我们在外层循环的时候碰到这种情况，直接跳过即可。

代码如下：

// 方法三：进一步改进
public int longestConsecutiveSequence(int[] nums){
     // 定义一个变量，保存当前最长连续序列的长度
     int maxLength = 0;

     // 定义一个HashSet，保存所有出现的数值
     HashSet<Integer> hashSet = new HashSet<>();

     // 1. 遍历所有元素，保存到HashSet
     for (int num: nums){
         hashSet.add(num);
     }

     // 2. 遍历数组，以每个元素作为起始点，寻找连续序列
     for (int i = 0; i < nums.length; i++){
         // 保存当前元素作为起始点
         int currNum = nums[i];
         // 保存当前连续序列长度
         int currLength = 1;

         // 判断：只有当前元素的前驱不存在的情况下，才去进行寻找连续序列的操作
         if (!hashSet.contains(currNum - 1)) {
             // 寻找后续数字，组成连续序列
             while ( hashSet.contains(currNum + 1) ){
                 currLength ++;
                 currNum ++;
             }

             // 判断当前连续序列长度是否为最大
             maxLength = currLength > maxLength ? currLength : maxLength;
         }
     }

     return maxLength;
 }

复杂度分析

• 时间复杂度：O(N)。外层循环需要 O(n)的时间复杂度，只有当一个数是连续序列的第一个数的情况下才会进入内层循环，然后在内层循环中匹配连续序列中的数，因此数组中的每个数只会进入内层循环一次。
• 空间复杂度：O(N)。哈希表保存数组中所有数据需要O(N)的内存空间。