C 没有得到所有的结果移动我的数组

我试图制作一个程序，将数组中的所有元素向右移动一个，然后将最后一个元素移动到第一个位置。我的问题是，当我运行代码时，它会给我两次编号

5

。有人能帮我吗，也许我的逻辑或for循环不对

#include <stdio.h>

int main ()
{
    int array[6];
    int x;
    int temp;

    printf("Enter six numbers.\n\n");

    for (x = 0; x < 6; x++) {
        printf("Enter a number : ", x + 1);
        scanf("%d", &array[x]);

        temp = array[x - 1];
    }

    for (x = 6 - 1; x > 0; x--) {
        array[x] = array[x - 1];
    }

    array[0] = temp;

    for (x = 0; x < 6; x++) {
        printf("%d\n", array[x]);
    }

    return 0;
}

#包括
int main（）
{
int数组[6]；
int x；
内部温度；
printf（“输入六个数字。\n\n”）；
对于（x=0；x<6；x++）{
printf（“输入一个数字：”，x+1）；
scanf（“%d”、&array[x]）；
温度=阵列[x-1]；
}
对于（x=6-1；x>0；x--）{
数组[x]=数组[x-1]；
}
数组[0]=temp；
对于（x=0；x<6；x++）{
printf（“%d\n”，数组[x]）；
}
返回0；
}

您可以为类循环创建一个

for(i=0; i<SIZE; ++i)
{
    scanf("%d", &arr[(i+1)%SIZE]);
}

将最后一个元素保存到临时变量中，将其他元素向右移动，最后将临时变量中的值指定给第一个元素

正如所指出的，在第一次
for
循环的第一次迭代中，
arr[x-1]
将变成
arr[-1]
，因为
x
是
0
。您正在尝试访问不属于该阵列的内存。这将调用未定义的行为。
我将尝试用最简单的算法来解释它，是的，简单意味着从性能角度来看效率不高。
例如，假设您有一个包含六个元素的数组：

123456

从这个问题中，我所理解的是，您希望反转此数组，以获得最终的数组：

654321

一种简单的方法是将第一个元素存储在临时变量中，将第二个元素分配给第一个元素，然后将临时变量分配给第二个元素，并重复此操作，直到所有元素都交换完毕，如下所示：

temp = arr[0]
arr[0] = arr[1]
arr[1] = temp

您将需要两个循环来执行此操作，一个是递减循环，一个是递增循环

1 2 3 4 5 6  i=0; j=5
2 1 3 4 5 6  i=1; j=5
2 3 1 4 5 6  i=2; j=5
2 3 4 1 5 6  i=3; j=5
2 3 4 5 1 6  i=4; j=5
2 3 4 5 6 1  i=5; j=5

接下来，您必须以较少的迭代执行上述循环：

2 3 4 5 6 1  i=0; j=4
3 2 4 5 6 1  i=1; j=4
3 4 2 5 6 1  i=2; j=4
3 4 5 2 6 1  i=3; j=4
3 4 5 6 2 1  i=4; j=4

因此，循环将是：

for(i=5; i>0; i--)
{
  for(j=0; j<i; j++)
  {
    temp = arr[j];
    arr[j] = arr[j+1];
    arr[j+1] = temp;
   }
 }

for（i=5；i>0；i--）
{
对于（j=0；j通过向移位例程添加一个方向，并将移位代码放入一个以数组、成员数和移位方向为参数的函数中，可以使事情变得更一般。然后，只需按正确的方向迭代，将元素按正确的方向移位，并将fin在适当的位置输入值。例如，您可以编写一个简单的函数，如下所示：

/** shift array index in in circular manner by 1 in the
 *  0 - left or 1 - right direction. 
 */
void arrayshift (int *a, size_t nmemb, int dir)
{
    if (dir) {  /* shift to RIGHT */
        int tmp = a[nmemb - 1];
        for (size_t i = nmemb - 1; i > 0; i--)
            a[i] = a[i - 1];
        a[0] = tmp;
    }
    else {      /* shift to LEFT */
        int tmp = a[0];
        for (size_t i = 1; i < nmemb; i++)
            a[i - 1] = a[i];
        a[nmemb - 1] = tmp;
    }
}

您还可以通过传递元素的数量来移动数组，并使用模运算符来帮助索引。（这将留待另一天）
对于第一次迭代，即对于
x=0
，
temp=array[x-1]；
这将导致UB。对于右边，数组的右边是什么意思？
/** shift array index in in circular manner by 1 in the
 *  0 - left or 1 - right direction. 
 */
void arrayshift (int *a, size_t nmemb, int dir)
{
    if (dir) {  /* shift to RIGHT */
        int tmp = a[nmemb - 1];
        for (size_t i = nmemb - 1; i > 0; i--)
            a[i] = a[i - 1];
        a[0] = tmp;
    }
    else {      /* shift to LEFT */
        int tmp = a[0];
        for (size_t i = 1; i < nmemb; i++)
            a[i - 1] = a[i];
        a[nmemb - 1] = tmp;
    }
}

#include <stdio.h>

enum { LEFT, RIGHT };

void arrayshift (int *a, size_t nmemb, int dir);

int main (int argc, char **argv) {

    int a[] = { 1, 2, 3, 4, 5, 6 },
        dir = argc > 1 ? LEFT : RIGHT;
    size_t n = sizeof a / sizeof *a;

    printf ("original:");
    for (size_t i = 0; i < n; i++)
        printf (" %d", a[i]);
    putchar ('\n');

    arrayshift (a, n, dir);

    printf ("shifted :");
    for (size_t i = 0; i < n; i++)
        printf (" %d", a[i]);
    putchar ('\n');

    return 0;
}

/** shift array index in in circular manner by 1 in the
 *  0 - left or 1 - right direction. 
 */
void arrayshift (int *a, size_t nmemb, int dir)
{
    if (dir) {  /* shift to RIGHT */
        int tmp = a[nmemb - 1];
        for (size_t i = nmemb - 1; i > 0; i--)
            a[i] = a[i - 1];
        a[0] = tmp;
    }
    else {      /* shift to LEFT */
        int tmp = a[0];
        for (size_t i = 1; i < nmemb; i++)
            a[i - 1] = a[i];
        a[nmemb - 1] = tmp;
    }
}

$ ./bin/array_cir_shift_by_1
original: 1 2 3 4 5 6
shifted : 6 1 2 3 4 5

$ ./bin/array_cir_shift_by_1 0
original: 1 2 3 4 5 6
shifted : 2 3 4 5 6 1