Shuffle 2n integers as a1-b1-a2-b2-a3-b3-..bn without using extra space

We have an array of the form {a0, a1, a2….., an, b0, b1, b2, …..bn} and our task is to rearrange the same in theform given below by using O(1) space- 
{a0, b0, a1, b1, a2, b2………..an, bn} 

Examples:

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

Input : arr[] = {11, 13, 15, 12, 14, 16}
Output : {11, 12, 13, 14, 15, 16}

We have already discussed two approaches-  

• https://www.geeksforgeeks.org/shuffle-2n-integers-format-a1-b1-a2-b2-a3-b3-bn-without-using-extra-space/
• https://www.geeksforgeeks.org/shuffle-array-a1-b1-a2-b2-a3-b3-bn-without-using-extra-space/

As we can see we have to transform the array so there must be an even size array.To rearrange the array we will start from the middle of the array and each time we will shift 1 element of the second half to left at it’s desired position. This algorithm will take O(n^2).

Algorithm-  

1- Take the input array
2- If size is null or odd return
3- find the middle index of the array
4- While (midindex>0)
    set count = midindex and 
        swapindex = midindex
    while (count-->0){
      swap(swapindex+1, swapindedx)
      swapindex++
    }
    midindex--
5- End

Working-

array- 1 3 5 7 2 4 6 8
1st Loop- 1 2 3 5 7 4 6 8
2nd Loop- 1 2 3 4 5 7 6 8
3rd loop- 1 2 3 4 5 6 7 8

C++

// C++ program to shuffle an array in
// the form of a1, b1, a2, b2,...
#include<iostream>
using namespace std;

// function to rearrange the array
void rearrange(int arr[], int n)
{

    // if size is null or odd return because it
    // is not possible to rearrange
    if (arr == NULL || n % 2 == 1)
        return;

    // start from the middle index
    int currIdx = (n - 1) / 2;

    // each time we will set two elements from the
    // start to the valid position by swapping
    while (currIdx > 0)
    {
        int count = currIdx, swapIdx = currIdx;

        while (count-- > 0)
        {
            int temp = arr[swapIdx + 1];
            arr[swapIdx + 1] = arr[swapIdx];
            arr[swapIdx] = temp;
            swapIdx++;
        }

        currIdx--;
    }
}

