# Longest Consecutive Subsequence

• Difficulty Level : Medium
• Last Updated : 21 Jun, 2022

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 using namespace std;  // Returns length of the longest// contiguous subsequenceint findLongestConseqSubseq(int arr[], int n){    int ans = 0, count = 0;      // sort the array    sort(arr, arr + n);      vector 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 codeint 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 subsequenceimport 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 v = new ArrayList();        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 subsequenceusing 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 v = new List();     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



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 using namespace std;  // Returns length of the longest// contiguous subsequenceint findLongestConseqSubseq(int arr[], int n){    unordered_set 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 codeint 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 subsequenceimport java.io.*;import java.util.*;  class ArrayElements {    // Returns length of the longest    // consecutive subsequence    static int findLongestConseqSubseq(int arr[], int n)    {        HashSet S = new HashSet();        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

## Python3

 # Python program to find longest contiguous subsequence    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 codeif __name__ == '__main__':    n = 7    arr = [1, 9, 3, 10, 4, 20, 2]    print ("Length of the Longest contiguous subsequence is ",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 S = new HashSet();        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



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 using namespace std;  int findLongestConseqSubseq(int arr[], int N){    priority_queue, greater > 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 Codeint 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 Queueimport 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 pq            = new PriorityQueue();        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

## Python3

 # Python program for the above approachimport bisect  def findLongestConseqSubseq(arr,N):    pq = []    for i in range(N):                # adding element from        # array to PriorityQueue        bisect.insort(pq,arr[i])              # Storing the first element    # of the Priority Queue    # This first element is also    # the smallest element    prev = pq[0]    pq.pop(0)          # Taking a counter variable with value 1    c=1          # Storing value of max as 1    # as there will always be    # one element    max = 1    while(len(pq)):        # 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[0] - 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[0]            pq.pop(0)                      # Check if the previous        # element and peek are same        elif(pq[0] - prev == 0):            # Update the previous position with the            # current peek And remove it            prev = pq[0]            pq.pop(0)                      # If the difference        # between previous element and peek is 1        else:            # Update the counter            # These are consecutive elements            c = c +1            # Update the previous position            # with the current peek And remove it            prev = pq[0]            pq.pop(0)                      # Check if current longest        # subsequence is the greatest        if(max < c):            # Store the current subsequence count as            # max            max = c    return max  # Driver Codearr = [1, 9, 3, 10, 4, 20, 2]n = 7print("Length of the Longest consecutive subsequence is {}".format(findLongestConseqSubseq(arr, n)))    # This code is contributed by Pushpesh Raj

## C#

 // C# program to implement// the above approachusing System;using System.Collections.Generic;  class GFG{    // return the length of the longest  // subsequence of consecutive integers  static int findLongestConseqSubseq(int[] arr, int N)  {      List pq = new List();    for (int i = 0; i < N; i++)    {        // adding element from      // array to PriorityQueue      pq.Add(arr[i]);      pq.Sort();    }      // Storing the first element    // of the Priority Queue    // This first element is also    // the smallest element    int prev = pq[0];      // 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[0] - 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[0];        pq.RemoveAt(0);      }        // Check if the previous      //  element and peek are same      else if (pq[0] - prev == 0)      {          // Update the previous position with the        // current peek And remove it        prev = pq[0];        pq.RemoveAt(0);      }        // 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[0];        pq.RemoveAt(0);      }        // 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()  {    int[] arr = { 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 code_hunt.

Output

Length of the Longest consecutive subsequence is 4