Even numbers at even index and odd numbers at odd index

Last Updated : 17 May, 2026

Given an array arr[] containing equal number of odd and even numbers, arrange the numbers such that all even numbers are placed at even indices and odd numbers at odd indices.
Note: There are multiple possible solutions, print any one of them. Also, 0-based indexing is considered.

Examples : 

Input: arr[] = [3, 6, 12, 1, 5, 8]
Output: 1
Explanation: Place even numbers at even indices and odd at odd indices, One valid arrangement: 6 3 12 1 8 5.

Input: arr[] = [1, 2, 3, 4]
Output: 1
Explanation: Place even numbers at even indices and odd at odd indices, One valid arrangement: 2 1 4 3.

Try It Yourself
redirect icon

Table of Content

[Naive Approach] Using Separate Lists - O(n) Time O(n) Space

The idea is to store even and odd elements in separate lists, then fill the array by placing evens at even indices and odds at odd indices.

C++ 
#include <iostream>
#include <vector>
using namespace std;

void reArrange(vector<int> &arr)
{
    // Vectors to store even and odd numbers
    vector<int> even, odd;

    // Separate even and odd elements
    for (int i = 0; i < arr.size(); i++)
    {
        if (arr[i] % 2 == 0)
            even.push_back(arr[i]);
        else
            odd.push_back(arr[i]);
    }

    int e = 0, o = 0;

    // Fill array with correct positions
    for (int i = 0; i < arr.size(); i++)
    {
        // Place even numbers at even indices
        if (i % 2 == 0)
            arr[i] = even[e++];
            
        // Place odd numbers at odd indices
        else
            arr[i] = odd[o++];
    }
}

int main()
{
    vector<int> arr = {3, 6, 12, 1, 5, 8};

    reArrange(arr);

    for(int i=0; i<arr.size(); i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}
C 
#include <stdio.h>
#include <stdlib.h>

void reArrange(int *arr, int size)
{
    // Arrays to store even and odd numbers
    int *even = (int *)malloc(size * sizeof(int));
    int *odd = (int *)malloc(size * sizeof(int));
    int e = 0, o = 0;

    // Separate even and odd elements
    for (int i = 0; i < size; i++)
    {
        if (arr[i] % 2 == 0)
            even[e++] = arr[i];
        else
            odd[o++] = arr[i];
    }

    e = 0;
    o = 0;

    // Fill array with correct positions
    for (int i = 0; i < size; i++)
    {
        // Place even numbers at even indices
        if (i % 2 == 0)
            arr[i] = even[e++];
            
        // Place odd numbers at odd indices
        else
            arr[i] = odd[o++];
    }

    free(even);
    free(odd);
}

int main()
{
    int arr[] = {3, 6, 12, 1, 5, 8};
    int size = sizeof(arr) / sizeof(arr[0]);
    reArrange(arr, size);
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}
Java 
public class GfG {
    public static void reArrange(int[] arr) {
        
        // Arrays to store even and odd numbers
        int[] even = new int[arr.length];
        int[] odd = new int[arr.length];
        int e = 0, o = 0;

        // Separate even and odd elements
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 2 == 0)
                even[e++] = arr[i];
            else
                odd[o++] = arr[i];
        }

        // Fill array with correct positions
        for (int i = 0; i < arr.length; i++) {
            
            // Place even numbers at even indices
            if (i % 2 == 0)
                arr[i] = even[--e];
                
            // Place odd numbers at odd indices
            else
                arr[i] = odd[--o];
        }

        // Print the modified array
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void main(String[] args) {
        int[] arr = {3, 6, 12, 1, 5, 8};
        reArrange(arr);
    }
}
Python 
def reArrange(arr):
    
    # Lists to store even and odd numbers
    even = []
    odd = []
    
    # Separate even and odd elements
    for i in range(len(arr)):
        if arr[i] % 2 == 0:
            even.append(arr[i])
        else:
            odd.append(arr[i])
    
    e = 0
    o = 0
    
    # Fill array with correct positions
    for i in range(len(arr)):
        
        # Place even numbers at even indices
        if i % 2 == 0:
            arr[i] = even[e]
            e += 1
            
        # Place odd numbers at odd indices
        else:
            arr[i] = odd[o]
            o += 1

# Driver Code
if __name__ == "__main__":
    arr = [3, 6, 12, 1, 5, 8]
    
    reArrange(arr)
    
    print(arr)
C# 
using System;
using System.Collections.Generic;

public class GfG
{
    public static void reArrange(List<int> arr)
    {
        // Lists to store even and odd numbers
        List<int> even = new List<int>();
        List<int> odd = new List<int>();

        // Separate even and odd elements
        for (int i = 0; i < arr.Count; i++)
        {
            if (arr[i] % 2 == 0)
                even.Add(arr[i]);
            else
                odd.Add(arr[i]);
        }

        int e = 0, o = 0;

        // Fill array with correct positions
        for (int i = 0; i < arr.Count; i++)
        {
            // Place even numbers at even indices
            if (i % 2 == 0)
                arr[i] = even[e++];
            // Place odd numbers at odd indices
            else
                arr[i] = odd[o++];
        }
    }

    public static void Main()
    {
        List<int> arr = new List<int> {3, 6, 12, 1, 5, 8};
        reArrange(arr);
        Console.WriteLine(string.Join(", ", arr));
    }
}
JavaScript 
function reArrange(arr) {
    // Arrays to store even and odd numbers
    let even = [];
    let odd = [];

    // Separate even and odd elements
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] % 2 === 0)
            even.push(arr[i]);
        else
            odd.push(arr[i]);
    }

    let e = 0, o = 0;

    // Fill array with correct positions
    for (let i = 0; i < arr.length; i++) {
        
        // Place even numbers at even indices
        if (i % 2 === 0)
            arr[i] = even[e++];
            
        // Place odd numbers at odd indices
        else
            arr[i] = odd[o++];
    }

    // Print modified array
    console.log(arr);
}

// Driver Code
let arr = [3, 6, 12, 1, 5, 8];
reArrange(arr);

Output
1

Time complexity: O(n)
Auxiliary Space: O(n)

[Expected Approach] Using Two Pointer Swap - O(n) Time O(1) Space

The idea is to use two pointers for even and odd indices. If both positions have wrong elements, swap them to fix two positions in one step.

Let us understand with an example:
Input: arr = [3, 6, 12, 1, 5, 8]

  • Start: evenInd = 0, oddInd = 1, arr = [3, 6, 12, 1, 5, 8]
  • evenInd = 0 (3 is odd -> wrong), oddInd = 1 (6 is even -> wrong) -> swap -> [6, 3, 12, 1, 5, 8]
  • Move pointers -> evenInd = 4 (5 is odd -> wrong), oddInd = 5 (8 is even -> wrong) -> swap -> [6, 3, 12, 1, 8, 5]
  • Both pointers go out of range -> stop

Final Array: [6, 3, 12, 1, 8, 5], Output: 1

C++ 
#include <iostream>
#include <vector>
using namespace std;

void reArrange(vector<int> &arr)
{

    int n = arr.size();

    // Initialize pointers for even and odd indices
    int evenInd = 0, oddInd = 1;

    // Traverse until either pointer goes out of range
    while (true)
    {
        // Move even pointer if element is correctly placed
        while (evenInd < n && arr[evenInd] % 2 == 0)
            evenInd += 2;

        // Move odd pointer if element is correctly placed
        while (oddInd < n && arr[oddInd] % 2 == 1)
            oddInd += 2;

        // Swap misplaced elements
        if (evenInd < n && oddInd < n)
            swap(arr[evenInd], arr[oddInd]);
        else
            break;
    }
}

// Driver Code
int main()
{

    vector<int> arr = {3, 6, 12, 1, 5, 8};

    reArrange(arr);

    for(int i=0; i<arr.size(); i++) {
        cout << arr[i] << " ";
    }

    return 0;
}
C 
#include <stdio.h>

void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void reArrange(int arr[], int n)
{
    // Initialize pointers for even and odd indices
    int evenInd = 0, oddInd = 1;

    // Traverse until either pointer goes out of range
    while (1)
    {
        // Move even pointer if element is correctly placed
        while (evenInd < n && arr[evenInd] % 2 == 0)
            evenInd += 2;

        // Move odd pointer if element is correctly placed
        while (oddInd < n && arr[oddInd] % 2 == 1)
            oddInd += 2;

        // Swap misplaced elements
        if (evenInd < n && oddInd < n)
            swap(&arr[evenInd], &arr[oddInd]);
        else
            break;
    }
}

// Driver Code
int main()
{
    int arr[] = {3, 6, 12, 1, 5, 8};
    int n = sizeof(arr) / sizeof(arr[0]);

    reArrange(arr, n);

    printf("Rearranged array:\n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}
Java 
import java.util.Arrays;

public class GfG {
    static void swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    static void reArrange(int[] arr)
    {
        int n = arr.length;

        // Initialize pointers for even and odd indices
        int evenInd = 0, oddInd = 1;

        // Traverse until either pointer goes out of range
        while (true)
        {
            // Move even pointer if element is correctly placed
            while (evenInd < n && arr[evenInd] % 2 == 0)
                evenInd += 2;

            // Move odd pointer if element is correctly placed
            while (oddInd < n && arr[oddInd] % 2 == 1)
                oddInd += 2;

            // Swap misplaced elements
            if (evenInd < n && oddInd < n)
                swap(arr, evenInd, oddInd);
            else
                break;
        }
    }

    public static void main(String[] args)
    {
        int[] arr = {3, 6, 12, 1, 5, 8};

        reArrange(arr);

        System.out.println(Arrays.toString(arr));
    }
}
Python 
def reArrange(arr):
    n = len(arr)

    # Initialize pointers for even and odd indices
    evenInd = 0
    oddInd = 1

    # Traverse until either pointer goes out of range
    while True:
        
        # Move even pointer if element is correctly placed
        while evenInd < n and arr[evenInd] % 2 == 0:
            evenInd += 2

        # Move odd pointer if element is correctly placed
        while oddInd < n and arr[oddInd] % 2 == 1:
            oddInd += 2

        # if both pointers are within range, then swap
        if evenInd < n and oddInd < n:
            arr[evenInd], arr[oddInd] = arr[oddInd], arr[evenInd]
        else:
            break

# Driver Code
if __name__ == "__main__":
    arr = [3, 6, 12, 1, 5, 8]

    reArrange(arr)
    print(arr)
C# 
using System;

public class GfG
{
    static void Swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    static int reArrange(int[] arr)
    {
        int n = arr.Length;

        // Initialize pointers for even and odd indices
        int evenInd = 0, oddInd = 1;

        // Traverse until either pointer goes out of range
        while (true)
        {
            // Move even pointer if element is correctly placed
            while (evenInd < n && arr[evenInd] % 2 == 0)
                evenInd += 2;

            // Move odd pointer if element is correctly placed
            while (oddInd < n && arr[oddInd] % 2 == 1)
                oddInd += 2;

            // Swap misplaced elements
            if (evenInd < n && oddInd < n)
                Swap(arr, evenInd, oddInd);
            else
                break;
        }

        // Return 1 for successful rearrangement
        return 1;
    }

    static void Main()
    {
        int[] arr = {3, 6, 12, 1, 5, 8};

        int res = reArrange(arr);

        Console.WriteLine(res);
    }
}
JavaScript 
function reArrange(arr) {
    let n = arr.length;

    // Initialize pointers for even and odd indices
    let evenInd = 0;
    let oddInd = 1;

    // Traverse until either pointer goes out of range
    while (true) {

        // Move even pointer if element is correctly placed
        while (evenInd < n && arr[evenInd] % 2 === 0) {
            evenInd += 2;
        }

        // Move odd pointer if element is correctly placed
        while (oddInd < n && arr[oddInd] % 2 === 1) {
            oddInd += 2;
        }

        // if both pointers are within range, then swap
        if (evenInd < n && oddInd < n) {
            [arr[evenInd], arr[oddInd]] = [arr[oddInd], arr[evenInd]];
        } else {
            break;
        }
    }
}

// Driver Code
let arr = [3, 6, 12, 1, 5, 8];

reArrange(arr);
console.log(arr);

Output
1

Time complexity: O(n)
Auxiliary Space: O(1)

Comment
Article Tags:
DSA
Arrays
array-rearrange

Explore