如何反转数组并将反转数组的值存储在新数组中答案

【问题标题】：How to reverse an array and store the values of the reversed array in a new array如何反转数组并将反转数组的值存储在新数组中
【发布时间】：2020-08-06 01:53:25
【问题描述】：

我的程序需要做以下事情：

反转一个数组（例如niz[] = { 2, 4, 5, 7, 4, 8, 3 }需要变成niz[] = { 3, 8, 4, 7, 5, 4, 2 }
将反转数组的值存储到一个全新的数组中
所有这些都必须在不使用 printf 的情况下完成，该函数将数组反转并将值存储到新数组中。此外，需要预定义数组及其大小（因此无需用户输入）。
需要在main 中打印结果（在这种情况下是包含前一个数组反转值的新数组）

但是，不是反转数组并将其存储到新数组中并返回它。该程序总是打印以下数字：

那么有人在我的代码中看到了问题吗？

int koko(int *array, int *array2, int c, int d) {
    for (c = 6; c > -1; c--, d++) {
        array2[d] = array[c];
    }
    return array2;
}

int main() {
    int niz[] = { 2, 4, 5, 7, 4, 8, 3 };
    int niz2[7];
    int a, b, c;
    c = koko(niz, niz2, a, b);
    printf("%d", c);
}

【问题讨论】：

您正在传入（并使用）未分配值的 b。
虽然不是问题的原因，但您也不必要地传入了a，并且从未真正使用传入的值（尽管a 无论如何都未初始化）。
除了您传入未分配的变量这一事实。在你的koko 函数中，为什么不在函数内部声明int c 和int d？这将减少传入的参数数量并使代码更具可读性。

标签： c arrays reverse function-definition

【解决方案1】：

因为你使用新数组作为koko函数的参数，所以你不需要返回它。如果要退货，请将退货类型从int改为int *。

在koko 函数中，d 必须始终以0 开头，因此您无需将其声明为该函数的参数。让我们在这个函数中将它声明为局部变量。

c是for循环的迭代器之一，所以让我们在这个函数中声明它，初始值等于size - 1（size是数组的大小或这个数组的元素个数） .

顺便说一句，这个函数变成如下：

void koko(int *array,int *array2,int size)
{
    int d = 0;
    int c;
    for(c = size - 1;c>-1;c--,d++)
    {
        array2[d]=array[c];
    }
}

要在main中使用这个函数，你只需要给出两个数组和数组的大小（在这种情况下是7）：

 koko(niz,niz2,7);

完整的测试代码：

#include <stdio.h>

void koko(int *array,int *array2,int size)
{
    int d = 0;
    int c;
    for(c = size - 1;c>-1;c--,d++)
    {
        array2[d]=array[c];
    }
}

int main()
{
    int niz[]={2, 4, 5, 7, 4, 8, 3};
    int niz2[7];
    koko(niz,niz2,7);
    for(int i = 0; i <7; i++)
        printf("%d ",niz2[i]);
}

输出：

3 8 4 7 5 4 2

【讨论】：

为什么我有 2 票反对？投票者愿意解释吗？
我的赌注是代码质量的一些问题，大小不应该是一个 int 字面量，它应该至少是一个常数，因为它在多个实例中使用，c 是完全没有必要的，条件 c > -1 不符合标准，请查看其他答案并查看差异，也就是说我也得到了 1 次反对票，所以可能有人只是想放弃所有答案，谁知道呢。这是网站的一项功能，人们不妨习惯它。

【解决方案2】：

您不需要将 4 个参数传递给 koko，只需数组和元素数量就足够了。也不要和-1比较，把循环写成在0处停止的向下循环，这样就可以使用无符号索引类型，比如size_t。最好使用排除索引从 0 到 length 的经典循环，并将源元素存储到适当的目标元素。

你得到一个无意义的数字作为输出的原因是你打印了koko的返回值，它被错误输入为int，而你返回一个指向目标数组的指针，无论如何你不能以这种方式打印一个数组，您可以使用循环来遍历数组元素。

这是修改后的版本：

#include <stdio.h>

void koko(const int *array, int *array2, size_t length) {
    for (size_t i = 0; i < length; i++) {
        array2[length - 1 - i] = array[i];
    }
}

int main() {
    int niz[] = { 2, 4, 5, 7, 4, 8, 3 };
    size_t length = sizeof(niz) / sizeof(niz[0]);
    int niz2[length];
    koko(niz, niz2, length);
    for (size_t i = 0; i < length; i++) {
        printf("%d ", niz2[i]);
    }
    printf("\n");
    return 0;
}

