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

Question

所以我得到了这个结构

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

考虑像 [1][2][3][4][5]

这样的数组

我构建了一个这样的函数

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);
}

结果很奇怪

0 2 3 4 5

我们的想法是给出下一个地址 (a+1)，这样 a->items[0] 在第二个循环中就会是 2。我怎么能实现它？

Answer 1

在这些陈述中

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

您访问的内存超出分配的数组，因为有效的上限索引是 a->size - 1。

而不是将数据成员 size 减一

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

你必须减少两倍。

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

此外，该函数更改作为参数传递的原始对象的数据成员 size 和 items 的值。所以退出函数后原对象的状态会发生变化

还有这个表达式

a+1

没有意义，因为您向函数传递了指向 Tarray.

类型的单个对象的指针

函数如下面的演示程序所示。

#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;
}

程序输出为

5 4 3 2 1

Answer 2

新版代码就是这个。

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 更改了函数的原型。

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

Reversing a structed array with a recursive function

c

arrays

reverse

struct

structure