Shuffle 2n integers in format {a1, b1, a2, b2, a3, b3, ......, an, bn} without using extra space

Given an array of 2n elements in the following format { a1, a2, a3, a4, ….., an, b1, b2, b3, b4, …., bn }. The task is shuffle the array to {a1, b1, a2, b2, a3, b3, ……, an, bn } without using extra space.

Examples:

Input : arr[] = { 1, 2, 9, 15 }
Output : 1 9 2 15

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

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Method 1: Brute Force
A brute force solution involves two nested loops to rotate the elements in the second half of the array to the left. The first loop runs n times to cover all elements in the second half of the array. The second loop rotates the elements to the left. Note that the start index in the second loop depends on which element we are rotating and the end index depends on how many positions we need to move to the left.

Below is implementation of this approach:

C++

// C++ Naive program to shuffle an array of size 2n 
#include <bits/stdc++.h> 
using namespace std; 
  
// function to shuffle an array of size 2n 
void shuffleArray(int a[], int n) 
{ 
    // Rotate the element to the left 
    for (int i = 0, q = 1, k = n; i < n; i++, k++, q++)      
        for (int j = k; j > i + q; j--)  
            swap(a[j-1], a[j]); 
} 
  
// Driven Program 
int main() 
{ 
    int a[] = { 1, 3, 5, 7, 2, 4, 6, 8 }; 
    int n = sizeof(a) / sizeof(a[0]); 
  
    shuffleArray(a, n/2); 
  
    for (int i = 0; i < n; i++)  
        cout << a[i] << " "; 
  
    return 0; 
} 

Java

// Java Naive program to shuffle an array of size 2n 
  
import java.util.Arrays; 
  
public class GFG  
{ 
    // method to shuffle an array of size 2n 
    static void shuffleArray(int a[], int n) 
    { 
        // Rotate the element to the left 
        for (int i = 0, q = 1, k = n; i < n; i++, k++, q++)         
            for (int j = k; j > i + q; j--){ 
                // swap a[j-1], a[j] 
                int temp = a[j-1]; 
                a[j-1] = a[j]; 
                a[j] = temp; 
            }      
    } 
      
    // Driver Method 
    public static void main(String[] args) 
    { 
        int a[] = { 1, 3, 5, 7, 2, 4, 6, 8 }; 
       
        shuffleArray(a, a.length/2); 
          
        System.out.println(Arrays.toString(a)); 
    } 
} 

Python3

# Python3 Naive program to  
# shuffle an array of size 2n 
  
# Function to shuffle an array of size 2n 
def shuffleArray(a, n): 
  
    # Rotate the element to the left 
    i, q, k = 0, 1, n 
    while(i < n):      
        j = k  
        while(j > i + q): 
            a[j - 1], a[j] = a[j], a[j - 1] 
            j -= 1
        i += 1
        k += 1
        q += 1
  
# Driver Code 
a = [1, 3, 5, 7, 2, 4, 6, 8]  
n = len(a) 
shuffleArray(a, int(n / 2)) 
for i in range(0, n):  
    print(a[i], end = " ") 
  
# This code is contributed by Smitha Dinesh Semwal. 

C#

// C# Naive program to shuffle an  
// array of size 2n 
using System; 
  
class GFG  
{ 
// method to shuffle an array of size 2n 
static void shuffleArray(int[] a, int n) 
{ 
    // Rotate the element to the left 
    for (int i = 0, q = 1, k = n; 
             i < n; i++, k++, q++)      
        for (int j = k; j > i + q; j--) 
        { 
            // swap a[j-1], a[j] 
            int temp = a[j - 1]; 
            a[j - 1] = a[j]; 
            a[j] = temp; 
        }      
} 
  
// Driver Code 
public static void Main() 
{ 
    int []a = { 1, 3, 5, 7, 2, 4, 6, 8 }; 
  
    shuffleArray(a, a.Length / 2); 
    for(int i = 0; i < a.Length; i++) 
        Console.Write(a[i] + " "); 
} 
} 
  
// This code is contributed  
// by ChitraNayal 

Output:

1 2 3 4 5 6 7 8

Time Complexity: O(n²)

Method 2: (Divide and Conquer)
The idea is to use Divide and Conquer Technique. Divide the given array into half (say arr1[] and arr2[]) and swap second half element of arr1[] with first half element of arr2[]. Recursively do this for arr1 and arr2.

Let us explain with the help of an example.

Let the array be a1, a2, a3, a4, b1, b2, b3, b4
Split the array into two halves: a1, a2, a3, a4 : b1, b2, b3, b4
Exchange element around the center: exchange a3, a4 with b1, b2 correspondingly.
you get: a1, a2, b1, b2, a3, a4, b3, b4
Recursively spilt a1, a2, b1, b2 into a1, a2 : b1, b2
then split a3, a4, b3, b4 into a3, a4 : b3, b4.
Exchange elements around the center for each subarray we get:
a1, b1, a2, b2 and a3, b3, a4, b4.

Note: This solution only handles the case when n = 2ⁱ where i = 0, 1, 2, …etc.