// Driver Program
int main()
{
    int arr[] = {1, 3, 5, 2, 4, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    rearrange(arr, n);
    for (int i = 0; i < n; i++)
    cout << " " << arr[i];

}

// This code is contributed by Smitha Dinesh Semwal

Java

// Java program to shuffle an array in
// the form of a1, b1, a2, b2,...
import java.io.*;

class GFG {

  // function to rearrange the array
  public static void rearrange(int[] arr) {

    // if size is null or odd return because it
    // is not possible to rearrange
    if (arr == null || arr.length % 2 == 1)
      return;

    // start from the middle index
    int currIdx = (arr.length - 1) / 2;

    // each time we will set two elements from the
    // start to the valid position by swapping
    while (currIdx > 0) {
      int count = currIdx, swapIdx = currIdx;

      while (count-- > 0) {
        int temp = arr[swapIdx + 1];
        arr[swapIdx + 1] = arr[swapIdx];
        arr[swapIdx] = temp;
        swapIdx++;
      }
      currIdx--;
    }
  }

  public static void main(String[] args) {
    int arr[] = {1, 3, 5, 2, 4, 6};
    rearrange(arr);
    for (int i = 0; i < arr.length; i++)
      System.out.print(" " + arr[i]);
  }
}

Python3

# Python program to shuffle
# an array in the form
# of a1, b1, a2, b2,...

arr = [1, 3, 5, 2, 4, 6]

# function to
# rearrange the array
def rearrange(n) :

    global arr

    # if size is null or
    # odd return because
    # it is not possible
    # to rearrange
    if (n % 2 == 1) :
        return

    # start from the
    # middle index
    currIdx = int((n - 1) / 2)

    # each time we will set
    # two elements from the
    # start to the valid
    # position by swapping
    while (currIdx > 0) :

        count = currIdx
        swapIdx = currIdx

        while (count > 0) :

            temp = arr[swapIdx + 1]
            arr[swapIdx + 1] = arr[swapIdx]
            arr[swapIdx] = temp
            swapIdx = swapIdx + 1
            count = count - 1

        currIdx = currIdx - 1

# Driver Code
n = len(arr)
rearrange(n)
for i in range(0, n) :
    print ("{} " . format(arr[i]),
                        end = "")

# This code is contributed by
# Manish Shaw(manishshaw1)

C#

// C# program to shuffle an array in
// the form of a1, b1, a2, b2,...
using System;

class GFG {

    // function to rearrange the array
    public static void rearrange(int[] arr)
    {

        // if size is null or odd return
        // because it is not possible to
        // rearrange
        if (arr == null || arr.Length % 2 == 1)
            return;

        // start from the middle index
        int currIdx = (arr.Length - 1) / 2;

        // each time we will set two elements
        // from the start to the valid position
        // by swapping
        while (currIdx > 0) {
            int count = currIdx, swapIdx = currIdx;

            while (count-- > 0) {
                int temp = arr[swapIdx + 1];
                arr[swapIdx + 1] = arr[swapIdx];
                arr[swapIdx] = temp;
                swapIdx++;
            }

            currIdx--;
        }
    }

    // Driver Program
    public static void Main() {

        int []arr = {1, 3, 5, 2, 4, 6};

        rearrange(arr);

        for (int i = 0; i < arr.Length; i++)
            Console.Write(" " + arr[i]);
    }
}

// This code is contributed by vt_m.

PHP

<?php
// PHP program to shuffle
// an array in the form
// of a1, b1, a2, b2,...

// function to
// rearrange the array
function rearrange(&$arr, $n)
{
    // if size is null or
    // odd return because
    // it is not possible
    // to rearrange
    if ($arr == NULL ||
        $n % 2 == 1)
        return;

    // start from the
    // middle index
    $currIdx = intval(($n - 1) / 2);

    // each time we will set
    // two elements from the
    // start to the valid
    // position by swapping
    while ($currIdx > 0)
    {
        $count = $currIdx;
        $swapIdx = $currIdx;

        while ($count-- > 0)
        {
            $temp = $arr[$swapIdx + 1];
            $arr[$swapIdx + 1] = $arr[$swapIdx];
            $arr[$swapIdx] = $temp;
            $swapIdx++;
        }

        $currIdx--;
    }
}

// Driver Code
$arr = array(1, 3, 5, 2, 4, 6);
$n = count($arr);
rearrange($arr, $n);
for ($i = 0; $i < $n; $i++)
    echo ($arr[$i] . " ");

// This code is contributed by
// Manish Shaw(manishshaw1)
?>

Javascript

<script>

// JavaScript program to shuffle an array in
// the form of a1, b1, a2, b2,...

// Function to rearrange the array
function rearrange(arr, n)
{

    // If size is null or odd return because it
    // is not possible to rearrange
    if (arr == null || n % 2 == 1)
        return;

    // Start from the middle index
    let currIdx = Math.floor((n - 1) / 2);

    // Each time we will set two elements from the
    // start to the valid position by swapping
    while (currIdx > 0)
    {
        let count = currIdx, swapIdx = currIdx;

        while (count-- > 0)
        {
            let temp = arr[swapIdx + 1];
            arr[swapIdx + 1] = arr[swapIdx];
            arr[swapIdx] = temp;
            swapIdx++;
        }
        currIdx--;
    }
}

// Driver code
let arr = [ 1, 3, 5, 2, 4, 6 ];
let n = arr.length;

rearrange(arr, n);

for(let i = 0; i < n; i++)
    document.write(" " + arr[i]);

// This code is contributed by Surbhi Tyagi.

</script>

Output:

1 2 3 4 5 6

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

Efficient Approach:

Note: The assumption is that the largest value  in the array is INT_MAX/2 and consists of only positive integers

The algorithm utilizes bit manipulation techniques to rearrange an array [x1,x2,…,xn,y1,y2,…,yn]. 

It is based on the constraint that 1 <= nums[i] <= INT_MAX/2. 

1. The largest number in the array is 1000 which requires 10 bits in binary representation. 
2. Thus, two numbers can fit into a 32-bit binary representation without overwriting each other. 
3. The algorithm has two loops: the first loop groups the numbers into pairs [x1, y1], [x2, y2]… [xn,yn] and stores both numbers in one binary representation.
4.  The second loop places these pairs in their final positions. To get the two numbers out of the binary representation, the algorithm uses Bitwise AND and Right Shift.

Implementation:

The algorithm has two parts, loop 1 and loop 2. 

1. Loop 1 groups the numbers in the array into pairs [x1, y1], [x2, y2]… [xn,yn] by storing both xn and yn in one binary representation. 
2. Loop 2 then places these pairs in their final position in the array. 

To store two numbers in one binary representation, two pointers i and j are used.

 i starts from n and moves backwards to 0, while j starts from the end of the array and moves backwards to n.

Code:

C++

// C++ program to shuffle an array in
// the form of a1, b1, a2, b2,...
#include<bits/stdc++.h>
using namespace std;

// function to rearrange the array
void rearrange(int nums[], int n)
{
    n = n/2 ;
    for(int i = 0; i < n; i++){
        nums[i] = nums[i] << 16 ;
        nums[i] = nums[i] | nums[i+n] ;
    }

    int sixteen1s = pow(2, 16) - 1 ;
    int j = 2*n - 1 ;
    for(int i = n-1; i >= 0 ; i--){
        int y = nums[i] & sixteen1s ;
        int x = nums[i] >> 16 ;
        nums[j] = y ;
        j-- ;
        nums[j] = x ;
        j-- ;
    }


}

// Driver Program
int main()
{
    int arr[] = {1, 3, 5, 2, 4, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    rearrange(arr, n);
    for (int i = 0; i < n; i++)
    cout << " " << arr[i];

}

Java

// Java code
import java.util.Arrays;

class GFG {

  // function to rearrange the array
  static void rearrange(int[] nums, int n)
  {
    n = n / 2;
    for (int i = 0; i < n; i++) {
      int x = nums[i] << 16;
      nums[i] = x | nums[i + n];
    }

    int sixteen1s = (1 << 16) - 1;
    int j = 2 * n - 1;
    for (int i = n - 1; i >= 0; i--) {
      int y = nums[i] & sixteen1s;
      int x = nums[i] >> 16;
      nums[j] = y;
      j--;
      nums[j] = x;
      j--;
    }
  }

  // Driver Program
  public static void main(String[] args)
  {
    int[] arr = { 1, 3, 5, 2, 4, 6 };
    int n = arr.length;
    rearrange(arr, n);
    System.out.println(Arrays.toString(arr));
  }
}

Python3

# Python3 program to shuffle an array in
# the form of a1, b1, a2, b2,...

import math

# function to rearrange the array
def rearrange(nums, n):
    n = n//2
    for i in range(n):
        nums[i] = nums[i] << 16
        nums[i] = nums[i] | nums[i+n]

    sixteen1s = pow(2, 16) - 1
    j = 2*n - 1
    for i in range(n-1, -1, -1):
        y = nums[i] & sixteen1s
        x = nums[i] >> 16
        nums[j] = y
        j -= 1
        nums[j] = x
        j -= 1

# Driver Program
if __name__ == '__main__':
    arr = [1, 3, 5, 2, 4, 6]
    n = len(arr)
    rearrange(arr, n)
    for i in range(n):
        print(arr[i], end=" ")

C#

// C# program to shuffle an array in
// the form of a1, b1, a2, b2,...

using System;
using System.Collections.Generic;

class Gfg{
    // function to rearrange the array
    static void rearrange(int[] nums, int n)
    {
        n = n/2 ;
        for(int i = 0; i < n; i++){
            nums[i] = nums[i] << 16 ;
            nums[i] = nums[i] | nums[i+n] ;
        }

        int sixteen1s = (int)Math.Pow(2, 16) - 1 ;
        int j = 2*n - 1 ;
        for(int i = n-1; i >= 0 ; i--){
            int y = nums[i] & sixteen1s ;
            int x = nums[i] >> 16 ;
            nums[j] = y ;
            j-- ;
            nums[j] = x ;
            j-- ;
        }


    }

    // Driver Program
    public static void Main(String[] args)
    {
        int[] arr = {1, 3, 5, 2, 4, 6};
        int n = arr.Length;
        rearrange(arr, n);
        for (int i = 0; i < n; i++)
            Console.Write(" " + arr[i]);
    }
}

Javascript

// JavaScript program to shuffle an array in
// the form of a1, b1, a2, b2,...

// function to rearrange the array
function rearrange(nums, n) {
    n = Math.floor(n/2);
    for(let i = 0; i < n; i++){
        nums[i] = nums[i] << 16;
        nums[i] = nums[i] | nums[i+n];
    }

    let sixteen1s = Math.pow(2, 16) - 1;
    let j = 2*n - 1;
    for(let i = n-1; i >= 0 ; i--)
    {
        let y = nums[i] & sixteen1s;
        let x = nums[i] >> 16;
        nums[j] = y;
        j--;
        nums[j] = x;
        j--;
    }
}

// Driver Program
let arr = [1, 3, 5, 2, 4, 6];
let n = arr.length;
rearrange(arr, n);
for (let i = 0; i < n; i++)
console.log(arr[i]);

Output

 1 2 3 4 5 6

Complexity Analysis

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