Skip to content
Related Articles

Related Articles

Improve Article
Length of the longest ZigZag subarray of the given array
  • Last Updated : 12 May, 2021

Given an array arr[] containing n numbers, the task is to find the length of the longest ZigZag subarray such that every element in the subarray should be in form 

a < b > c < d > e < f

Examples: 

Input: arr[] = {12, 13, 1, 5, 4, 7, 8, 10, 10, 11} 
Output:
Explanation: 
The subarray is {12, 13, 1, 5, 4, 7} whose length is 6 and is in zigzag fashion.

Input: arr[] = {1, 2, 3, 4, 5} 
Output:
Explanation: 
The subarray is {1, 2} or {2, 3} or {4, 5} whose length is 2. 
 

Approach: To solve the problem mentioned above following steps are followed: 



  • Initially initialize cnt, a counter as 1.
  • Iterate among the array elements, check if elements are in form
a < b > c < d > e < f
  • If true Increase the cnt by 1. If it is not in form
a < b > c < d > e < f
  • then re-initialize cnt by 1.

Below is the implementation of the above approach:  

C++




// C++ implementation to find
// the length of longest zigzag
// subarray of the given array
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the length of
// longest zigZag contiguous subarray
int lenOfLongZigZagArr(int a[], int n)
{
 
    // 'max' to store the length
    // of longest zigZag subarray
    int max = 1,
 
        // 'len' to store the lengths
        // of longest zigZag subarray
        // at different instants of time
        len = 1;
 
    // Traverse the array from the beginning
    for (int i = 0; i < n - 1; i++) {
 
        if (i % 2 == 0
            && (a[i] < a[i + 1]))
            len++;
 
        else if (i % 2 == 1
                 && (a[i] > a[i + 1]))
            len++;
 
        else {
            // Check if 'max' length
            // is less than the length
            // of the current zigzag 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 zigzag subarray
            // is being calculated
            len = 1;
        }
    }
 
    // comparing the length of the last
    // zigzag subarray with 'max'
    if (max < len)
        max = len;
 
    // Return required maximum length
    return max;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    cout << lenOfLongZigZagArr(arr, n);
 
    return 0;
}

Java




// Java implementation to find
// the length of longest zigzag
// subarray of the given array
import java.io.*;
import java.util.*;
class GFG {
     
// Function to find the length of
// longest zigZag contiguous subarray
static int lenOfLongZigZagArr(int a[], int n)
{
    // 'max' to store the length
    // of longest zigZag subarray
    int max = 1,
 
    // 'len' to store the lengths
    // of longest zigZag subarray
    // at different instants of time
    len = 1;
 
    // Traverse the array from the beginning
    for (int i = 0; i < n - 1; i++)
    {
        if (i % 2 == 0 && (a[i] < a[i + 1]))
            len++;
     
        else if (i % 2 == 1 && (a[i] > a[i + 1]))
            len++;
     
        else
        {
            // Check if 'max' length
            // is less than the length
            // of the current zigzag 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 zigzag subarray
            // is being calculated
            len = 1;
        }
    }
 
    // comparing the length of the last
    // zigzag subarray with 'max'
    if (max < len)
        max = len;
     
    // Return required maximum length
    return max;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int n = arr.length;
 
    System.out.println(lenOfLongZigZagArr(arr, n));
}
}
 
// This code is contributed by coder001

Python3




# Python3 implementation to find the
# length of longest zigzag subarray
# of the given array
 
# Function to find the length of
# longest zigZag contiguous subarray
def lenOfLongZigZagArr(a, n):
 
    # '_max' to store the length
    # of longest zigZag subarray
    _max = 1
 
    # '_len' to store the lengths
    # of longest zigZag subarray
    # at different instants of time
    _len = 1
 
    # Traverse the array from the beginning
    for i in range(n - 1):
 
        if i % 2 == 0 and a[i] < a[i + 1]:
            _len += 1
 
        elif i % 2 == 1 and a[i] > a[i + 1]:
            _len += 1
 
        else:
             
            # Check if '_max' length is less than
            # the length of the current zigzag
            # 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 zigzag
            # subarray is being calculated
            _len = 1
     
    # Comparing the length of the last
    # zigzag subarray with '_max'
    if _max < _len:
        _max = _len
         
    # Return required maximum length
    return _max
 
# Driver code
arr = [ 1, 2, 3, 4, 5 ]
n = len(arr)
 
print(lenOfLongZigZagArr(arr, n))
     
# This code is contributed by divyamohan123

C#




// C# implementation to find
// the length of longest zigzag
// subarray of the given array
using System;
 
class GFG{
     
// Function to find the length of
// longest zigZag contiguous subarray
static int lenOflongZigZagArr(int []a, int n)
{
     
    // 'max' to store the length
    // of longest zigZag subarray
    int max = 1,
 
    // 'len' to store the lengths
    // of longest zigZag subarray
    // at different instants of time
    len = 1;
 
    // Traverse the array from the beginning
    for(int i = 0; i < n - 1; i++)
    {
       if (i % 2 == 0 && (a[i] < a[i + 1]))
           len++;
            
       else if (i % 2 == 1 && (a[i] > a[i + 1]))
           len++;
            
       else
       {
 
           // Check if 'max' length
           // is less than the length
           // of the current zigzag 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 zigzag subarray
           // is being calculated
           len = 1;
       }
    }
 
    // Comparing the length of the last
    // zigzag subarray with 'max'
    if (max < len)
        max = len;
     
    // Return required maximum length
    return max;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 3, 4, 5 };
    int n = arr.Length;
 
    Console.WriteLine(lenOflongZigZagArr(arr, n));
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// Javascript implementation to find
// the length of longest zigzag
// subarray of the given array
 
// Function to find the length of
// longest zigZag contiguous subarray
function lenOfLongZigZagArr( a, n)
{
 
    // 'max' to store the length
    // of longest zigZag subarray
    var max = 1,
 
    // 'len' to store the lengths
    // of longest zigZag subarray
    // at different instants of time
    len = 1;
 
    // Traverse the array from the beginning
    for (var i = 0; i < n - 1; i++) {
 
        if (i % 2 == 0
            && (a[i] < a[i + 1]))
            len++;
 
        else if (i % 2 == 1
                 && (a[i] > a[i + 1]))
            len++;
 
        else {
            // Check if 'max' length
            // is less than the length
            // of the current zigzag 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 zigzag subarray
            // is being calculated
            len = 1;
        }
    }
 
    // comparing the length of the last
    // zigzag subarray with 'max'
    if (max < len)
        max = len;
 
    // Return required maximum length
    return max;
}
 
// Driver code
var arr = [ 1, 2, 3, 4, 5 ];
var n = arr.length;
document.write( lenOfLongZigZagArr(arr, n));
 
</script>
Output: 
2

 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes




My Personal Notes arrow_drop_up
Recommended Articles
Page :