如何反转数组并将反转数组的值存储在新数组中
How to reverse an array and store the values of the reversed array in a new array
我的程序需要执行以下操作:
- 反转数组(f.e。
niz[] = { 2, 4, 5, 7, 4, 8, 3 }
需要变成niz[] = { 3, 8, 4, 7, 5, 4, 2 }
- 将反转数组的值存储到全新数组中
- 所有这些都必须在不使用
printf
的函数内完成,该函数反转数组并将值存储到新数组中。此外,需要预定义数组及其大小(因此无需用户输入)。
- 结果(在本例中为包含先前数组的反转值的新数组)需要打印在
main
但是,不是反转数组并将其存储到新数组中并返回它。该程序始终打印以下数字:
6356668
有人看到我的代码中的问题了吗?
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);
}
函数的 return 类型不正确。
int koko(int *array,int *array2,int c,int d)
{
for(c=6;c>-1;c--,d++)
{
array2[d]=array[c];
}
return array2;
}
returned 表达式的类型为 int *
,而 return 类型为 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
So does anyone see the problem in my code?
是:
d
接收一个单元化参数 c
,因为你在使用它之前从未在函数范围内初始化它,它调用 undefined behaviour.
koko
的 return 类型不正确,因为您正在尝试 return array2
,实际上 niz2
,您需要 int*
return 类型,而不是 int
.
此外,您不需要这样做,因为作为函数参数传递的数组会衰减为指向其第一个元素的指针,即使参数不是明确的指针,在范围内对其所做的更改也是如此的功能是永久的。
根据您的代码,您可以执行以下操作:
#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]);
}
因为你使用新数组作为koko
函数的参数,所以你不需要return它。如果你想 return 它,你应该将 returning 的类型从 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
您不需要向koko
传递4个参数,只需要数组和元素数量就足够了。也不要和-1
比较,把循环写成在0
处停止的向下循环,这样就可以使用无符号索引类型,比如size_t
。最好使用索引从 0 到 length
的经典循环,并将源元素存储到适当的目标元素。
你得到一个无意义的数字作为输出的原因是你 printf koko
的 return 值,它被错误输入为 int
而你 return 一个指针到目标数组,并且无论如何都不能以这种方式打印数组,您可以使用循环来遍历数组元素。
这是修改后的版本:
#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;
}
我的程序需要执行以下操作:
- 反转数组(f.e。
niz[] = { 2, 4, 5, 7, 4, 8, 3 }
需要变成niz[] = { 3, 8, 4, 7, 5, 4, 2 }
- 将反转数组的值存储到全新数组中
- 所有这些都必须在不使用
printf
的函数内完成,该函数反转数组并将值存储到新数组中。此外,需要预定义数组及其大小(因此无需用户输入)。 - 结果(在本例中为包含先前数组的反转值的新数组)需要打印在
main
但是,不是反转数组并将其存储到新数组中并返回它。该程序始终打印以下数字:
6356668
有人看到我的代码中的问题了吗?
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);
}
函数的 return 类型不正确。
int koko(int *array,int *array2,int c,int d)
{
for(c=6;c>-1;c--,d++)
{
array2[d]=array[c];
}
return array2;
}
returned 表达式的类型为 int *
,而 return 类型为 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
So does anyone see the problem in my code?
是:
d
接收一个单元化参数c
,因为你在使用它之前从未在函数范围内初始化它,它调用 undefined behaviour.koko
的 return 类型不正确,因为您正在尝试 returnarray2
,实际上niz2
,您需要int*
return 类型,而不是int
.此外,您不需要这样做,因为作为函数参数传递的数组会衰减为指向其第一个元素的指针,即使参数不是明确的指针,在范围内对其所做的更改也是如此的功能是永久的。
根据您的代码,您可以执行以下操作:
#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]);
}
因为你使用新数组作为koko
函数的参数,所以你不需要return它。如果你想 return 它,你应该将 returning 的类型从 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
您不需要向koko
传递4个参数,只需要数组和元素数量就足够了。也不要和-1
比较,把循环写成在0
处停止的向下循环,这样就可以使用无符号索引类型,比如size_t
。最好使用索引从 0 到 length
的经典循环,并将源元素存储到适当的目标元素。
你得到一个无意义的数字作为输出的原因是你 printf koko
的 return 值,它被错误输入为 int
而你 return 一个指针到目标数组,并且无论如何都不能以这种方式打印数组,您可以使用循环来遍历数组元素。
这是修改后的版本:
#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;
}