# Convert array into Zig-Zag fashion

• Difficulty Level : Easy
• Last Updated : 10 Aug, 2022

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 ``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 ``#include ``int` `comparator(``const` `void``* p, ``const` `void``* q)``{``    ``return` `(*(``int``*)p - *(``int``*)q);``}``void` `zigZag(``int` `arr[], ``int` `N)``{``    ``// sort the array usinf 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 usinf 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

 ``

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 ``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 ``#include ` `// 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

 ``

Output

`3 7 4 8 2 6 1 `

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

My Personal Notes arrow_drop_up