leetcode-最长连续序列

最初的代码 执行超时

class Solution(object):
    def longestConsecutive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # 看到题需要先排序 再进行计算长度
        nums_ = sorted(nums)
        # 遍历i、i+1是否连续 记录长度k 取最大值 
        i = 0
        k = 1
        # 有顺序的 
        while i+1 < len(nums_):
            if nums_[i+1] - nums_[i] == 1:
                i += 1
                k += 1
        return k

题解一：

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        longest_streak = 0
        num_set = set(nums)

        for num in num_set:
            if num - 1 not in num_set:
                current_num = num
                current_streak = 1

                while current_num + 1 in num_set:
                    current_num += 1
                    current_streak += 1

                longest_streak = max(longest_streak, current_streak)

        return longest_streak

作者：力扣官方题解

题解二：

class Solution(object):

    def longestConsecutive(self, nums):

        """

        :type nums: List[int]

        :rtype: int

        """

        table = set(nums)

        maxlength = 0

        for num in nums:

            # 这样pass会超时

            # if (num-1) in table: pass

            # if (num+maxlength) not in table: pass



            if num-1 not in table and num+maxlength in table:

                thislength = 1

                while (num+1) in table:

                    thislength += 1

                    num += 1

                if thislength > maxlength:

                    maxlength = thislength

        return maxlength

作者：doubleZ

题解三：

class Solution(object):
    def longestConsecutive(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        [1,2,3,4]
        """
        hash_dict = dict()

        max_length = 0

        for num in nums:
            if num not in hash_dict:
                # 取出其左右相邻数已有的连续区间长度left和right
                left = hash_dict.get(num - 1, 0)
                right = hash_dict.get(num + 1, 0)

                # 计算当前数的区间长度为：cur_length = left + right + 1
                cur_length = 1 + left + right

                # 根据 cur_length 更新最大长度 max_length 的值
                if cur_length > max_length:
                    max_length = cur_length
                
                
                hash_dict[num] = cur_length
                # 更新最左端点的值，如果left=n存在，那么证明当前数的前n个都存在哈希表中
                hash_dict[num - left] = cur_length
                # 更新最右端点的值，如果right=n存在，那么证明当前数的后n个都存在哈希表中
                hash_dict[num + right] = cur_length

        return max_length
                

看看进来时前后能排上队连接不，左边连接左边，右边连接右边

左边长+1+右边长

首先，定义一个哈希表（用于判断某个数是否存在哈希表中）

然后遍历数组

如果当前数num存在哈希表，那么跳过

如果当前数num不存在哈希表中，那么查找num-1和num+1这两个数是不是在哈希表中

比如 num是5

1234 678都在哈希表中

遍历数组的时候，遇到1234678都会掠过

此时哈希表中，1的位置和4存的值都是4（证明1或者4所在的连续长度是4）

同理 6和8存的值都是3

那么此时5进来之后，看看4和6在不在哈希表内，如果在的话，一定是端点，一定能获取到值

所以5进来之后，发现左边有4个连续的，右边有3个连续的，加上自己一个，那么组成一个大连续的

4+1+3 = 8

---------以上内容好理解--------到下面为啥更新端点的位置一下没看出来-------

所以要更新当前最长连续串的端点，也就是1的位置（5-4），8的位置（5+3），更新长度为8

只需要端点存值就行，因为端点中的值在遍历的时候如果在哈希表中就会略过
1234678

num=1
left：0
right：0
cur_length=1
max_length = 1
hash[1]=1
hash[1-0]=1
hash[1+0]=1

num=2
left=1
right=0
cur_length=2
max_length = 2
hash[2]=2
hash[2-1]=2
hash[2+0]=2

num=3
left=2
right=0
cur_length=3
max_length = 3
hash[3]=3
hash[3-2]=3
hash[3+0]=3

num=4
left=3
right=0
cur_length=4
max_length = 4
hash[4]=4
hash[4-3]=4
hash[4+0]=4

num=6
left=0
right=0
cur_length=1
max_length = 4
hash[6]=1
hash[6-0]=1
hash[6+0]=1

num=7
left=1
right=0
cur_length=2
max_length = 4
hash[7]=2
hash[7-1]=2
hash[7+0]=2

num=8
left=2
right=0
cur_length=3
max_length = 4
hash[8]=3
hash[8-2]=3
hash[8+0]=3

这时候如果再加进来5
num=5
left=4
right=3
cur_length=8
max_length = 5
hash[5]=8
hash[5-4]=8
hash[5+3]=8

----------------------------为什么呢？------------------------
这是因为整个子序列 [num-left, num+right] 中的元素都已经被访问过了所有的值都已经存储到了map里面，
那么如果其他数字想要通过这个判断
if num not in hash_dict ，
这个数字只可能在这个子序列的左边或者右边，
我们还是以左边为例，当我们放入第num-left-1个数字的时候就需要知道
我们的右边第num-left的子序列长度，而通过之前的计算
hash_dict[num - left] = cur_length
我们可以知道第num-left为开头的最大子序列长度为cur_length,
可以看出左端点（num-left）的值只有其左边的数字用的上，
那么他自己自然只需要存右边的子序列长度就可以了，右边同理。

------凌乱的是left、right和num什么关系-----------------------------------

left = dict.get(num-1,0) 获取左边小一个数节点存储的序列长度，没有为0
right = dict.get(num+1,0) 获取右边大一个数节点存储的序列长度，没有为0

那么 num - left 就是 左边节点的数字，num + right就是右边的节点数字：

---------------------------------还是不太理解---------------------------------

如果这个时候9又进来，那么它获取到8的位置有8，10的位置有0

更新连续子串长度（8+1+0）

所以更新左端点1（9-8）的值为9，右端点9（9+0）的值为9