# 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 < arr  > arr < arr > arr < . . . . 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 as it is, swap arr and arr, swap arr and arr, 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), 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);` `    ``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);` `    ``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
Recommended Articles
Page :