Below is implementation of this approach:

C++

// C++ Effective  program to shuffle an array of size 2n 
  
#include <bits/stdc++.h> 
using namespace std; 
  
// function to shuffle an array of size 2n 
void shufleArray(int a[], int f, int l) 
{ 
    // If only 2 element, return 
    if (l - f == 1) 
        return; 
  
    // finding mid to divide the array 
    int mid = (f + l) / 2; 
  
    // using temp for swapping first half of second array 
    int temp = mid + 1; 
  
    // mmid is use for swapping second half for first array 
    int mmid = (f + mid) / 2; 
  
    // Swapping the element 
    for (int i = mmid + 1; i <= mid; i++) 
        swap(a[i], a[temp++]); 
  
    // Recursively doing for first half and second half 
    shufleArray(a, f, mid); 
    shufleArray(a, mid + 1, l); 
} 
  
// Driven Program 
int main() 
{ 
    int a[] = { 1, 3, 5, 7, 2, 4, 6, 8 }; 
    int n = sizeof(a) / sizeof(a[0]); 
  
    shufleArray(a, 0, n - 1); 
  
    for (int i = 0; i < n; i++) 
        cout << a[i] << " "; 
  
    return 0; 
} 

Java

// Java Effective  program to shuffle an array of size 2n 
  
import java.util.Arrays; 
  
public class GFG  
{ 
    // method to shuffle an array of size 2n 
    static void shufleArray(int a[], int f, int l) 
    { 
        // If only 2 element, return 
        if (l - f == 1) 
            return; 
       
        // finding mid to divide the array 
        int mid = (f + l) / 2; 
       
        // using temp for swapping first half of second array 
        int temp = mid + 1; 
       
        // mmid is use for swapping second half for first array 
        int mmid = (f + mid) / 2; 
       
        // Swapping the element 
        for (int i = mmid + 1; i <= mid; i++) 
        { 
            // swap a[i], a[temp++] 
            int temp1 = a[i]; 
            a[i] = a[temp]; 
            a[temp++] = temp1; 
        } 
       
        // Recursively doing for first half and second half 
        shufleArray(a, f, mid); 
        shufleArray(a, mid + 1, l); 
    } 
      
    // Driver Method 
    public static void main(String[] args) 
    { 
        int a[] = { 1, 3, 5, 7, 2, 4, 6, 8 }; 
       
        shufleArray(a, 0, a.length - 1); 
          
        System.out.println(Arrays.toString(a)); 
    } 
} 

Python3

# Python3 effective program to  
# shuffle an array of size 2n 
  
# Function to shuffle an array of size 2n 
def shufleArray(a, f, l): 
  
    # If only 2 element, return 
    if (l - f == 1): 
        return
  
    # Finding mid to divide the array 
    mid = int((f + l) / 2) 
  
    # Using temp for swapping first 
    # half of second array 
    temp = mid + 1
  
    # Mid is use for swapping second 
    # half for first array 
    mmid = int((f + mid) / 2) 
  
    # Swapping the element 
    for i in range(mmid + 1, mid + 1): 
        (a[i], a[temp]) = (a[temp], a[i]) 
        temp += 1
  
    # Recursively doing for first 
    # half and second half 
    shufleArray(a, f, mid) 
    shufleArray(a, mid + 1, l) 
  
  
# Driver Code 
a = [1, 3, 5, 7, 2, 4, 6, 8]  
n = len(a)  
shufleArray(a, 0, n - 1) 
  
for i in range(0, n): 
    print(a[i], end = " ") 
  
# This code is contributed by Smitha Dinesh Semwal 

C#

// C# program program to merge two  
// sorted arrays with O(1) extra space.  
using System; 
  
// method to shuffle an array of size 2n 
  
public class GFG  
{  
    // method to shuffle an array of size 2n  
    static void shufleArray(int []a, int f, int l)  
    {  
        // If only 2 element, return  
        if (l - f == 1)  
            return;  
      
        // finding mid to divide the array  
        int mid = (f + l) / 2;  
      
        // using temp for swapping first half of second array  
        int temp = mid + 1;  
      
        // mmid is use for swapping second half for first array  
        int mmid = (f + mid) / 2;  
      
        // Swapping the element  
        for (int i = mmid + 1; i <= mid; i++)  
        {  
            // swap a[i], a[temp++]  
            int temp1 = a[i];  
            a[i] = a[temp];  
            a[temp++] = temp1;  
        }  
      
        // Recursively doing for first half and second half  
        shufleArray(a, f, mid);  
        shufleArray(a, mid + 1, l);  
    }  
      
    // Driver Method  
    public static void Main()  
    {  
        int []a = { 1, 3, 5, 7, 2, 4, 6, 8 };  
      
        shufleArray(a, 0, a.Length - 1);  
        for(int i = 0; i<a.Length;i++) 
            Console.Write(a[i]+" ");  
    }  
}  
  
/*This code is contributed by 29AjayKumar*/

Output:

1 2 3 4 5 6 7 8

Time Complexity: O(n log n)

Linear time solution

This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes