Length of the longest ZigZag subarray of the given array

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: 6
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: 2
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:



Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 diferent 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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 diferent 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 diferent 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 diferent 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
chevron_right

Output:
2

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.





Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :