# Rearrange array by interchanging positions of even and odd elements in the given array

• Difficulty Level : Basic
• Last Updated : 02 Mar, 2022

Given an array arr[] of N positive integers with an equal number of even and odd elements. The task is to use in-place swapping to interchange positions of even and odd elements in the array.

Examples:

Input: arr[] = {1, 3, 2, 4}
Output: 2 4 1 3
Explanation:
Before rearranging the given array, indices 0 and 1 had odd elements and indices 2 and 3 had even elements.
After rearrangement, array becomes {2, 4, 1, 3} where indices 0 and 1 have even elements and indices 2 and 3 have odd elements.

Input: arr[] = {2, 2, 1, 3}
Output: 1 3 2 2
Explanation:
Before rearranging the given array, indices 0 and 1 had even elements and indices 2 and 3 had odd elements.
After rearrangement, array becomes {1, 3, 2, 2} where indices 0 and 1 have odd elements and indices 2 and 3 have even elements.

Naive Approach: The simplest approach is to iterate over array elements using two loops, the outer loop picks each element of the array and the inner loop is to find the opposite parity element for the picked element and swap them. After swapping elements, mark the picked element as negative so as not to pick it again. Finally, make all elements positive and print the array.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include``using` `namespace` `std;` `// Function to replace each even``// element by odd and vice-versa``// in a given array``void` `replace(``int` `arr[], ``int` `n)``{``    ` `    ``// Traverse array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``for``(``int` `j = i + 1; j < n; j++)``        ``{``            ` `            ``// If current element is even``            ``// then swap it with odd``            ``if` `(arr[i] >= 0 && arr[j] >= 0 &&``                ``arr[i] % 2 == 0 &&``                ``arr[j] % 2 != 0)``            ``{``                ` `                ``// Perform Swap``                ``int` `tmp = arr[i];``                ``arr[i] = arr[j];``                ``arr[j] = tmp;` `                ``// Change the sign``                ``arr[j] = -arr[j];` `                ``break``;``            ``}` `            ``// If current element is odd``            ``// then swap it with even``            ``else` `if` `(arr[i] >= 0 && arr[j] >= 0 &&``                     ``arr[i] % 2 != 0 &&``                     ``arr[j] % 2 == 0)``            ``{``                ` `                ``// Perform Swap``                ``int` `tmp = arr[i];``                ``arr[i] = arr[j];``                ``arr[j] = tmp;` `                ``// Change the sign``                ``arr[j] = -arr[j];` `                ``break``;``            ``}``        ``}``    ``}` `    ``// Marked element positive``    ``for``(``int` `i = 0; i < n; i++)``        ``arr[i] = ``abs``(arr[i]);` `    ``// Print final array``    ``for``(``int` `i = 0; i < n; i++)``         ``cout << arr[i] << ``" "``;``}` `// Driver Code``int` `main()``{``    ` `    ``// Given array arr[]``    ``int` `arr[] = { 1, 3, 2, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ` `    ``// Function Call``    ``replace(arr,n);``}` `// This code is contributed by SURENDRA_GANGWAR`

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.lang.*;` `class` `GFG {` `    ``// Function to replace each even``    ``// element by odd and vice-versa``    ``// in a given array``    ``static` `void` `replace(``int``[] arr)``    ``{``        ``// Stores length of array``        ``int` `n = arr.length;` `        ``// Traverse array``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``for` `(``int` `j = i + ``1``; j < n; j++) {` `                ``// If current element is even``                ``// then swap it with odd``                ``if` `(arr[i] >= ``0``                    ``&& arr[j] >= ``0``                    ``&& arr[i] % ``2` `== ``0``                    ``&& arr[j] % ``2` `!= ``0``) {` `                    ``// Perform Swap``                    ``int` `tmp = arr[i];``                    ``arr[i] = arr[j];``                    ``arr[j] = tmp;` `                    ``// Change the sign``                    ``arr[j] = -arr[j];` `                    ``break``;``                ``}` `                ``// If current element is odd``                ``// then swap it with even``                ``else` `if` `(arr[i] >= ``0``                         ``&& arr[j] >= ``0``                         ``&& arr[i] % ``2` `!= ``0``                         ``&& arr[j] % ``2` `== ``0``) {` `                    ``// Perform Swap``                    ``int` `tmp = arr[i];``                    ``arr[i] = arr[j];``                    ``arr[j] = tmp;` `                    ``// Change the sign``                    ``arr[j] = -arr[j];` `                    ``break``;``                ``}``            ``}``        ``}` `        ``// Marked element positive``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``arr[i] = Math.abs(arr[i]);` `        ``// Print final array``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``System.out.print(arr[i] + ``" "``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given array arr[]``        ``int``[] arr = { ``1``, ``3``, ``2``, ``4` `};` `        ``// Function Call``        ``replace(arr);``    ``}``}`

## Python3

 `# Python3 program for the``# above approach` `# Function to replace each even``# element by odd and vice-versa``# in a given array``def` `replace(arr,  n):` `    ``# Traverse array``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(i ``+` `1``, n):` `            ``# If current element is``            ``# even then swap it with odd``            ``if` `(arr[i] >``=` `0` `and``                ``arr[j] >``=` `0` `and``                ``arr[i] ``%` `2` `=``=` `0` `and``                ``arr[j] ``%` `2` `!``=` `0``):` `                ``# Perform Swap``                ``tmp ``=` `arr[i]``                ``arr[i] ``=` `arr[j]``                ``arr[j] ``=` `tmp` `                ``# Change the sign``                ``arr[j] ``=` `-``arr[j]` `                ``break` `            ``# If current element is odd``            ``# then swap it with even``            ``elif` `(arr[i] >``=` `0` `and``                  ``arr[j] >``=` `0` `and``                  ``arr[i] ``%` `2` `!``=` `0` `and``                  ``arr[j] ``%` `2` `=``=` `0``):` `                ``# Perform Swap``                ``tmp ``=` `arr[i]``                ``arr[i] ``=` `arr[j]``                ``arr[j] ``=` `tmp` `                ``# Change the sign``                ``arr[j] ``=` `-``arr[j]` `                ``break` `    ``# Marked element positive``    ``for` `i ``in` `range``(n):``        ``arr[i] ``=` `abs``(arr[i])` `    ``# Print final array``    ``for` `i ``in` `range``(n):``        ``print``(arr[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``# Given array arr[]``    ``arr ``=` `[``1``, ``3``, ``2``, ``4``]``    ``n ``=` `len``(arr)` `    ``# Function Call``    ``replace(arr, n)` `# This code is contributed by Chitranayal`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// Function to replace each even``// element by odd and vice-versa``// in a given array``static` `void` `replace(``int``[] arr)``{``    ` `    ``// Stores length of array``    ``int` `n = arr.Length;` `    ``// Traverse array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``for``(``int` `j = i + 1; j < n; j++)``        ``{``            ` `            ``// If current element is even``            ``// then swap it with odd``            ``if` `(arr[i] >= 0 &&``                ``arr[j] >= 0 &&``                ``arr[i] % 2 == 0 &&``                ``arr[j] % 2 != 0)``            ``{``                ` `                ``// Perform Swap``                ``int` `tmp = arr[i];``                ``arr[i] = arr[j];``                ``arr[j] = tmp;``                ` `                ``// Change the sign``                ``arr[j] = -arr[j];` `                ``break``;``            ``}` `            ``// If current element is odd``            ``// then swap it with even``            ``else` `if` `(arr[i] >= 0 &&``                     ``arr[j] >= 0 &&``                     ``arr[i] % 2 != 0 &&``                     ``arr[j] % 2 == 0)``            ``{``                ` `                ``// Perform Swap``                ``int` `tmp = arr[i];``                ``arr[i] = arr[j];``                ``arr[j] = tmp;``                ` `                ``// Change the sign``                ``arr[j] = -arr[j];` `                ``break``;``            ``}``        ``}``    ``}` `    ``// Marked element positive``    ``for``(``int` `i = 0; i < n; i++)``        ``arr[i] = Math.Abs(arr[i]);` `    ``// Print readonly array``    ``for``(``int` `i = 0; i < n; i++)``        ``Console.Write(arr[i] + ``" "``);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given array []arr``    ``int``[] arr = { 1, 3, 2, 4 };` `    ``// Function Call``    ``replace(arr);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`2 4 1 3 `

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use Two Pointer Approach. Traverse the array by picking each element that is greater than 0 and search for the opposite parity element greater than 0 from the current index up to the end of the array. If found, swap the elements and multiply them with -1. Follow the below steps to solve the problem:

• Initialize the variables e and o with -1 that will store the currently found even and odd number respectively that is not yet taken.
• Traverse the given array over the range [0, N – 1] and do the following:
• Pick the element arr[i] if it is greater than 0.
• If arr[i] is even, increment o + 1 by 1 and find the next odd number that is not yet marked is found. Mark the current and the found number by multiplying them with -1 and swap them.
• If arr[i] is odd, increment e + 1 by 1 and find the next even number that is not yet marked is found. Mark the current and the found number by multiplying them with -1 and swap them.
• After traversing the whole array, multiply its elements with -1 to again make them positive and print that array.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;``#define N 3``#define M 4` `// Function to replace odd elements``// with even elements and vice versa``void` `swapEvenOdd(``int` `arr[], ``int` `n)``{``    ``int` `o = -1, e = -1;` `    ``// Traverse the given array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// If arr[i] is visited``        ``if` `(arr[i] < 0)``            ``continue``;` `        ``int` `r = -1;` `        ``if` `(arr[i] % 2 == 0)``        ``{``            ``o++;``            ` `            ``// Find the next odd element``            ``while` `(arr[o] % 2 == 0 || arr[o] < 0)``                ``o++;``                ` `            ``r = o;``        ``}``        ``else``        ``{``            ``e++;``            ` `            ``// Find next even element``            ``while` `(arr[e] % 2 == 1 || arr[e] < 0)``                ``e++;``                ` `            ``r = e;``        ``}` `        ``// Mark them visited``        ``arr[i] *= -1;``        ``arr[r] *= -1;` `        ``// Swap them``        ``int` `tmp = arr[i];``        ``arr[i] = arr[r];``        ``arr[r] = tmp;``    ``}` `    ``// Print the final array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``cout << (-1 * arr[i]) << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ` `    ``// Given array arr[]``    ``int` `arr[] = { 1, 3, 2, 4 };``    ` `    ``// Length of the array``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ` `    ``// Function Call``    ``swapEvenOdd(arr, n);``}` `// This code is contributed by Rajput-Ji`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `GFG {` `    ``// Function to replace odd elements``    ``// with even elements and vice versa``    ``static` `void` `swapEvenOdd(``int` `arr[])``    ``{``        ``// Length of the array``        ``int` `n = arr.length;` `        ``int` `o = -``1``, e = -``1``;` `        ``// Traverse the given array``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// If arr[i] is visited``            ``if` `(arr[i] < ``0``)``                ``continue``;` `            ``int` `r = -``1``;` `            ``if` `(arr[i] % ``2` `== ``0``) {``                ``o++;` `                ``// Find the next odd element``                ``while` `(arr[o] % ``2` `== ``0``                       ``|| arr[o] < ``0``)``                    ``o++;``                ``r = o;``            ``}``            ``else` `{``                ``e++;` `                ``// Find next even element``                ``while` `(arr[e] % ``2` `== ``1``                       ``|| arr[e] < ``0``)``                    ``e++;``                ``r = e;``            ``}` `            ``// Mark them visited``            ``arr[i] *= -``1``;``            ``arr[r] *= -``1``;` `            ``// Swap them``            ``int` `tmp = arr[i];``            ``arr[i] = arr[r];``            ``arr[r] = tmp;``        ``}` `        ``// Print the final array``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``System.out.print(``                ``(-``1` `* arr[i]) + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given array arr[]``        ``int` `arr[] = { ``1``, ``3``, ``2``, ``4` `};` `        ``// Function Call``        ``swapEvenOdd(arr);``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Function to replace odd elements``# with even elements and vice versa``def` `swapEvenOdd(arr):``    ` `    ``# Length of the array``    ``n ``=` `len``(arr)` `    ``o ``=` `-``1``    ``e ``=` `-``1` `    ``# Traverse the given array``    ``for` `i ``in` `range``(n):``        ` `        ``# If arr[i] is visited``        ``if` `(arr[i] < ``0``):``            ``continue` `        ``r ``=` `-``1` `        ``if` `(arr[i] ``%` `2` `=``=` `0``):``            ``o ``+``=` `1` `            ``# Find the next odd element``            ``while` `(arr[o] ``%` `2` `=``=` `0` `or``                   ``arr[o] < ``0``):``                ``o ``+``=` `1``                ` `            ``r ``=` `o``        ``else``:``            ``e ``+``=` `1` `            ``# Find next even element``            ``while` `(arr[e] ``%` `2` `=``=` `1` `or``                   ``arr[e] < ``0``):``                ``e ``+``=` `1``                ` `            ``r ``=` `e` `        ``# Mark them visited``        ``arr[i] ``*``=` `-``1``        ``arr[r] ``*``=` `-``1` `        ``# Swap them``        ``tmp ``=` `arr[i]``        ``arr[i] ``=` `arr[r]``        ``arr[r] ``=` `tmp` `    ``# Print the final array``    ``for` `i ``in` `range``(n):``        ``print``((``-``1` `*` `arr[i]), end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given array arr``    ``arr ``=` `[ ``1``, ``3``, ``2``, ``4` `]` `    ``# Function Call``    ``swapEvenOdd(arr)` `# This code is contributed by Amit Katiyar`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to replace odd elements``// with even elements and vice versa``static` `void` `swapEvenOdd(``int` `[]arr)``{``    ` `    ``// Length of the array``    ``int` `n = arr.Length;` `    ``int` `o = -1, e = -1;` `    ``// Traverse the given array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// If arr[i] is visited``        ``if` `(arr[i] < 0)``            ``continue``;` `        ``int` `r = -1;` `        ``if` `(arr[i] % 2 == 0)``        ``{``            ``o++;``            ` `            ``// Find the next odd element``            ``while` `(arr[o] % 2 == 0 ||``                   ``arr[o] < 0)``                ``o++;``                ` `            ``r = o;``        ``}``        ``else``        ``{``            ``e++;` `            ``// Find next even element``            ``while` `(arr[e] % 2 == 1 ||``                   ``arr[e] < 0)``                ``e++;``                ` `            ``r = e;``        ``}` `        ``// Mark them visited``        ``arr[i] *= -1;``        ``arr[r] *= -1;` `        ``// Swap them``        ``int` `tmp = arr[i];``        ``arr[i] = arr[r];``        ``arr[r] = tmp;``    ``}` `    ``// Print the readonly array``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``Console.Write((-1 * arr[i]) + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given array []arr``    ``int` `[]arr = { 1, 3, 2, 4 };` `    ``// Function Call``    ``swapEvenOdd(arr);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output

`2 4 1 3 `

Time Complexity: O(N)
Auxiliary Space: O(N)

Efficient Approach 2 :

Another way to do this would be by using a stack. Follow the below steps:

1. Take element at index from the array arr[] and push to a stack
2. Iterate arr[] from index i = 1 to end and do the following:
1. If arr[i] and item on top of the stack are not both even or not both odd, pop and swap
2. Else push item to stack

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to replace odd elements``// with even elements and vice versa``void` `swapEvenOdd(``int` `arr[], ``int` `N)``{``  ``stack > stack;` `  ``// Push the first element to stack``  ``stack.push({ 0, arr });` `  ``// iterate the array and swap even and odd``  ``for` `(``int` `i = 1; i < N; i++)``  ``{``    ``if` `(!stack.empty())``    ``{``      ``if` `(arr[i] % 2 != stack.top().second % 2)``      ``{` `        ``// pop and swap``        ``pair<``int``, ``int``> pop = stack.top();``        ``stack.pop();` `        ``int` `index = pop.first, val = pop.second;``        ``arr[index] = arr[i];``        ``arr[i] = val;``      ``}``      ``else``        ``stack.push({ i, arr[i] });``    ``}``    ``else``      ``stack.push({ i, arr[i] });``  ``}` `  ``// print the arr[]``  ``for` `(``int` `i = 0; i < N; i++)``    ``cout << arr[i] << ``" "``;``}` `// Driven Program``int` `main()``{` `  ``// Given array arr[]``  ``int` `arr[] = { 1, 3, 2, 4 };` `  ``// Stores the length of array``  ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `  ``// Function Call``  ``swapEvenOdd(arr, N);``  ``return` `0;``}` `// This code is contributed by Kingash.`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG {` `  ``// Function to replace odd elements``  ``// with even elements and vice versa``  ``static` `void` `swapEvenOdd(``int` `arr[], ``int` `N)``  ``{` `    ``Stack<``int``[]> stack = ``new` `Stack<>();` `    ``// Push the first element to stack``    ``stack.push(``new` `int``[] { ``0``, arr[``0``] });` `    ``// iterate the array and swap even and odd``    ``for` `(``int` `i = ``1``; i < N; i++)``    ``{``      ``if` `(!stack.isEmpty())``      ``{``        ``if` `(arr[i] % ``2` `!= stack.peek()[``1``] % ``2``)``        ``{` `          ``// pop and swap``          ``int` `pop[] = stack.pop();``          ``int` `index = pop[``0``], val = pop[``1``];``          ``arr[index] = arr[i];``          ``arr[i] = val;``        ``}``        ``else``          ``stack.push(``new` `int``[] { i, arr[i] });``      ``}``      ``else``        ``stack.push(``new` `int``[] { i, arr[i] });``    ``}` `    ``// print the arr[]``    ``for` `(``int` `i = ``0``; i < N; i++)``      ``System.out.print(arr[i] + ``" "``);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``// Given array arr``    ``int` `arr[] = { ``1``, ``3``, ``2``, ``4` `};` `    ``// length of the arr``    ``int` `N = arr.length;` `    ``// Function Call``    ``swapEvenOdd(arr, N);``  ``}``}` `// This code is contributed by Kingash.`

## Python3

 `# Python3 program for the above approach` `# Function to replace odd elements``# with even elements and vice versa``def` `swapEvenOdd(arr):``    ``stack ``=` `[]``    ` `    ``# Push the first element to stack``    ``stack.append((``0``, arr[``0``],))``    ` `    ``# iterate the array and swap even and odd``    ``for` `i ``in` `range``(``1``, ``len``(arr)):``        ``if` `stack:``            ``if` `arr[i]``%``2` `!``=` `stack[``-``1``][``1``]``%``2``:``                ``#pop and swap``                ``index, val ``=` `stack.pop(``-``1``)``                ``arr[index] ``=` `arr[i]``                ``arr[i] ``=` `val``            ``else``:``                ``stack.append((i, arr[i],))``        ``else``:``            ``stack.append((i, arr[i],))``    ``return` `arr` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given array arr``    ``arr ``=` `[ ``1``, ``3``, ``2``, ``4` `]` `    ``# Function Call``    ``print``(swapEvenOdd(arr))` `# This code is contributed by Arunabha Choudhury`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``public` `class` `GFG``{` `  ``// Function to replace odd elements``  ``// with even elements and vice versa``  ``static` `void` `swapEvenOdd(``int` `[]arr, ``int` `N) {` `    ``Stack<``int``[]> stack = ``new` `Stack<``int``[]>();` `    ``// Push the first element to stack``    ``stack.Push(``new` `int``[] { 0, arr });` `    ``// iterate the array and swap even and odd``    ``for` `(``int` `i = 1; i < N; i++)``    ``{``      ``if` `(stack.Count != 0)``      ``{``        ``if` `(arr[i] % 2 != stack.Peek() % 2)``        ``{` `          ``// pop and swap``          ``int` `[]pop = stack.Pop();``          ``int` `index = pop, val = pop;``          ``arr[index] = arr[i];``          ``arr[i] = val;``        ``}``        ``else``          ``stack.Push(``new` `int``[] { i, arr[i] });``      ``}``      ``else``        ``stack.Push(``new` `int``[] { i, arr[i] });``    ``}` `    ``// print the []arr``    ``for` `(``int` `i = 0; i < N; i++)``      ``Console.Write(arr[i] + ``" "``);``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``// Given array arr``    ``int` `[]arr = { 1, 3, 2, 4 };` `    ``// length of the arr``    ``int` `N = arr.Length;` `    ``// Function Call``    ``swapEvenOdd(arr, N);``  ``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``

Output

`[4, 2, 3, 1]`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up