Convert array into Zig-Zag fashion

Given an array of distinct elements of size N, the task is to rearrange the elements of the array in a zig-zag fashion so that the converted array should be in the below form: 

arr[0] < arr[1]  > arr[2] < arr[3] > arr[4] < . . . . arr[n-2] < arr[n-1] > arr[n]. 

Examples:

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

Convert array into Zig-Zag fashion Using Sorting

The Idea is to first sort the array. 

After sorting, exclude the first element, swap the remaining elements in pairs. (i.e. keep arr[0] as it is, swap arr[1] and arr[2], swap arr[3] and arr[4], and so on). 

Follow the steps mentioned below to implement the idea:

• Sort the array.
• Traverse the array from index 1 to N-1, and increase the value of index by 2.
• While traversing the array swap arr[i] with arr[i+1].
• Print the final array.

Below is the implementation of the above approach:

C++

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

void zigZag(vector<int>& 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<int> 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));
    }
}

Python3

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

<script>

// JavaScript program to sort an array
// in Zig-Zag form

// Program for zig-zag conversion of array
function zigZag(arr, n)
{
    // sort the by using the sort function
    arr.sort();
    //traverse the array from 1 to n-1
    for(let i = 1; i <= n - 2; i++)
    {
    // swap the current element with next element
        let temp = arr[i];
        arr[i] = arr[i+1];
        arr[i+1] = temp;
    }
}

// Driver code
let arr = [ 4, 3, 7, 8, 6, 2, 1 ];
let n = arr.length;
zigZag(arr, n);
// print the array
for(let i = 0; i < n; i++)
    document.write(arr[i] + " ");

// This code is contributed by Surbhi Tyagi.

</script>

Output

1 3 2 6 4 8 7 

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

Optimized approach for Convert array into Zig-Zag fashion

In this approach, rather than sorting the complete array, we will maintain a flag for representing which order(i.e.,< or >) we currently need. If the current two elements are not in that order, then swap those elements, otherwise not.

Illustration:

Below is the illustration of above approach.

Follow the steps mentioned below to implement the idea:

• Create a bool variable flag and set it to true
• Traverse the array from index 0 to N-1 
• If the value of flag is true then check if  arr[i] < arr[i+1] or not , if not then swap
• Flip the value of flag
• If the value of flag is false then check if  arr[i] > arr[i+1] or not , if not then swap
• Print the final array.

Below is the implementation of the above approach:

C++

// C++ program to sort an array in Zig-Zag form
#include <iostream>
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

<script>

// JavaScript program to sort an array
// in Zig-Zag form

// Program for zig-zag conversion of array
function zigZag(arr, n)
{

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

    for(let i = 0; i <= n - 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])
                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])
                 temp = arr[i];
                 arr[i] = arr[i + 1];
                 arr[i + 1] = temp;
        }

        // Flip flag
        flag = !flag;
    }
}

// Driver code
let arr = [ 4, 3, 7, 8, 6, 2, 1 ];
let n = arr.length;
zigZag(arr, n);

for(let i = 0; i < n; i++)
    document.write(arr[i] + " ");

// This code is contributed by Surbhi Tyagi.

</script>

Output

3 7 4 8 2 6 1 

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