Skip to content
Related Articles

Related Articles

Longest increasing subarray

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 18 Jul, 2022
View Discussion
Improve Article
Save Article

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

Implementation:

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 different
    // 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 different
        // 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 different
    # 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 different
        // 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 different
    // 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.
?>
Javascript



<script>
  
// Javascript 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 different
    // instants of time
    var max = 1, len = 1;
      
    // traverse the array from the 2nd element
    for (var 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
var arr = [5, 6, 3, 5, 7, 8, 9, 1, 2];
var n = arr.length;
document.write("Length = " + lenOfLongIncSubArr(arr, n));
// This code is contributed by shivani.
</script>
Output
Length = 5
Time Complexity: O(n)
How to print the subarray? 
We can print the subarray by keeping track of the index with the largest length. 
Implementation:
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 different
    // 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 different
        // 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 different
    # 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 different
        // 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
    // different 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
?>
Javascript



<script>
 
// Javascript 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 different
    // instants of time
    var max = 1, len = 1, maxIndex = 0;
     
    // traverse the array from the 2nd element
    for (var 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 (var i=maxIndex; i<max+maxIndex; i++)
        document.write( arr[i] + " ");
}
 
// Driver program to test above
var arr = [5, 6, 3, 5, 7, 8, 9, 1, 2];
var n = arr.length;
printLogestIncSubArr(arr, n);
 
// This code is contributed by rrrtnx.
</script>
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 write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. 

My Personal Notes
arrow_drop_up
Next

Longest Increasing Subsequence | DP-3
Recommended Articles
Page :
Print the longest increasing consecutive subarray
19, Jan 22
Longest increasing subsequence which forms a subarray in the sorted representation of the array
21, Sep 20
Maximum length of longest increasing contiguous subarray after deleting exactly one element from array
27, Oct 21
Find the length of Longest increasing Consecutive Subarray
16, Jan 22
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
Longest Increasing subarray with one change allowed
10, Nov 17
Length of longest increasing circular subarray
12, Dec 17
Length of the longest alternating increasing decreasing subarray
23, Nov 21
Minimum size Subarray with maximum sum in non-increasing order
16, Apr 20
Maximum score of Array using increasing subsequence and subarray with given conditions
14, Dec 21
Maximize product of a strictly increasing or decreasing subarray
12, Jan 21
Largest sum contiguous increasing subarray
10, May 17
Find Maximum Sum Strictly Increasing Subarray
07, Dec 16
Longest increasing sub-sequence formed by concatenating array to itself N times
18, Mar 20
Length of longest increasing index dividing subsequence
16, May 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
Longest increasing sequence possible by the boundary elements of an Array
03, Jan 21
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

Start Your Coding Journey Now!