使用递归函数反转结构化数组

Question

So i got this struct

typedef struct Sarray{
  int *items;
  int size;
}Tarray;

Considering an array like [1][2][3][4][5]

i built a function like this

void ArrayReverse (Tarray *a){
    int tmp,i;
    if (a->size<=1)
        return;
    tmp=(a->items[0]);
    (a->items[0])=(a->items[a->size]);
    (a->items[a->size])=tmp;
    a->size=a->size-1;

    ArrayReverse(a+1);
}

The result is weird

0 2 3 4 5

The idea was to give the next address (a+1) so the a->items[0] would have been 2 in the second cycle. What's wrong how could i implement it ?

Answer 1

In these statements

(a->items[0])=(a->items[a->size]);
(a->items[a->size])=tmp;

you access memory beyond the allocated array because the valid upper index is a->size - 1 .

Instead of decreasing the data member size by one

a->size=a->size-1;

you have to decrease it by two.

a->size=a->size-2;

Moreover the function changes the values of data members size and items of the original object passed as an argument. So after exiting the function the state of the original object will be changed.

And this expression

a+1

does not make sense because you passed to the function a pointer to a single object of the type Tarray .

The function can look the following way as it is shown in the demonstrative program below.

#include <stdio.h>
#include <stdlib.h>

typedef struct Sarray
{
    int *items;
    size_t size;
} Tarray;

void ArrayReverse ( Tarray *t )
{
    if ( ! ( t->size < 2 ) )
    {
        int tmp = t->items[0];
        t->items[0] = t->items[t->size - 1];
        t->items[t->size - 1] = tmp;

        t->size -= 2;
        ++t->items;

        ArrayReverse( t );

        t->size += 2;
        --t->items;
    }
}

int main(void) 
{
    Tarray t = { 0 };
    size_t n = 5;

    t.items = malloc( n * sizeof( int ) );

    if ( t.items != NULL ) t.size = n;

    for ( size_t i = 0; i < t.size; i++ )
    {
        t.items[i] = ( int )( i + 1 );
    }

    ArrayReverse( &t );

    for ( size_t i = 0; i < t.size; i++ )
    {
        printf( "%d ", t.items[i] );
    }

    putchar( '\n' );

    free( t.items );

    return 0;
}

The program output is

5 4 3 2 1

Answer 2

The new version of the code is this one.

void ArrayReverse (Tarray *a,int i){
int tmp;
if(a->size <= a->lenght/2)
    return;
tmp=a->items[i];
a->items[i]=a->items[a->size-1];
a->items[a->size-1]=tmp;
a->size=a->size-1;
i++;
ArrayReverse(a,i);}

I changed the prototype of the function with the counter i.