Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Longest Consecutive Subsequence

  • Difficulty Level : Medium
  • Last Updated : 13 Jul, 2021

Given an array of integers, find the length of the longest sub-sequence such that elements in the subsequence are consecutive integers, the consecutive numbers can be in any order. 

Examples:  

Input: arr[] = {1, 9, 3, 10, 4, 20, 2}
Output: 4
Explanation: 
The subsequence 1, 3, 4, 2 is the longest 
subsequence of consecutive elements

Input: arr[] = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}
Output: 5
Explanation: 
The subsequence 36, 35, 33, 34, 32 is the longest 
subsequence of consecutive elements.

Naive Approach: The idea is to first sort the array and find the longest subarray with consecutive elements. 
After sorting the array and removing the multiple occurrences of elements, run a loop and keep a count and max (both initially zero). Run a loop from start to end and if the current element is not equal to the previous (element+1) then set the count to 1 else increase the count. Update max with a maximum of count and max. 

C++

// C++ program to find longest
// contiguous subsequence
#include <bits/stdc++.h>
using namespace std;

// Returns length of the longest
// contiguous subsequence
int findLongestConseqSubseq(int arr[], int n)
{
    int ans = 0, count = 0;

    // sort the array
    sort(arr, arr + n);

    vector<int> v;
    v.push_back(arr[0]);

    //insert repeated elements only once in the vector
    for (int i = 1; i < n; i++) 
    {
        if (arr[i] != arr[i - 1])
            v.push_back(arr[i]);
    }
    // find the maximum length
    // by traversing the array
    for (int i = 0; i < v.size(); i++) 
    {
        
        // Check if the current element is equal
        // to previous element +1
        if (i > 0 && v[i] == v[i - 1] + 1)
            count++;
        // reset the count
        else
            count = 1;

        // update the maximum
        ans = max(ans, count);
    }
    return ans;
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 3 };
    int n = sizeof arr / sizeof arr[0];
    cout << "Length of the Longest contiguous subsequence "
            "is "
         << findLongestConseqSubseq(arr, n);
    return 0;
}

Java

// Java program to find longest
// contiguous subsequence
import java.io.*;
import java.util.*;

class GFG 
{

    static int findLongestConseqSubseq(int arr[], 
                                           int n)
    {

        // Sort the array
        Arrays.sort(arr);

        int ans = 0, count = 0;
      
        ArrayList<Integer> v = new ArrayList<Integer>();
        v.add(10);
      
        // Insert repeated elements 
        // only once in the vector
        for (int i = 1; i < n; i++) 
        {
            if (arr[i] != arr[i - 1])
                v.add(arr[i]);
        }
   

        // Find the maximum length
        // by traversing the array
        for (int i = 0; i < v.size(); i++) 
        {

            // Check if the current element is
            // equal to previous element +1
            if (i > 0 &&v.get(i) == v.get(i - 1) + 1)
                count++;
            else
                count = 1;

            // Update the maximum
            ans = Math.max(ans, count);
        }
        return ans;
    }

    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
        int n = arr.length;

        System.out.println(
            "Length of the Longest "
            + "contiguous subsequence is "
            + findLongestConseqSubseq(arr, n));
    }
}

// This code is contributed by parascoding

Python3

# Python3 program to find longest 
# contiguous subsequence 

# Returns length of the longest 
# contiguous subsequence 
def findLongestConseqSubseq(arr, n):
    
    ans = 0
    count = 0

    # Sort the array 
    arr.sort()

    v = []

    v.append(arr[0])

    # Insert repeated elements only 
    # once in the vector 
    for i in range(1, n):
        if (arr[i] != arr[i - 1]):
            v.append(arr[i])

    # Find the maximum length 
    # by traversing the array 
    for i in range(len(v)):

        # Check if the current element is
        # equal to previous element +1 
        if (i > 0 and v[i] == v[i - 1] + 1):
            count += 1
            
        # Reset the count 
        else:
            count = 1
            
        # Update the maximum 
        ans = max(ans, count)
        
    return ans

# Driver code 
arr = [ 1, 2, 2, 3 ]
n = len(arr)

print("Length of the Longest contiguous subsequence is",
       findLongestConseqSubseq(arr, n))

# This code is contributed by avanitrachhadiya2155

C#

// C# program to find longest
// contiguous subsequence
using System;
using System.Collections.Generic; 

class GFG{
    
static int findLongestConseqSubseq(int[] arr,
                                   int n)
{
    
    // Sort the array
    Array.Sort(arr);

    int ans = 0, count = 0;
   
    List<int> v = new List<int>(); 
    v.Add(10);
   
    // Insert repeated elements 
    // only once in the vector
    for(int i = 1; i < n; i++) 
    {
        if (arr[i] != arr[i - 1])
            v.Add(arr[i]);
    }
    
    // Find the maximum length
    // by traversing the array
    for(int i = 0; i < v.Count; i++) 
    {
        
        // Check if the current element is
        // equal to previous element +1
        if (i > 0 && v[i] == v[i - 1] + 1)
            count++;
        else
            count = 1;

        // Update the maximum
        ans = Math.Max(ans, count);
    }
    return ans;
}

// Driver code 
static void Main()
{
    int[] arr = { 1, 9, 3, 10, 4, 20, 2 };
    int n = arr.Length;

    Console.WriteLine("Length of the Longest " + 
                      "contiguous subsequence is " +
                      findLongestConseqSubseq(arr, n));
}
}

// This code is contributed by divyeshrabadiya07

Javascript

    <script>
    
        // JavaScript program to find longest
        // contiguous subsequence

        // Returns length of the longest
        // contiguous subsequence
        function findLongestConseqSubseq(arr, n) {
            let ans = 0, count = 0;

            // sort the array
            arr.sort(function (a, b) { return a - b; })

            var v = [];
            v.push(arr[0]);

            //insert repeated elements only once in the vector
            for (let i = 1; i < n; i++) {
                if (arr[i] != arr[i - 1])
                    v.push(arr[i]);
            }
            // find the maximum length
            // by traversing the array
            for (let i = 0; i < v.length; i++) {

                // Check if the current element is equal
                // to previous element +1
                if (i > 0 && v[i] == v[i - 1] + 1)
                    count++;
                // reset the count
                else
                    count = 1;

                // update the maximum
                ans = Math.max(ans, count);
            }
            return ans;
        }

        // Driver code

        let arr = [1, 2, 2, 3];
        let n = arr.length;
        document.write(
        "Length of the Longest contiguous subsequence is "
        +findLongestConseqSubseq(arr, n)
        );

     // This code is contributed by Potta Lokesh
  
    </script>
Output
Length of the Longest contiguous subsequence is 3

Complexity Analysis: 

  • Time complexity: O(nLogn). 
    Time to sort the array is O(nlogn).
  • Auxiliary space : O(1). 
    As no extra space is needed.

Thanks to Hao.W for suggesting the above solution.

Efficient solution: 
This problem can be solved in O(n) time using an Efficient Solution. The idea is to use Hashing. We first insert all elements in a Set. Then check all the possible starts of consecutive subsequences.

 Algorithm: 

  1. Create an empty hash.
  2. Insert all array elements to hash.
  3. Do following for every element arr[i]
  4. Check if this element is the starting point of a subsequence. To check this, simply look for arr[i] – 1 in the hash, if not found, then this is the first element a subsequence.
  5. If this element is the first element, then count the number of elements in the consecutive starting with this element. Iterate from arr[i] + 1 till the last element that can be found.
  6. If the count is more than the previous longest subsequence found, then update this.

Below image is a dry run of the above approach: 

Below is the implementation of the above approach: 

C++

// C++ program to find longest
// contiguous subsequence
#include <bits/stdc++.h>
using namespace std;

// Returns length of the longest
// contiguous subsequence
int findLongestConseqSubseq(int arr[], int n)
{
    unordered_set<int> S;
    int ans = 0;

    // Hash all the array elements
    for (int i = 0; i < n; i++)
        S.insert(arr[i]);

    // check each possible sequence from
    // the start then update optimal length
    for (int i = 0; i < n; i++)
    {
        // if current element is the starting
        // element of a sequence
        if (S.find(arr[i] - 1) == S.end())
        {
            // Then check for next elements
            // in the sequence
            int j = arr[i];
            while (S.find(j) != S.end())
                j++;

            // update  optimal length if
            // this length is more
            ans = max(ans, j - arr[i]);
        }
    }
    return ans;
}

// Driver code
int main()
{
    int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
    int n = sizeof arr / sizeof arr[0];
    cout << "Length of the Longest contiguous subsequence "
            "is "
         << findLongestConseqSubseq(arr, n);
    return 0;
}

Java

// Java program to find longest
// consecutive subsequence
import java.io.*;
import java.util.*;

class ArrayElements {
    // Returns length of the longest
    // consecutive subsequence
    static int findLongestConseqSubseq(int arr[], int n)
    {
        HashSet<Integer> S = new HashSet<Integer>();
        int ans = 0;

        // Hash all the array elements
        for (int i = 0; i < n; ++i)
            S.add(arr[i]);

        // check each possible sequence from the start
        // then update optimal length
        for (int i = 0; i < n; ++i) 
        {
            // if current element is the starting
            // element of a sequence
            if (!S.contains(arr[i] - 1)) 
            {
                // Then check for next elements
                // in the sequence
                int j = arr[i];
                while (S.contains(j))
                    j++;

                // update  optimal length if this
                // length is more
                if (ans < j - arr[i])
                    ans = j - arr[i];
            }
        }
        return ans;
    }

    // Driver Code
    public static void main(String args[])
    {
        int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
        int n = arr.length;
        System.out.println(
            "Length of the Longest consecutive subsequence is "
            + findLongestConseqSubseq(arr, n));
    }
}
// This code is contributed by Aakash Hasija

Python

# Python program to find longest contiguous subsequence

from sets import Set


def findLongestConseqSubseq(arr, n):

    s = Set()
    ans = 0

    # Hash all the array elements
    for ele in arr:
        s.add(ele)

    # check each possible sequence from the start
    # then update optimal length
    for i in range(n):

         # if current element is the starting
        # element of a sequence
        if (arr[i]-1) not in s:

            # Then check for next elements in the
            # sequence
            j = arr[i]
            while(j in s):
                j += 1

            # update  optimal length if this length
            # is more
            ans = max(ans, j-arr[i])
    return ans


# Driver code
if __name__ == '__main__':
    n = 7
    arr = [1, 9, 3, 10, 4, 20, 2]
    print "Length of the Longest contiguous subsequence is ",
    print findLongestConseqSubseq(arr, n)

# Contributed by: Harshit Sidhwa

C#

using System;
using System.Collections.Generic;

// C# program to find longest consecutive subsequence

public class ArrayElements {
    // Returns length of the 
    // longest consecutive subsequence
    public static int findLongestConseqSubseq(int[] arr,
                                              int n)
    {
        HashSet<int> S = new HashSet<int>();
        int ans = 0;

        // Hash all the array elements
        for (int i = 0; i < n; ++i) {
            S.Add(arr[i]);
        }

        // check each possible sequence from the start
        // then update optimal length
        for (int i = 0; i < n; ++i) 
        {
            // if current element is the starting
            // element of a sequence
            if (!S.Contains(arr[i] - 1)) 
            {
                // Then check for next elements in the
                // sequence
                int j = arr[i];
                while (S.Contains(j)) 
                {
                    j++;
                }

                // update  optimal length if this length
                // is more
                if (ans < j - arr[i]) 
                {
                    ans = j - arr[i];
                }
            }
        }
        return ans;
    }

    // Driver code
    public static void Main(string[] args)
    {
        int[] arr = new int[] { 1, 9, 3, 10, 4, 20, 2 };
        int n = arr.Length;
        Console.WriteLine(
            "Length of the Longest consecutive subsequence is "
            + findLongestConseqSubseq(arr, n));
    }
}

// This code is contributed by Shrikant13

Javascript

<script>
// Javascript program to find longest
// contiguous subsequence


// Returns length of the longest
// contiguous subsequence
function findLongestConseqSubseq(arr, n) {
    let S = new Set();
    let ans = 0;

    // Hash all the array elements
    for (let i = 0; i < n; i++)
        S.add(arr[i]);

    // check each possible sequence from
    // the start then update optimal length
    for (let i = 0; i < n; i++)
    {
    
        // if current element is the starting
        // element of a sequence
        if (!S.has(arr[i] - 1))
        {
        
            // Then check for next elements
            // in the sequence
            let j = arr[i];
            while (S.has(j))
                j++;

            // update optimal length if
            // this length is more
            ans = Math.max(ans, j - arr[i]);
        }
    }
    return ans;
}

// Driver code
let arr = [1, 9, 3, 10, 4, 20, 2];
let n = arr.length;
document.write("Length of the Longest contiguous subsequence is "
    + findLongestConseqSubseq(arr, n));
    
    // This code is contributed by gfgking.
</script>
Output
Length of the Longest contiguous subsequence is 4

 Complexity Analysis: 

  • Time complexity: O(n). 
    Only one traversal is needed and the time complexity is O(n) under the assumption that hash insert and search take O(1) time.
  • Auxiliary space: O(n). 
    To store every element in hashmap O(n) space is needed
     Thanks to Gaurav Ahirwar for the above solution.

Another Solution:

This problem can be solved in O(N log N) time with another Method, this time the Idea is to use Priority Queue.

Algorithm:

  1. Create a Priority Queue to store the element
  2. Store the first element in a variable
  3. Remove it from the Priority Queue
  4. Check the difference between this removed first element and the new peek element
  5. If the difference is equal to 1 increase count by 1 and repeats step 2 and step 3
  6. If the difference is greater than 1 set counter to 1 and repeat step 2 and step 3
  7. if the difference is equal to 0 repeat step 2 and 3
  8. if counter greater than the previous maximum then store counter to maximum
  9. Continue step 4 to 7 until we reach the end of the Priority Queue
  10. Return the maximum value

C++

// CPP program for the above approach
#include <bits/stdc++.h>
using namespace std;

int findLongestConseqSubseq(int arr[], int N)
{
    priority_queue<int, vector<int>, greater<int> > pq;
    for (int i = 0; i < N; i++) {
      
        // adding element from
        // array to PriorityQueue
        pq.push(arr[i]);
    }

    // Storing the first element
    // of the Priority Queue
    // This first element is also
    // the smallest element
    int prev = pq.top();
    pq.pop();

    // Taking a counter variable with value 1
    int c = 1;

    // Storing value of max as 1
    // as there will always be
    // one element
    int max = 1;
    while (!pq.empty()) {
      
        // check if current peek
        // element minus previous
        // element is greater then
        // 1 This is done because
        // if it's greater than 1
        // then the sequence
        // doesn't start or is broken here
        if (pq.top() - prev > 1) {
          
            // Store the value of counter to 1
            // As new sequence may begin
            c = 1;

            // Update the previous position with the
            // current peek And remove it
            prev = pq.top();
            pq.pop();
        }

        // Check if the previous
        //  element and peek are same
        else if (pq.top() - prev == 0) {
          
            // Update the previous position with the
            // current peek And remove it
            prev = pq.top();
            pq.pop();
        }
      
        // If the difference
        // between previous element and peek is 1
        else {
          
            // Update the counter
            // These are consecutive elements
            c++;

            // Update the previous position
            //  with the current peek And remove it
            prev = pq.top();
            pq.pop();
        }
      
        // Check if current longest
        // subsequence is the greatest
        if (max < c) {
          
            // Store the current subsequence count as
            // max
            max = c;
        }
    }
    return max;
}

// Driver Code
int main()
{
    int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
    int n = 7;

    cout << "Length of the Longest consecutive subsequence "
            "is "
         << findLongestConseqSubseq(arr, n);
    return 0;
}
// this code is contributed by Manu Pathria

Java

// Java Program to find longest consecutive 
// subsequence This Program uses Priority Queue
import java.io.*;
import java.util.PriorityQueue;
public class Longset_Sub
{
    // return the length of the longest
    // subsequence of consecutive integers
    static int findLongestConseqSubseq(int arr[], int N)
    {

        PriorityQueue<Integer> pq
            = new PriorityQueue<Integer>();
        for (int i = 0; i < N; i++) 
        {
            // adding element from 
            // array to PriorityQueue
            pq.add(arr[i]);
        }
        
        // Storing the first element 
        // of the Priority Queue
        // This first element is also 
        // the smallest element
        int prev = pq.poll();
        
        // Taking a counter variable with value 1
        int c = 1;
        
        // Storing value of max as 1
        // as there will always be
        // one element
        int max = 1;

        for (int i = 1; i < N; i++) 
        {
            // check if current peek 
            // element minus previous
            // element is greater then 
            // 1 This is done because
            // if it's greater than 1 
            // then the sequence
            // doesn't start or is broken here
            if (pq.peek() - prev > 1) 
            {
                // Store the value of counter to 1
                // As new sequence may begin
                c = 1;
                
                // Update the previous position with the
                // current peek And remove it
                prev = pq.poll();
            }
            
            // Check if the previous
            //  element and peek are same
            else if (pq.peek() - prev == 0) 
            {
                // Update the previous position with the
                // current peek And remove it
                prev = pq.poll();
            }
            // if the difference 
            // between previous element and peek is 1
            else 
            {
                // Update the counter
                // These are consecutive elements
                c++;
                 
                // Update the previous position
                //  with the current peek And remove it
                prev = pq.poll();
            }

            // Check if current longest 
            // subsequence is the greatest
            if (max < c) 
            {
                // Store the current subsequence count as
                // max
                max = c;
            }
        }

        return max;
    }
    
    // Driver Code
    public static void main(String args[])
        throws IOException
    {
        int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
        int n = arr.length;
        System.out.println(
            "Length of the Longest consecutive subsequence is "
            + findLongestConseqSubseq(arr, n));
    }
}
// This code is contributed by Sudipa Sarkar
Output
Length of the Longest consecutive subsequence is 4
 

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!