最长连续序列

题目介绍

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

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

最长连续序列_第1张图片

分析

要寻找连续序列,关键在于找到当前数的“下一个数”(或者叫“后继”)。如果有后继,就在数组中继续找,每找到一个后继,当前序列长度就加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(N3)。我们定义了外层循环遍历数组,内层循环不停寻找后继;另外,在内层循环中每次要判断后继是否存在,还需要遍历数组查找。所以总计是O(N3)。
  • 空间复杂度: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)的内存空间。

你可能感兴趣的:(力扣刷题,数据结构,java)