【讨论】：

【解决方案3】：

那么有人在我的代码中看到了问题吗？

是的：

d 接收一个未初始化的参数c，因为您在使用它之前从未在函数范围内对其进行初始化，所以它会调用undefined behaviour。
koko 的返回类型不正确，因为您尝试返回 array2，实际上是 niz2，您需要 int* 返回类型，而不是 int。

此外，您不需要这样做，因为作为函数参数传递的数组会衰减为指向它的第一个元素的指针，即使参数不是显式指针，对它所做的更改也在功能是永久的。

根据您的代码，您可以执行以下操作：

Running sample

#include <stdio.h>

void koko(int *array, int *array2, size_t size) // pass the size of the array
{                                              // size_t more appropriate for object sizes  
    for (int j = 0; size > 0; size--, j++) // initialize j, you can use size as iterator
    {
        array2[j] = array[size - 1]; // changes made to array2 are permanent
    }
}

int main()
{
    int niz[] = {2, 4, 5, 7, 4, 8, 3};
    const size_t SIZE = sizeof(niz) / sizeof(niz[0]); // determine the size of the array
    int niz2[SIZE]; // same size as non reversed array

    koko(niz, niz2, SIZE);

    for (size_t i = 0; i < SIZE; i++) // test print the reversed array
        printf("%d", niz2[i]);
}

【讨论】：

感谢您的编辑...for (int i = 0; i < 6; i++) 怎么样 -> for (int i = 0; i < SIZE; i++)
@chqrlieforyellowblockquotes，谢谢，我想我在那里躲过了一劫。
我们都会犯错，不是吗？由于变量名称的较晚更改和不建议的复制/粘贴，我可能应该对我的答案中这么多愚蠢的错误投反对票……这是通往简单的漫长而艰难的道路，但值得一游:)

【解决方案4】：

函数的返回类型不正确。

int koko(int *array,int *array2,int c,int d)
{
for(c=6;c>-1;c--,d++)
{
    array2[d]=array[c];
}
return array2;
}

返回的表达式类型为int *，而返回类型为int。

还有这个电话

c=koko(niz,niz2,a,b);

没有意义，因为变量 a 和 b 未初始化。

还有这个函数printf的单次调用

printf("%d", c);

与输出整个结果数组没有什么共同点。

看来您需要的是以下内容。

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

int * reverse( const int *a, size_t n )
{
    int *result = malloc( n * sizeof( int ) );

    if ( result != NULL )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            result[i] = a[n - i - 1];
        }
    }

    return result;
}

int main(void) 
{
    int a[] = { 2, 4, 5, 7, 4, 8, 3 };
    const size_t N = sizeof( a ) / sizeof( *a );

    int *b = reverse( a, N );

    if ( b != NULL )
    {
        for ( size_t i = 0; i < N; i++ )
        {
            printf( "%d ", b[i] );
        }

        putchar( '\n' );
    }

    free( b );

    return 0;
}

程序输出是

3 8 4 7 5 4 2

如果你想以相反的顺序将一个数组复制到另一个已经存在的数组中，那么对应的函数可以如下面的演示程序所示。

#include <stdio.h>

void reverse_copy( const int *a, size_t n, int *b )
{
    const int *p = a + n;

    while ( p-- != a )
    {
        *b++ = *p;
    }
}

int main(void) 
{
    enum { N = 7 };
    int a[N] = { 2, 4, 5, 7, 4, 8, 3 };
    int b[N];

    reverse_copy( a, N, b );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", b[i] );
    }

    putchar( '\n' );

    return 0;
}

程序输出将与上图相同。

3 8 4 7 5 4 2

无需在函数中引入任何额外的变量（实际上是多余的），就可以这样定义

void reverse_copy( const int *a, size_t n, int *b )
{
    while ( n-- )
    {
        *b++ = a[n];
    }
}

正如您在函数内部看到的，只使用了它的参数。

顺便说一句，递归函数可以如下所示。:)

#include <stdio.h>

void reverse_copy( const int *a, size_t n, int *b )
{
    if ( n )
    {
        *b = a[n-1];
        reverse_copy( a, n - 1, b + 1 );
    }
}

int main(void) 
{
    enum { N = 7 };
    int a[N] = { 2, 4, 5, 7, 4, 8, 3 };
    int b[N];

    reverse_copy( a, N, b );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", b[i] );
    }

    putchar( '\n' );

    return 0;
}

它的输出又是

3 8 4 7 5 4 2

【讨论】：