C语言的反向数组

Question

It is an reverse array program, but the output of program is getting wrong its not reversing all numbers I have dry run this code but am not getting where the issue is?

#include <stdio.h>

void reverseArray(int ar[], int start, int end)
{
    while (start < end)
    {   ar[start] = ar[start] + ar[end];
        ar[end] = ar[start] - ar[end];
        ar[start] = ar[start] - ar[end];
        start += 1;
        end -= 1;
        reverseArray(ar, start, end);
    }
  
}

void main()
{
    int ar[5] = {1, 2, 3, 4, 5};
    reverseArray(ar, 0, 4);
    for (int i = 0; i < 5; i++)
    {
        printf("%d ", ar[i]);
    }
}

Output is: 5 2 3 4 1

What I found that control is getting inside while loop for 3 times but according to condition it should run the loop only for 2 times

Answer 1

You're mixing loop with recursion. Recursively, you reverse the subsection of your array and reverse it again with your loop. Only the outermost elements remain swapped.

By the way, swapping like this could be subject to overflows, resulting in undefined behaviour.

Answer 2

You don't need to add the function call at the end. If you want to add that, then you don't end to add the while loop ,because by calling the function you are making it recursive. Recursion and loops don't go well together .

Also, try not to pass Hard-coded values in parameters, It isn't a good practice:)

Answer 3

Due to having both a while loop and using recursive calls, your code is doing

reverseArray(ar, 0, 4)
    a[0] <-> a[4]  // swap
    reverseArray(ar, 1, 3)
        a[1] <-> a[3]  // swap
        reverseArray(ar, 2, 2)
    a[1] <-> a[3]  // swap
    reverseArray(ar, 2, 2)

so you swap element ar[1] and ar[3] twice, ie they end up in their original positions.

The solution seems simple: Just delete the recursive call.

Further:

Don't swap elements by "smart code" like:

    ar[start] = ar[start] + ar[end];
    ar[end] = ar[start] - ar[end];
    ar[start] = ar[start] - ar[end];

Write it simple and readable like:

    int tmp = ar[start];
    ar[start] = ar[end];
    ar[end] = tmp;

It's easier to read and understand, it's most likely faster and most important it avoids integer overflow (which is undefined behavior in C).

Answer 4

Let me tell you the issue.

Values when your program reaches the line

reverseArray(ar, start, end);
start = 1, end = 3, arr={5,2,3,4,1}

After this, your compiler goes into the function once again from where your array comes back completely reversed. But all this happen in some other while loop because you called the function once again. Hence when your compiler comes back from the function call. Remember, your values of start and end in the first while loop will still be

Start = 1, end = 3
**But**
Your array is now arr = {5,4,3,2,1}

Your while loop runs again and that is why your first and last element isn't disturbed while your rest of the array is disturbed in final output.

Answer 5

Already there are great answers provided by the experts..

I am trying to answer in my way.

Basically when reverseArray(ar, start, end); is called start=1,end=3

Recursively calling reverseArray(ar, start, end);

reversed your array and returned control when start=2 end=2

But your first while loop hasn't finished yet and undoing what you wanted to achieve.

Function call by value, by reference is playing the game here.

You are passing reference of arr but for start and end you are passing value.