Longest Consecutive Sequence

In this tutorial, we will write the Python program to find the longest consecutive sequence. It is a commonly asked programming question in the technical interview.

A Longest Consecutive Sequence problem typically involves finding the longest sequence of consecutive numbers within an array or list of integers. The idea is to determine the length of the longest consecutive sequence of numbers without gaps.

Example 1:

Input: nums = [100, 4, 200, 1, 3, 2]
Output: 4
Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
Example 2:
Input: nums = [0,3,7,2,5,8,4,6,0,1]
Output: 9

Solutions

We will solve this problem using the various approach -

Naïve Approach

The approach involves sorting the array, removing duplicates, and then iterating through it. During the iteration, we maintain two counters: `count` and `max`, both initially set to zero. Within the loop, if the current element is not one greater than the previous one, we reset `count` to one; otherwise, we increment it. At each step, we update `max` with the maximum value between `count` and the current `max`.

Let's understand the following example -

Example -

def longestConsecutive(nums):
    if not nums:
        return 0

    nums = list(set(nums))  # Remove duplicates for faster processing
    nums.sort()  # Sort the list for easier consecutive sequence checking

    count = 1  # Initialize the count of the current consecutive sequence
    max_count = 1  # Initialize the maximum count of consecutive elements

    for i in range(1, len(nums)):
        if nums[i] != nums[i - 1] + 1:
            count = 1
        else:
            count += 1
        max_count = max(max_count, count)

    return max_count

# Example usage:
input_arr1 = [1, 9, 3, 10, 4, 20, 2]
output1 = longestConsecutive(input_arr1)
print("The length of the longest consecutive subsequence in input_arr1 is:", output1)

input_arr2 = [36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42]
output2 = longestConsecutive(input_arr2)
print("The length of the longest consecutive subsequence in input_arr2 is:", output2)

Output:

The length of the longest consecutive subsequence in input_arr1 is: 4
The length of the longest consecutive subsequence in input_arr2 is: 5

Explanation -

We sort the list of numbers to make it easier to identify consecutive elements.

We initialize count to 1 to keep track of the current consecutive sequence length and max_count to 1 to store the maximum consecutive sequence length.

We iterate through the sorted list of numbers and check if the current element is not equal to the previous element plus one. If they are not consecutive, we reset count to 1. Otherwise, we increment count. We update max_count with the maximum value between its current value and count.

Finally, we return max_count, which represents the length of the longest consecutive subsequence in the input list.

Time Complexity - O(n log n), where n is the number of elements in the input list.

Auxiliary space: O(N). Extra space is needed for storing distinct elements.

Longest Consecutive Subsequence using sorting without removing duplicate elements

The approach consists of first sorting the array. Subsequently, we count the consecutive elements within the sorted array, excluding any repeated elements. Let's understand the following example -

Example -

def longestConsecutive(nums):
    if not nums:
        return 0

    nums.sort()  # Sort the list of numbers

    longest_sequence = 1  # Initialize the length of the longest sequence
    current_sequence = 1  # Initialize the length of the current sequence

    for i in range(1, len(nums)):
        if nums[i] == nums[i - 1] + 1:
            current_sequence += 1
        elif nums[i] != nums[i - 1]:
            current_sequence = 1
        longest_sequence = max(longest_sequence, current_sequence)

    return longest_sequence

# Example usage:
input_arr1 = [1, 9, 3, 10, 4, 20, 2]
output1 = longestConsecutive(input_arr1)
print("The length of the longest consecutive subsequence in input_arr1 is:", output1)
input_arr2 = [36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42]
output2 = longestConsecutive(input_arr2)
print("The length of the longest consecutive subsequence in input_arr2 is:", output2)

Output:

The length of the longest consecutive subsequence in input_arr1 is: 4
The length of the longest consecutive subsequence in input_arr2 is: 5

Explanation -

The code starts by sorting the input list of numbers to make it easier to identify consecutive elements. Two variables, `longest_sequence` and `current_sequence`, are initialized to 1. These variables keep track of the length of the longest consecutive subsequence found so far and the length of the current consecutive subsequence being examined, respectively.

Then iterates through the sorted list and checks for consecutive elements. If the current element is exactly one greater than the previous element, it increments the `current_sequence` because it indicates a consecutive element. If the current element is different from the previous one, implying a non-duplicate, the `current_sequence` is reset to 1 to start counting a new potential consecutive subsequence.

After each iteration, the code updates `longest_sequence` with the maximum value between its current value and `current_sequence`. This ensures that it keeps track of the longest consecutive subsequence found so far.

Finally, the function returns the value of `longest_sequence`, representing the length of the longest consecutive subsequence in the input list.

Longest Consecutive Subsequence using Hashing

To find the longest consecutive subsequence using hashing, you can follow a more efficient approach that doesn't involve sorting. Here's a Python program using hashing to achieve this.

Example -

def longestConsecutive(nums):
    if not nums:
        return 0
    
    num_set = set(nums)  # Convert the list into a set for faster lookup
    longest_sequence = 0
    
    for num in num_set:
        if num - 1 not in num_set:
            current_num = num
            current_sequence = 1
            
            while current_num + 1 in num_set:
                current_num += 1
                current_sequence += 1
            
            longest_sequence = max(longest_sequence, current_sequence)
    
    return longest_sequence

# Example usage:
input_arr1 = [1, 9, 3, 10, 4, 20, 2]
output1 = longestConsecutive(input_arr1)
print("The length of the longest consecutive subsequence in input_arr1 is:", output1)

input_arr2 = [36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42]
output2 = longestConsecutive(input_arr2)
print("The length of the longest consecutive subsequence in input_arr2 is:", output2)

Output:

The length of the longest consecutive subsequence in input_arr1 is: 4
The length of the longest consecutive subsequence in input_arr2 is: 5

Explanation -

We start by converting the input list nums into a set called num_set for faster lookup.

We initialize longest_sequence to 0, which will store the length of the longest consecutive subsequence.

We iterate through the elements in num_set and for each element, we check if num - 1 is not in num_set. If it's not present, it means num is the start of a potential consecutive sequence.

Inside the loop, we initialize current_num with the current element num and current_sequence to 1. Then, we use a while loop to check for consecutive numbers in the positive direction (i.e., current_num + 1) and increment current_sequence accordingly.

We update longest_sequence with the maximum value between its current value and current_sequence. This ensures that we keep track of the longest consecutive subsequence found so far.

Finally, we return the value of longest_sequence, which represents the length of the longest consecutive subsequence in the input list nums.

Next TopicPython Inspect Module

← prev next →