# Convert array into Zig-Zag fashion

Given an array of **DISTINCT** elements, rearrange the elements of array in zig-zag fashion in O(n) time. The converted array should be in form a < b > c < d > e < f.

Example: Input: arr[] = {4, 3, 7, 8, 6, 2, 1} Output: arr[] = {3, 7, 4, 8, 2, 6, 1} Input: arr[] = {1, 4, 3, 2} Output: arr[] = {1, 4, 2, 3}

A **Simple Solution** 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). Time complexity is O(nlogn) since we need to sort the array first.

We can convert in O(n) time using an **Efficient Approach**. The idea is to use modified one pass of bubble sort. Maintain a flag for representing which order(i.e. < or >) currently we need. If the current two elements are not in that order then swap those elements otherwise not.

Let us see the main logic using three consecutive elements A, B, C. Suppose we are processing B and C currently and the current relation is ‘<'. But we have B > C. Since current relation is ‘<' previous relation must be '>‘ i.e., A must be greater than B. So, the relation is A > B and B > C. We can deduce A > C. So if we swap B and C then the relation is A > C and C < B. Finally we get the desired order **A C B**

Refer this for more explanation.

Below is C++ and Java implementation of above algorithm

## 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 > B < C 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; ` `} ` |

*chevron_right*

*filter_none*

## 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 > B < C 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)); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

## 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 > B < C ` ` ` `# 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 ` |

*chevron_right*

*filter_none*

Output:

3 7 4 8 2 6 1

Time complexity: O(n)

Auxiliary Space: O(1)

This article is contributed by **Siva Krishna Aleti**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

## Recommended Posts:

- Converting an array of integers into Zig-Zag fashion!
- Convert a String to Integer Array in C/C++
- Rearrange Odd and Even values in Alternate Fashion in Ascending Order
- Convert an array to reduced form | Set 2 (Using vector of pairs)
- Convert given array to Arithmetic Progression by adding an element
- Convert to Strictly increasing integer array with minimum changes
- Convert the array such that the GCD of the array becomes 1
- Program to convert a given number to words
- Count number of bits to be flipped to convert A to B
- Number of steps to convert to prime factors
- Find original array from encrypted array (An array of sums of other elements)
- Convert a given Binary Tree to Doubly Linked List | Set 3
- Convert a given Binary Tree to Doubly Linked List | Set 4
- Convert a BST to a Binary Tree such that sum of all greater keys is added to every key
- Convert a given Binary Tree to Doubly Linked List | Set 2