# Zigzag Array in Java

In this tutorial, we discuss, what is zigzag array and its example. Even we will create the java program. In this program, we convert the simple array into a zigzag array.

## What is a Zigzag Array in Java?

Java has supported another type of array called a zigzag array. Zigzag array means a two-dimensional(2-D) array in which rows are already fixed and then different numbers of columns are fixed for each row.

``````int[][]a= new int[];
a= new int;
a= new int;
a= new int;
a= new int;
a= new int;
``````

If there are no three consecutive elements in either increasing or decreasingorder in an array, it is said to be a zigzag array. That is to say, if the array contains three elements (say, ai, ai+1, ai+2), The array is not in a zigzag pattern. Because ai ai+1 ai+2 or ai > ai+1 > ai+2.

As a result, the condition can be symbolically represented as follows:

a <b> c < b > c < d > f

The elements of the array are a, b, c, d, e, and f.

In a nutshell, array elements must alternately follow the less than (<) and greater than (>) orders. Every element has a larger or lesser value than its nearby.

There are two ways that can be used:

Method 1: A Simple Solution

1. To begin, shorten the array that has been provided.
2. The first element should be fixed.
3. Swap the remaining parts in pairs after that. It denotes that you should swap a and a, a and a, and so forth.

Because no more space is required, the complexity of the aforementioned solution will be O(n log n) and the complexity of space will be O(1).

Method 2: A Cost-Effective Solution

The second method is more efficient because it completes the bubble short in one pass. In O(n) time, it changes the array to a zigzag form.

We have to keep a flag that represents the order (fewer than (<) or larger than (>) in order to conduct the bubble short. If the two elements are not in that order, switch them; otherwise, don't.

### Algorithm:

1. Set the value of the flag to true.

2. From 0 to n-2, traverse the array (where n is the array's length).

1. If the flag is true
• Make surethe present element is larger than the one that comes after it.
• Change the settings.
2. Otherwise, see if the present element is larger than the one that comes after it.
• Check to see if the current element is smaller than the next.
• Change the settings.
3. Toggle the flag's value.

Let's have a look at an example.

Consider the array A, which consists of three elements: [5, 3, 1]. 5 > 3 > 1 in this case. It denotes the absence of a zigzag array. Assume we're dealing with 3 and 1, which equals 3 > 1. If we switch 3 and 1, the connection becomes 5 > 1 and 1 3, and we end up with the zigzag array [5, 1, 3].

### A Zigzag Array Example:

Zigzag arrays are A = [4, 2, 6, 3, 10, 1] and B = [8, 4, 6, 3, 5, 1, 10, 9]. Because there are no three consecutive array elements in either increasing or decreasing order.

The element a1 a2 a3 i.e. (2 3 6) in the array C = [5, 2, 3, 6, 1] is not a zigzag array. When the third element, 6, is removed, the array becomes [5, 2, 3, 1], a collection of a zigzag array. The following are examples of zigzag arrays:

### Zigzag Array in Java

Because the items (in red) do not follow the order, the following arrays aren’t zigzag at all.

Simple Array in Java

Convert Simple array into Zigzag Array:

Here's how to print an array in a Zigzag pattern. Assume you've been handed an array of integers and asked to sort them in a zig-zag manner. The first integer is fewer than the second integer, which is larger than the third integer, which is fewer than the fourth integer, and so on in a zig-zag pattern. As a result, the transformed array should look like this: e1 >e2 > e3 >e4 > e5 >e6.

Test cases:

Input 1:

7

4 3 7 8 6 2 1

Output 1:

3 7 4 8 2 6 1

Input 2:

4

1 4 3 2

Output 2:

1 4 2 3

Example:

``````import java.until.Arrays ;

Public class ZigZagArray
{
Public static void main(String[] args)
{
int a[] = new int;
int i, j , k;

Scanner in = new Scanner ( System.in ) ;

System.out.println( “ Enter 5 elements in array “ ) ;

for(i = 0 ; i< 5 ; i++)
{
a[i] = in.nextInt() ;
}

int[][] b = new int[] ;

for ( i = 0 ; i< 5 ; i++ )
{
b[i] = new int[a[i]];
for ( j = 0 ; j <a[i] ; j++ )
{
b[i][j] = k;
k++ ;
}
}

}
}

System.out.print( “ You Create Array “ ) ;

for ( i = 0 ; i< 5 ; i++ )
{
for ( j = 0 ; j < b[j].length ; j++ )
{
System.out.print( b[][]+”\t” ) ;
}
System.out.println( ) ;
}
``````

Output:

``````Enter 5 elements in an array
1
5
2
9
4
You Create Array 1
1       2       3        4        5
1 2
1       2       3         4        5         6        7        8        9
1       2       3         4
``````