递归地反转数组

Question

I am trying to recursively reverse the elements of an array. The only parameters I can have in the function is the array and the size. This is what I have done so far, but having trouble in swapping. How can i fix my output? For example when i enter 1 2 3 , the elements get reversed to 2 3 1

//Recursive function for Reversing array
void reverse_arr(int a[],int size){
    if(size ==0){
        return ;
    }
    else{
        int temp;
        int i= 0;
        temp = a[i];
        a[i]= a[size-1];
        a[size -1] = temp;
        reverse_arr(a, size-1);
    }      
}

int main() {
    int a[100];
    int size ;

    cout<<"Enter the size of the array: "<<endl;
    cin>>size;
    cout<<"Enter the elements of the array: "<<endl;
    for(int i = 0; i<size; i++){
        cin>>a[i]; }
    for(int i = 0; i<size; i++){

        cout<<a[i]<<"  ";}
    cout<<endl;
    reverse_arr(a, 3);
    for(int i = 0; i<size; i++){

        cout<<a[i]<<"  ";}
}

Answer 1

void Reverse(int a[], int size)
{
  if (size > 1)
  {
    // Swap the extreme elements
    int swap= a[0]; a[0]= a[size-1]; a[size-1]= swap;

    // Recurse on the subarray obtained by dropping the extreme elements
    Reverse(a+1, size-2);
  }
}

Answer 2

Always swapping the first and last elements doesn't do what you want. If your array is initially 1 2 3 4 5 , here's the sequence of swaps at each recursion step:

• swap 0 and 4 : 5 2 3 4 1
• swap 0 and 3 : 4 2 3 5 1
• swap 0 and 2 : 3 2 4 5 1
• swap 0 and 1 : 2 3 4 5 1

In a recursive algorithm, each recursive step is supposed to solve the same problem on a smaller set of data, and combine that with what we've done so far to get closer to the desired result. But swapping 1st and last is only correct if they're in the same order as the original, which isn't true after each of these steps.

After you swap the first and last elements of the array, you need to recurse on the middle of the array, not just the same array with size - 1 . So you need to call the function recursively on the array starting with the 2nd element, and subtract 2 from size .

The base case where you do nothing should be when size <= 1 , since a 1-element array is the same when you reverse it.

//Recursive function for Reversing array
void reverse_arr(int a[],int size){
    if(size <= 1 ){
        return ;
    }
    else{
        int temp;
        int i= 0;
        temp = a[i];
        a[i]= a[size-1];
        a[size -1] = temp;
        reverse_arr(&a[1], size-2);
    }
}

Answer 3

I will pass both the start and end index and use:

void reverseArray(int arr[], int start, int end) 
{
    if (start >= end)
    return;

    int temp = arr[start]; 
    arr[start] = arr[end];
    arr[end] = temp;

    // Recursive Function calling
    reverseArray(arr, start + 1, end - 1);  
}

The logic is simple, swap arr[start] with arr[end] then recursively call reverse for rest of the array.

If you want to do it with just passing the size:

void reverseArray(int a[],int size)
{
  if (size > 1)
  {    
    //swapping
    int temp = a[0]; 
    a[0]= a[size-1]; 
    a[size-1]= temp;

    reverseArray(a+1, size-2);
  }
}