Skip to content
Related Articles

Related Articles

Longest increasing subarray
  • Difficulty Level : Easy
  • Last Updated : 15 Jul, 2019

Given an array containing n numbers. The problem is to find the length of the longest contiguous subarray such that every element in the subarray is strictly greater than its previous element in the same subarray. Time Complexity should be O(n).

Examples:

Input : arr[] = {5, 6, 3, 5, 7, 8, 9, 1, 2}
Output : 5
The subarray is {3, 5, 7, 8, 9}

Input : arr[] = {12, 13, 1, 5, 4, 7, 8, 10, 10, 11}
Output : 4
The subarray is {4, 7, 8, 10}

Algorithm:

lenOfLongIncSubArr(arr, n)
    Declare max = 1, len = 1
    for i = 1 to n-1
    if arr[i] > arr[i-1]
        len++
    else
        if max < len
            max = len
        len = 1
    if max < len
        max = len
    return max

C++




// C++ implementation to find the length of 
// longest increasing contiguous subarray
#include <bits/stdc++.h>
  
using namespace std;
  
// function to find the length of longest increasing 
// contiguous subarray
int lenOfLongIncSubArr(int arr[], int n)
{
    // 'max' to store the length of longest
    // increasing subarray
    // 'len' to store the lengths of longest
    // increasing subarray at diiferent 
    // instants of time
    int max = 1, len = 1;
      
    // traverse the array from the 2nd element
    for (int i=1; i<n; i++)
    {
        // if current element if greater than previous
        // element, then this element helps in building
        // up the previous increasing subarray encountered
        // so far
        if (arr[i] > arr[i-1])
            len++;
        else
        {
            // check if 'max' length is less than the length
            // of the current increasing subarray. If true, 
            // then update 'max'
            if (max < len)    
                max = len;
                  
            // reset 'len' to 1 as from this element
            // again the length of the new increasing
            // subarray is being calculated    
            len = 1;    
        }    
    }
      
    // comparing the length of the last
    // increasing subarray with 'max'
    if (max < len)
        max = len;
      
    // required maximum length
    return max;
}
  
// Driver program to test above
int main()
{
    int arr[] = {5, 6, 3, 5, 7, 8, 9, 1, 2};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Length = "
         << lenOfLongIncSubArr(arr, n);
    return 0;     
}
Java



// JAVA Code to find length of 
// Longest increasing subarray
import java.util.*;
  
class GFG {
      
    // function to find the length of longest
    // increasing contiguous subarray
    public static int lenOfLongIncSubArr(int arr[],
                                            int n)
    {
        // 'max' to store the length of longest
        // increasing subarray
        // 'len' to store the lengths of longest
        // increasing subarray at diiferent 
        // instants of time
        int max = 1, len = 1;
           
        // traverse the array from the 2nd element
        for (int i=1; i<n; i++)
        {
            // if current element if greater than
            // previous element, then this element 
            // helps in building up the previous 
            // increasing subarray encountered
            // so far
            if (arr[i] > arr[i-1])
                len++;
            else
            {
                // check if 'max' length is less 
                // than the length of the current 
                // increasing subarray. If true,
                // than update 'max'
                if (max < len)    
                    max = len;
                       
                // reset 'len' to 1 as from this 
                // element again the length of the 
                // new increasing subarray is being 
                // calculated    
                len = 1;    
            }    
        }
           
        // comparing the length of the last
        // increasing subarray with 'max'
        if (max < len)
            max = len;
           
        // required maximum length
        return max;
    }
      
    /* Driver program to test above function */
    public static void main(String[] args) 
    {
         int arr[] = {5, 6, 3, 5, 7, 8, 9, 1, 2};
            int n = arr.length;
            System.out.println("Length = " +
                      lenOfLongIncSubArr(arr, n));
          
        }
    }
    
// This code is contributed by Arnav Kr. Mandal.
Python3



# Python 3 implementation to find the length of 
# longest increasing contiguous subarray
  
   
# function to find the length of longest 
# increasing contiguous subarray
def lenOfLongIncSubArr(arr, n) :
  
    # 'max' to store the length of longest
    # increasing subarray
    # 'len' to store the lengths of longest
    # increasing subarray at diiferent 
    # instants of time
    m = 1 
    l = 1 
       
    # traverse the array from the 2nd element
    for i in range(1, n) :
  
        # if current element if greater than previous
        # element, then this element helps in building
        # up the previous increasing subarray encountered
        # so far
        if (arr[i] > arr[i-1]) :
            l =l + 1 
        else :
  
            # check if 'max' length is less than the length
            # of the current increasing subarray. If true, 
            # then update 'max'
            if (m < l)  :
                m = l 
  
            # reset 'len' to 1 as from this element
            # again the length of the new increasing
            # subarray is being calculated    
            l = 1 
          
          
    # comparing the length of the last
    # increasing subarray with 'max'
    if (m < l) :
        m = l
       
    # required maximum length
    return m
  
# Driver program to test above
  
arr = [5, 6, 3, 5, 7, 8, 9, 1, 2]
n = len(arr)
print("Length = ", lenOfLongIncSubArr(arr, n))
  
  
# This code is contributed
# by Nikita Tiwari.
C#



// C# Code to find length of
// Longest increasing subarray
using System;
  
class GFG {
  
    // function to find the length of longest
    // increasing contiguous subarray
    public static int lenOfLongIncSubArr(int[] arr,
                                             int n)
    {
        // 'max' to store the length of longest
        // increasing subarray
        // 'len' to store the lengths of longest
        // increasing subarray at diiferent
        // instants of time
        int max = 1, len = 1;
  
        // traverse the array from the 2nd element
        for (int i = 1; i < n; i++) {
              
            // if current element if greater than
            // previous element, then this element
            // helps in building up the previous
            // increasing subarray encountered
            // so far
            if (arr[i] > arr[i - 1])
                len++;
            else {
                  
                // check if 'max' length is less
                // than the length of the current
                // increasing subarray. If true,
                // than update 'max'
                if (max < len)
                    max = len;
  
                // reset 'len' to 1 as from this
                // element again the length of the
                // new increasing subarray is being
                // calculated
                len = 1;
            }
        }
  
        // comparing the length of the last
        // increasing subarray with 'max'
        if (max < len)
            max = len;
  
        // required maximum length
        return max;
    }
  
    /* Driver program to test above function */
    public static void Main()
    {
        int[] arr = { 5, 6, 3, 5, 7, 8, 9, 1, 2 };
        int n = arr.Length;
        Console.WriteLine("Length = " + 
                           lenOfLongIncSubArr(arr, n));
    }
}
  
// This code is contributed by Sam007
PHP



<?php
// PHP implementation to find the length of 
// longest increasing contiguous subarray
  
// function to find the length of 
// longest increasing contiguous
// subarray
function lenOfLongIncSubArr($arr, $n)
{
      
    // 'max' to store the length of longest
    // increasing subarray
    // 'len' to store the lengths of longest
    // increasing subarray at diiferent 
    // instants of time
    $max = 1;
    $len = 1;
      
    // traverse the array from 
    // the 2nd element
    for ($i = 1; $i < $n; $i++)
    {
          
        // if current element if 
        // greater than previous
        // element, then this element 
        // helps in building up the
        // previous increasing subarray 
        // encountered so far
        if ($arr[$i] > $arr[$i-1])
            $len++;
        else
        {
              
            // check if 'max' length is
            // less than the length
            // of the current increasing
            // subarray. If true, 
            // then update 'max'
            if ($max < $len) 
                $max = $len;
                  
            // reset 'len' to 1 as
            // from this element
            // again the length of 
            // the new increasing
            // subarray is being
            // calculated 
            $len = 1; 
        } 
    }
      
    // comparing the length of the last
    // increasing subarray with 'max'
    if ($max < $len)
        $max = $len;
      
    // required maximum length
    return $max;
}
  
    // Driver Code
    $arr = array(5, 6, 3, 5, 7, 8, 9, 1, 2);
    $n = sizeof($arr);
    echo "Length = ", lenOfLongIncSubArr($arr, $n);
      
// This code is contributed by nitin mittal.
?>

Output:


Length = 5

Time Complexity: O(n)
How to print the subarray?
We can print the subarray by keeping track of index with largest length.
C++



// C++ implementation to find the length of 
// longest increasing contiguous subarray
#include <bits/stdc++.h>
using namespace std;
  
// function to find the length of longest increasing 
// contiguous subarray
void printLogestIncSubArr(int arr[], int n)
{
    // 'max' to store the length of longest
    // increasing subarray
    // 'len' to store the lengths of longest
    // increasing subarray at diiferent 
    // instants of time
    int max = 1, len = 1, maxIndex = 0;
      
    // traverse the array from the 2nd element
    for (int i=1; i<n; i++)
    {
        // if current element if greater than previous
        // element, then this element helps in building
        // up the previous increasing subarray encountered
        // so far
        if (arr[i] > arr[i-1])
            len++;
        else
        {
            // check if 'max' length is less than the length
            // of the current increasing subarray. If true, 
            // then update 'max'
            if (max < len)    
            {
                max = len;
                  
                // index assign the starting index of 
                // longest increasing contiguous subarray.   
                maxIndex = i - max;
            }
                  
            // reset 'len' to 1 as from this element
            // again the length of the new increasing
            // subarray is being calculated    
            len = 1;    
        }    
    }
      
    // comparing the length of the last
    // increasing subarray with 'max'
    if (max < len)
    { 
        max = len;
        maxIndex = n - max;
    }
  
    // Print the elements of longest increasing
    // contiguous subarray. 
    for (int i=maxIndex; i<max+maxIndex; i++)
        cout << arr[i] << " ";
}
  
// Driver program to test above
int main()
{
    int arr[] = {5, 6, 3, 5, 7, 8, 9, 1, 2};
    int n = sizeof(arr) / sizeof(arr[0]);
    printLogestIncSubArr(arr, n);
    return 0;     
}
// This code is contributed by Dharmendra kumar
Java



// JAVA Code For Longest increasing subarray
import java.util.*;
  
class GFG {
      
    // function to find the length of longest 
    // increasing contiguous subarray
    public static void printLogestIncSubArr(int arr[], 
                                              int n)
    {
        // 'max' to store the length of longest
        // increasing subarray
        // 'len' to store the lengths of longest
        // increasing subarray at diiferent 
        // instants of time
        int max = 1, len = 1, maxIndex = 0;
           
        // traverse the array from the 2nd element
        for (int i = 1; i < n; i++)
        {
            // if current element if greater than 
            // previous element, then this element 
            // helps in building up the previous 
            // increasing subarray encountered
            // so far
            if (arr[i] > arr[i-1])
                len++;
            else
            {
                // check if 'max' length is less
                // than the length of the current
                // increasing subarray. If true, 
                // then update 'max'
                if (max < len)    
                {
                    max = len;
                       
                    // index assign the starting 
                    // index of longest increasing
                    // contiguous subarray.   
                    maxIndex = i - max;
                }
                       
                // reset 'len' to 1 as from this
                // element again the length of the
                // new increasing subarray is 
                // being calculated    
                len = 1;    
            }    
        }
           
        // comparing the length of the last
        // increasing subarray with 'max'
        if (max < len)
        { 
            max = len;
            maxIndex = n - max;
        }
       
        // Print the elements of longest 
        // increasing contiguous subarray. 
        for (int i = maxIndex; i < max+maxIndex; i++)
            System.out.print(arr[i] + " ");
    }
      
    /* Driver program to test above function */
    public static void main(String[] args) 
    {
        int arr[] = {5, 6, 3, 5, 7, 8, 9, 1, 2};
        int n = arr.length;
        printLogestIncSubArr(arr, n);
          
    }
}
    
// This code is contributed by Arnav Kr. Mandal.
Python3



# Python 3 implementation to find the length of 
# longest increasing contiguous subarray
  
  
# function to find the length of longest increasing 
# contiguous subarray
def printLogestIncSubArr( arr, n) :
  
    # 'max' to store the length of longest
    # increasing subarray
    # 'len' to store the lengths of longest
    # increasing subarray at diiferent 
    # instants of time
    m = 1
    l = 1
    maxIndex = 0
       
    # traverse the array from the 2nd element
    for i in range(1, n) :
  
        # if current element if greater than previous
        # element, then this element helps in building
        # up the previous increasing subarray 
        # encountered so far
        if (arr[i] > arr[i-1]) :
            l =l + 1
        else :
  
            # check if 'max' length is less than the length
            # of the current increasing subarray. If true, 
            # then update 'max'
            if (m < l)  :
                m = l 
  
                # index assign the starting index of 
                # longest increasing contiguous subarray.   
                maxIndex = i - m
                    
            # reset 'len' to 1 as from this element
            # again the length of the new increasing
            # subarray is being calculated    
            l = 1    
          
          
    # comparing the length of the last
    # increasing subarray with 'max'
    if (m < l) :
        m = l
        maxIndex = n - m
      
    # Print the elements of longest
    # increasing contiguous subarray. 
    for i in range(maxIndex, (m+maxIndex)) :
        print(arr[i] , end=" ")
          
# Driver program to test above
arr = [5, 6, 3, 5, 7, 8, 9, 1, 2]
n = len(arr)
printLogestIncSubArr(arr, n)
      
      
# This code is contributed
# by Nikita Tiwari
C#



// C# Code to print 
// Longest increasing subarray
using System;
  
class GFG {
  
    // function to find the length of longest
    // increasing contiguous subarray
    public static void printLogestIncSubArr(int[] arr,
                                                int n)
    {
        // 'max' to store the length of longest
        // increasing subarray
        // 'len' to store the lengths of longest
        // increasing subarray at diiferent
        // instants of time
        int max = 1, len = 1, maxIndex = 0;
  
        // traverse the array from the 2nd element
        for (int i = 1; i < n; i++) {
              
            // if current element if greater than
            // previous element, then this element
            // helps in building up the previous
            // increasing subarray encountered
            // so far
            if (arr[i] > arr[i - 1])
                len++;
            else 
            {
                // check if 'max' length is less
                // than the length of the current
                // increasing subarray. If true,
                // then update 'max'
                if (max < len) {
                    max = len;
  
                    // index assign the starting
                    // index of longest increasing
                    // contiguous subarray.
                    maxIndex = i - max;
                }
  
                // reset 'len' to 1 as from this
                // element again the length of the
                // new increasing subarray is
                // being calculated
                len = 1;
            }
        }
  
        // comparing the length of the last
        // increasing subarray with 'max'
        if (max < len) {
            max = len;
            maxIndex = n - max;
        }
  
        // Print the elements of longest
        // increasing contiguous subarray.
        for (int i = maxIndex; i < max + maxIndex; i++)
            Console.Write(arr[i] + " ");
    }
  
    /* Driver program to test above function */
    public static void Main()
    {
        int[] arr = { 5, 6, 3, 5, 7, 8, 9, 1, 2 };
        int n = arr.Length;
        printLogestIncSubArr(arr, n);
    }
}
  
// This code is contributed by Sam007
PHP



<?php
// PHP implementation to find 
// the length of longest increasing 
// contiguous subarray
  
// function to find the length of 
// longest increasing contiguous subarray
function printLogestIncSubArr(&$arr, $n)
{
    // 'max' to store the length of 
    // longest increasing subarray
    // 'len' to store the lengths of 
    // longest increasing subarray at 
    // diiferent instants of time
    $max = 1; 
    $len = 1; 
    $maxIndex = 0;
      
    // traverse the array from 
    // the 2nd element
    for ($i = 1; $i < $n; $i++)
    {
        // if current element if greater 
        // than previous element, then 
        // this element helps in building
        // up the previous increasing 
        // subarray encountered so far
        if ($arr[$i] > $arr[$i - 1])
            $len++;
        else
        {
            // check if 'max' length is less 
            // than the length of the current 
            // increasing subarray. If true, 
            // then update 'max'
            if ($max < $len) 
            {
                $max = $len;
                  
                // index assign the starting 
                // index of longest increasing
                // contiguous subarray. 
                $maxIndex = $i - $max;
            }
                  
            // reset 'len' to 1 as from this
            // element again the length of 
            // the new increasing subarray
            // is being calculated 
            $len = 1; 
        } 
    }
      
    // comparing the length of
    // the last increasing 
    // subarray with 'max'
    if ($max < $len)
    { 
        $max = $len;
        $maxIndex = $n - $max;
    }
  
    // Print the elements of
    // longest increasing
    // contiguous subarray. 
    for ($i = $maxIndex; 
         $i < ($max + $maxIndex); $i++)
        echo($arr[$i] . " ") ;
          
}
  
// Driver Code
$arr = array(5, 6, 3, 5, 7, 
             8, 9, 1, 2);
$n = sizeof($arr);
printLogestIncSubArr($arr, $n);
      
// This code is contributed
// by Shivi_Aggarwal
?>

Output:
3 5 7 8 9 

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
My Personal Notes
arrow_drop_up
Next

Longest Increasing Subsequence | DP-3
Recommended Articles
Page :
Length of longest increasing circular subarray
12, Dec 17
Longest increasing subsequence which forms a subarray in the sorted representation of the array
21, Sep 20
Longest Increasing subarray with one change allowed
10, Nov 17
Length of longest subarray with increasing contiguous elements
25, Oct 20
Length of the longest increasing subsequence which does not contain a given sequence as Subarray
01, Nov 20
Largest sum contiguous increasing subarray
10, May 17
Minimum size Subarray with maximum sum in non-increasing order
16, Apr 20
Find Maximum Sum Strictly Increasing Subarray
07, Dec 16
Maximize product of a strictly increasing or decreasing subarray
12, Jan 21
Construction of Longest Increasing Subsequence (N log N)
23, Nov 12
Longest Monotonically Increasing Subsequence Size (N log N): Simple implementation
23, Aug 14
Longest Increasing consecutive subsequence
13, May 18
Printing longest Increasing consecutive subsequence
13, May 18
Longest Increasing Subsequence using BIT
28, Nov 19
Longest increasing sub-sequence formed by concatenating array to itself N times
18, Mar 20
Longest increasing sequence by the boundary elements of an Array
20, Jun 20
Longest Increasing Subsequence having sum value atmost K
07, Jul 20
Maximize length of longest increasing prime subsequence from the given array
21, Sep 20
Length of longest increasing prime subsequence from a given array
12, Sep 20
Length of longest increasing absolute even subsequence
22, Sep 20
Longest increasing subsequence consisting of elements from indices divisible by previously selected indices
04, Dec 20
Number of Longest Increasing Subsequences
16, Nov 20
Maximize sum of all elements which are not a part of the Longest Increasing Subsequence
31, May 20
Longest Increasing Subsequence | DP-3
05, Jun 11
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox