Convert Array into ZigZag fashion (original) (raw)

Last Updated : 23 Jul, 2025

Given an array of distinct elements of size **N, the task is to rearrange the elements of the array in a **zig-zag fashion, i.e., the elements are arranged as smaller, then larger, then smaller, and so on. There can be more than one arrangement that follows the form:

arr[0] ****<** arr[1] > arr[2] < arr[3] > arr[4] < ...

Examples:

Input: N = 7, arr[] = [4, 3, 7, 8, 6, 2, 1]
Output: [3, 7, 4, 8, 2, 6, 1]
Explanation: The given array is in zig-zag pattern as we can see 3 < 7 > 4 < 8 > 2 < 6 >1

Input: N = 4, arr[] = [1, 4, 3, 2]
Output: [1, 4, 2, 3]

Try It Yourselfredirect icon

Table of Content

[Naive Approach] Using Sorting - O(N*log(N)) time and O(1) **Space

The most basic approach is to solve this with the help of Sorting. The idea is to sort the array first and then swap adjacent elements (from 1st index) to make the array as zig-zag array.

**Code Implementation:

C++ `

#include <bits/stdc++.h> using namespace std;

void zigZag(vector& arr, int N) { // sort the array by using the sort function sort(arr.begin(), arr.end()); // traverse the array from 1 to N -1 for (int i = 1; i < N - 1; i += 2) { // swap the current element with the next element swap(arr[i], arr[i + 1]); } // print the complete array for (int i = 0; i < N; i++) { cout << arr[i] << " "; } return; } int main() { vector arr = { 4, 3, 7, 8, 6, 2, 1 }; int N = 7; zigZag(arr, N); return 0; }

C

#include <stdio.h> #include <stdlib.h> int comparator(const void* p, const void* q) { return ((int)p - (int)q); } void zigZag(int arr[], int N) { // sort the array using the qsort function qsort((void*)arr, N, sizeof(arr[0]), comparator); for (int i = 1; i < N - 1; i += 2) { // swap the value of current element with next // element int temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } // print the complete array for (int i = 0; i < N; i++) printf("%d ", arr[i]); return; } int main() { int arr[] = { 2, 3, 4, 1, 5, 7, 6 }; int N = 7; zigZag(arr, N); return 0; }

Java

// Java program to sort an array in Zig-Zag form import java.util.Arrays;

class Test { static int arr[] = new int[] { 4, 3, 7, 8, 6, 2, 1 }; static void zigZag() { // sort the array using the sort function Arrays.sort(arr); // traverse the array from 1 to N -1 for (int i = 1; i <= arr.length - 2; i += 2) { // swap the current element with the next // element int temp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = temp; } }

// Driver method to test the above function
public static void main(String[] args)
{
    zigZag();
    // print the complete array
    System.out.println(Arrays.toString(arr));
}

}

Python

def zigZag(arr, n): # use sort function to sort the array arr.sort() # traverse the array from 1 to n-1 for i in range(1, n-1, 2): # swap value of current element with next element arr[i], arr[i+1] = arr[i+1], arr[i] # print the array print(arr)

Driver program

if name == "main": arr = [4, 3, 7, 8, 6, 2, 1] n = len(arr) zigZag(arr, n)

C#

// C# program to sort an array in Zig-Zag form using System;

class GFG {

static int[] arr = new int[] { 4, 3, 7, 8, 6, 2, 1 };

// Method for zig-zag conversion of array
static void zigZag()
{
    // sort the array by using the sort function
    Array.Sort(arr);
    for (int i = 1; i <= arr.Length - 2; i += 2) {
        // swap the current element with next next
        // element
        int temp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = temp;
    }
}

// Driver code
public static void Main(String[] args)
{
    zigZag();
    // print the array
    foreach(int i in arr) Console.Write(i + " ");
}

}

JavaScript

`

Time complexity: O(N*log(N)), because **sorting is used.
Auxiliary Space: O(1)

[Expected Approach] Rearranging Triplets using Flag - O(N) time **and O(1) **Space

The most efficient and expected approach is to use the triplet relation of zig-zag array, i.e. **arr[i-1] < arr[i] > arr[i+1].

The idea is that for each triplet, the middle element should be greater than its adjacent neighbours. So, for each triplet:

  1. First check the left neighbour with the middle element. If middle is smaller, swap the elements.
  2. Then check the middle with right neighbour. If middle is smaller, swap the elements.
  3. Repeat the process till complete array is traversed.

**Code Implementation:

C++ `

// C++ program to sort an array in Zig-Zag form #include using namespace std;

// Program for zig-zag conversion of array void zigZag(int arr[], int n) { // Flag true indicates relation "<" is expected, // else ">" is expected. The first expected relation // is "<" bool flag = true;

for (int i = 0; i <= n - 2; i++) {
    if (flag) /* "<" relation expected */
    {
        /* If we have a situation like A > B > C,
        we get A > C < B by swapping B and C */
        if (arr[i] > arr[i + 1])
            swap(arr[i], arr[i + 1]);
    }
    else /* ">" relation expected */
    {
        /* If we have a situation like A < B < C,
        we get A < C > B by swapping B and C */
        if (arr[i] < arr[i + 1])
            swap(arr[i], arr[i + 1]);
    }
    flag = !flag; /* flip flag */
}

}

// Driver program int main() { int arr[] = { 4, 3, 7, 8, 6, 2, 1 }; int n = sizeof(arr) / sizeof(arr[0]); zigZag(arr, n); for (int i = 0; i < n; i++) cout << arr[i] << " "; return 0; }

// This code is contributed by Sania Kumari Gupta // (kriSania804)

C

// C program to sort an array in Zig-Zag form #include <stdbool.h> #include <stdio.h>

// This function swaps values pointed by xp and yp void swap(int* xp, int* yp) { int temp = *xp; *xp = *yp; *yp = temp; }

// Program for zig-zag conversion of array void zigZag(int arr[], int n) { // Flag true indicates relation "<" is expected, // else ">" is expected. The first expected relation // is "<" bool flag = true;

for (int i = 0; i <= n - 2; i++) {
    if (flag) /* "<" relation expected */
    {
        /* If we have a situation like A > B > C,
        we get A > C < B by swapping B and C */
        if (arr[i] > arr[i + 1])
            swap(&arr[i], &arr[i + 1]);
    }
    else /* ">" relation expected */
    {
        /* If we have a situation like A < B < C,
        we get A < C > B by swapping B and C */
        if (arr[i] < arr[i + 1])
            swap(&arr[i], &arr[i + 1]);
    }
    flag = !flag; /* flip flag */
}

}

// Driver program int main() { int arr[] = { 4, 3, 7, 8, 6, 2, 1 }; int n = sizeof(arr) / sizeof(arr[0]); zigZag(arr, n); for (int i = 0; i < n; i++) printf("%d ", arr[i]); return 0; }

// This code is contributed by Sania Kumari Gupta // (kriSania804)

Java

// Java program to sort an array in Zig-Zag form import java.util.Arrays;

class Test { static int arr[] = new int[] { 4, 3, 7, 8, 6, 2, 1 };

// Method for zig-zag conversion of array
static void zigZag()
{
    // Flag true indicates relation "<" is expected,
    // else ">" is expected. The first expected relation
    // is "<"
    boolean flag = true;

    int temp = 0;

    for (int i = 0; i <= arr.length - 2; i++) {
        if (flag) /* "<" relation expected */
        {
            /* If we have a situation like A > B > C,
            we get A > C < B by swapping B and C */
            if (arr[i] > arr[i + 1]) {
                // swap
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        else /* ">" relation expected */
        {
            /* If we have a situation like A < B < C,
            we get A < C > B by swapping B and C */
            if (arr[i] < arr[i + 1]) {
                // swap
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        flag = !flag; /* flip flag */
    }
}

// Driver method to test the above function
public static void main(String[] args)
{
    zigZag();
    System.out.println(Arrays.toString(arr));
}

}

Python

Python program to sort an array in Zig-Zag form

Program for zig-zag conversion of array

def zigZag(arr, n): # Flag true indicates relation "<" is expected, # else ">" is expected. The first expected relation # is "<" flag = True for i in range(n-1): # "<" relation expected if flag is True: # If we have a situation like A > B > C, # we get A > C < B # by swapping B and C if arr[i] > arr[i+1]: arr[i], arr[i+1] = arr[i+1], arr[i] # ">" relation expected else: # If we have a situation like A < B < C, # we get A < C > B # by swapping B and C if arr[i] < arr[i+1]: arr[i], arr[i+1] = arr[i+1], arr[i] flag = bool(1 - flag) print(arr)

Driver program

arr = [4, 3, 7, 8, 6, 2, 1] n = len(arr) zigZag(arr, n)

This code is contributed by Pratik Chhajer

This code was improved by Hardik Jain

C#

// C# program to sort an array in Zig-Zag form using System;

class GFG {

static int[] arr = new int[] { 4, 3, 7, 8, 6, 2, 1 };

// Method for zig-zag conversion of array
static void zigZag()
{

    // Flag true indicates relation "<"
    // is expected, else ">" is expected.
    // The first expected relation
    // is "<"
    bool flag = true;

    int temp = 0;

    for (int i = 0; i <= arr.Length - 2; i++) {

        // "<" relation expected
        if (flag) {

            // If we have a situation like A > B > C,
            // we get A > C < B by swapping B and C
            if (arr[i] > arr[i + 1]) {

                // Swap
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        // ">" relation expected
        else {

            // If we have a situation like A < B < C,
            // we get A < C > B by swapping B and C
            if (arr[i] < arr[i + 1]) {

                // Swap
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        // Flip flag
        flag = !flag;
    }
}

// Driver code
public static void Main(String[] args)
{
    zigZag();
    foreach(int i in arr) Console.Write(i + " ");
}

}

// This code is contributed by amal kumar choubey

JavaScript

`

Time complexity: O(N)
Auxiliary Space: O(1)

**Illustration of the Expected Approach: