GeeksforGeeks App
Open App
Browser
Continue

# 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)

My Personal Notes arrow_drop_up