算法_ 最长连续序列(js)

力扣 128. 最长连续序列
给定一个未排序的整数数组，找出最长连续序列的长度。
要求算法的时间复杂度为 O(n)。。

示例一

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

解法一 三重循环暴力求解，时间复杂度 O(n^3), 超出时间限制，求解失败

    const longestConsecutive = (nums) => {
                if(nums == null || nums.length == 0) return 0
                var longest = 0
                 const findData = (data) => {
                     for (let j = 0; j < nums.length; j++) {
                         if(nums[j] == data){
                             return true
                         }
                     }
                     return false
                 }
                for (let i = 0; i < nums.length; i++) {
                    var current = 0, currentE = nums[i]
                    while(findData(currentE)){
                        current += 1
                        currentE += 1
                    }
                    longest = Math.max(current, longest)
                }
                
                return longest
            }

解法二 使用Set结构, 解法一的优化版, 时间复杂度O(n)

            const longestConsecutive_3 = (nums) => {
                if(nums == null || nums.length == 0) return 0
                var set = new Set()
                for (let i = 0; i < nums.length; i++) {
                    set.add(nums[i])
                }
                var longest = 1, current = 1, currentValue;
                for (let j = 0; j < nums.length; j++) {
                    currentValue = nums[j]
                    if(!(set.has(currentValue - 1))){ 
                        current = 1
                        while(set.has(currentValue + 1)){
                            current += 1
                            currentValue = currentValue + 1
                        }
                        longest = Math.max(current, longest)
                    }
                }
                return longest
            }

解法三 排序求解, 时间复杂度为O(n)

const longestConsecutive_2 = (nums) => {
                if(nums == null || nums.length == 0) return 0
                var new_nums = nums.sort((a, b) => a - b)
                var longest = 1, current = 1
                for (let i = 0; i < new_nums.length; i++) {
                    if(new_nums[i] != new_nums[i + 1]){
                        if(new_nums[i] == new_nums[i + 1] - 1){
                            current += 1
                        }else{
                            longest = Math.max(current, longest)
                            current = 1
                        }
                    }
                }
                return longest
            }

本题解法已经上传，立即跳转

本题来源于力扣，更多解题思路请跳到本题