通过将中间元素交替移动到开始和结束来重新排列数组

给定一个数组，任务是将中间元素交替移动到数组的开头和结尾，直到中间元素等于原始数组的第一个元素。

Input: arr[]=[2, 8, 5, 9, 10]
Output: [9, 5, 2, 10, 8]
Explanation: We can get this output by shifting middle element
step1: middle element 5 is shifted to front of array [5, 2, 8, 9, 10]
step2: middle element 8 is shifted to end of array [5, 2, 9, 10, 8]
step3: middle element 9 is shifted to front of array [9, 5, 2, 10, 8]

Input: arr[]=[10, 12, 6, 5, 3, 1]
Output: [1, 3, 5, 10, 6, 12]

朴素方法：将数组的中间元素交替移动到数组的开头和结尾。
如果 c 为偶数，则取中间元素并将其移至数组的开头；如果 c 为奇数，则将其移至数组的末尾。当中间元素等于原始数组的第一个元素时终止循环。

以下是上述方法的实现：

C++

// C++ program for above approach
#include 
using namespace std;
 
// Function for shifting middle element.
void AlternateShift(vector& arr, int x)
{
 
    // get middle index
    int mid = arr.size() / 2;
 
    // initialize c to 0
    int c = 0;
   
    // Shift middle element
    // till its value not equals to x.
    while (arr[mid] != x) {
 
        // pop middle element
 
        int z = arr[mid];
        arr.erase(arr.begin() + mid);
 
        // if c is even then insert z
        // at start of the array
        if (c % 2 == 0)
            arr.insert(arr.begin() + 0, z);
 
        // if c is odd then insert z
        // at end of the array
        else
            arr.push_back(z);
 
        // increment count c
        c += 1;
    }
}
 
int main()
{
    vector Arr = { 2, 8, 5, 9, 10 };
 
    // initialize a to zero index array value
    int a = Arr[0];
 
    // call AlternateShift function
    AlternateShift(Arr, a);
 
    // print the changed array Unpacking array
    for (int i = 0; i < Arr.size(); ++i) {
        cout << Arr[i] << " ";
    }
 
    return 0;
}
 
    // This code is contributed by rakeshsahni

Python3

# Function for shifting middle element.
def AlternateShift(arr, x):
 
    # get middle index
    mid = len(arr) // 2
 
    # initialize c to 0
    c = 0
 
    # Shift middle element
    # till its value not equals to x.
    while arr[mid] != x:
 
        # pop middle element
        z = arr.pop(mid)
 
        # if c is even then insert z
        # at start of the array
        if c % 2 == 0:
            arr.insert(0, z)
 
        # if c is odd then insert z
        # at end of the array
        else:
            arr.append(z)
 
        # increment count c
        c += 1
 
 
Arr = [2, 8, 5, 9, 10]
 
# initialize a to zero index array value
a = Arr[0]
 
# call AlternateShift function
AlternateShift(Arr, a)
 
# print the changed array Unpacking array
print(*Arr)

Javascript

    // JavaScript program for above approach
 
    // Function for shifting middle element.
    const AlternateShift = (arr, x) => {
 
        // get middle index
        let mid = parseInt(arr.length / 2);
 
        // initialize c to 0
        let c = 0;
 
        // Shift middle element
        // till its value not equals to x.
        while (arr[mid] != x) {
 
            // pop middle element
 
            let z = arr[mid];
            arr.splice(mid, 1);
 
            // if c is even then insert z
            // at start of the array
            if (c % 2 == 0)
                arr.splice(0, 0, z);
 
            // if c is odd then insert z
            // at end of the array
            else
                arr.push(z);
 
            // increment count c
            c += 1;
        }
    }
 
    Arr = [2, 8, 5, 9, 10];
 
    // initialize a to zero index array value
    let a = Arr[0];
 
    // call AlternateShift function
    AlternateShift(Arr, a);
 
    // print the changed array Unpacking array
 
    for (let i = 0; i < Arr.length; ++i) {
        document.write(`${Arr[i]} `);
    }
 
// This code is contributed by rakeshsahni
 

输出

9 5 2 10 8

时间复杂度： O(n ² )
辅助空间： O(1)

高效方法：交替移位也是阵列半反转的情况。如果 n 为偶数，则首先从 last 到 mid 取一个元素，或者从 last 到 mid 取一个元素并插入新数组 br[]，然后将第一个元素插入 br[]。然后将元素从 mid-1 插入到索引 1 并插入到 br[]。所以它将以半反转顺序返回数组。

算法 ：

step1: Declare new array br and initialize pos as n-1.
step2: If n is even traverse from last index pos or if n is odd then traverse from second last index pos-1.
step3: Store element from pos index to mid index into br array.
step4: Then insert first element of array to br array. 
step5: If n is odd then insert last value elementof array to br array.
step6: Store element from mid-1 index to index 1 into br array.
step7: return br array.

下面是上述算法的实现：

C++

// C++ Program of the above approach
#include 
using namespace std;
 
// Function to to shift the middle
// element to the start and end of
// the array alternatively, till
// the middle element becomes equal to
// the first element of the original Array
int* rearrange(int* ar, int n)
{
    // creating the array to store
    // rearranged value
    int* br = new int[n];
 
    // initialising pos to last index
    int pos = n - 1;
 
    // if n is odd then we will
    // transverse the array
    // from second last element
    if (n % 2 != 0)
        pos = pos - 1;
 
    // storing index of middle element
    int mid = n / 2;
 
    // index variable for rearranged array
    int c = 0;
 
    // transversing the array from
    // the pos to mid index
    // and storing it in br[] array
    for (; pos >= mid; pos--)
        br = ar[pos];
 
    // storing the first element as
    // mid value
    br = ar[0];
 
    // if n is odd then store
    // the last value in br[] the
    // transverse till 1st index
    if (n % 2 != 0)
        br = ar[n - 1];
 
    // storing the first element of
    // array as mid value
    for (; pos >= 1; pos--)
        br = ar[pos];
 
    // returning br[] array
    return br;
}
// Driver Code
int main()
{
    int ar[] = { 2, 8, 5, 9, 10 };
    int n = sizeof(ar) / sizeof(ar[0]);
 
    // Function Call
    int* res = rearrange(ar, n);
 
    // Print answer
    for (int i = 0; i < n; i++)
        cout << res[i] << " ";
}

Java

// Java Program of the above approach
import java.util.*;
 
class GFG
{
 
// Function to to shift the middle
// element to the start and end of
// the array alternatively, till
// the middle element becomes equal to
// the first element of the original Array
static int[] rearrange(int[] ar, int n)
{
   
    // creating the array to store
    // rearranged value
    int[] br = new int[n];
 
    // initialising pos to last index
    int pos = n - 1;
 
    // if n is odd then we will
    // transverse the array
    // from second last element
    if (n % 2 != 0)
        pos = pos - 1;
 
    // storing index of middle element
    int mid = n / 2;
 
    // index variable for rearranged array
    int c = 0;
 
    // transversing the array from
    // the pos to mid index
    // and storing it in br[] array
    for (; pos >= mid; pos--)
        br = ar[pos];
 
    // storing the first element as
    // mid value
    br = ar[0];
 
    // if n is odd then store
    // the last value in br[] the
    // transverse till 1st index
    if (n % 2 != 0)
        br = ar[n - 1];
 
    // storing the first element of
    // array as mid value
    for (; pos >= 1; pos--)
        br = ar[pos];
 
    // returning br[] array
    return br;
}
   
// Driver Code
public static void main(String[] args)
{
    int ar[] = { 2, 8, 5, 9, 10 };
    int n = ar.length;
 
    // Function Call
    int[] res = rearrange(ar, n);
 
    // Print answer
    for (int i = 0; i < n; i++)
        System.out.print(res[i]+ " ");
}
}
 
// This code is contributed by Amit Katiyar

Python3

# Python 3 Program of the above approach
 
# Function to to shift the middle
# element to the start and end of
# the array alternatively, till
# the middle element becomes equal to
# the first element of the original Array
def rearrange(ar, n):
    # creating the array to store
    # rearranged value
    br = [0 for i in range(n)]
 
    # initialising pos to last index
    pos = n - 1
 
    # if n is odd then we will
    # transverse the array
    # from second last element
    if (n % 2 != 0):
        pos = pos - 1
 
    # storing index of middle element
    mid = n // 2
 
    # index variable for rearranged array
    c = 0
 
    # transversing the array from
    # the pos to mid index
    # and storing it in br[] array
    while(pos >= mid):
        br = ar[pos]
        c += 1
        pos -= 1
 
    # storing the first element as
    # mid value
    br = ar[0]
    c += 1
 
    # if n is odd then store
    # the last value in br[] the
    # transverse till 1st index
    if (n % 2 != 0):
        br = ar[n - 1]
        c += 1
 
    # storing the first element of
    # array as mid value
    while(pos >= 1):
        br = ar[pos]
        c += 1
        pos -= 1
 
    # returning br[] array
    return br
 
# Driver Code
if __name__ == '__main__':
    ar = [2, 8, 5, 9, 10]
    n = len(ar)
 
    # Function Call
    res = rearrange(ar, n)
 
    # Print answer
    for i in range(n):
        print(res[i],end = " ")
         
        # This code is contributed by ipg2016107.

C＃

// C# Program of the above approach
using System;
 
public class GFG
{
 
// Function to to shift the middle
// element to the start and end of
// the array alternatively, till
// the middle element becomes equal to
// the first element of the original Array
static int[] rearrange(int[] ar, int n)
{
   
    // creating the array to store
    // rearranged value
    int[] br = new int[n];
 
    // initialising pos to last index
    int pos = n - 1;
 
    // if n is odd then we will
    // transverse the array
    // from second last element
    if (n % 2 != 0)
        pos = pos - 1;
 
    // storing index of middle element
    int mid = n / 2;
 
    // index variable for rearranged array
    int c = 0;
 
    // transversing the array from
    // the pos to mid index
    // and storing it in br[] array
    for (; pos >= mid; pos--)
        br = ar[pos];
 
    // storing the first element as
    // mid value
    br = ar[0];
 
    // if n is odd then store
    // the last value in br[] the
    // transverse till 1st index
    if (n % 2 != 0)
        br = ar[n - 1];
 
    // storing the first element of
    // array as mid value
    for (; pos >= 1; pos--)
        br = ar[pos];
 
    // returning br[] array
    return br;
}
   
// Driver Code
public static void Main(String[] args)
{
    int []ar = { 2, 8, 5, 9, 10 };
    int n = ar.Length;
 
    // Function Call
    int[] res = rearrange(ar, n);
 
    // Print answer
    for (int i = 0; i < n; i++)
        Console.Write(res[i]+ " ");
}
}
 
// This code is contributed by Amit Katiyar

Javascript

// javascript Program of the above approach
 
// Function to to shift the middle
// element to the start and end of
// the array alternatively, till
// the middle element becomes equal to
// the first element of the original Array
function rearrange(ar , n)
{
   
    // creating the array to store
    // rearranged value
    var br = Array.from({length: n}, (_, i) => 0);
 
    // initialising pos to last index
    var pos = n - 1;
 
    // if n is odd then we will
    // transverse the array
    // from second last element
    if (n % 2 != 0)
        pos = pos - 1;
 
    // storing index of middle element
    var mid = parseInt(n / 2);
 
    // index variable for rearranged array
    var c = 0;
 
    // transversing the array from
    // the pos to mid index
    // and storing it in br array
    for (; pos >= mid; pos--)
        br = ar[pos];
 
    // storing the first element as
    // mid value
    br = ar[0];
 
    // if n is odd then store
    // the last value in br the
    // transverse till 1st index
    if (n % 2 != 0)
        br = ar[n - 1];
 
    // storing the first element of
    // array as mid value
    for (; pos >= 1; pos--)
        br = ar[pos];
 
    // returning br array
    return br;
}
   
// Driver Code
    var ar = [ 2, 8, 5, 9, 10 ];
    var n = ar.length;
 
    // Function Call
    var res = rearrange(ar, n);
 
    // Print answer
    for (var i = 0; i < n; i++)
        document.write(res[i]+ " ");
 
// This code is contributed by Princi Singh

输出

9 5 2 10 8 

时间复杂度： O(n)
空间复杂度： O(n)