Question

我正在尝试创建一个程序，将数组的所有元素向右移动一个，并将最后一个元素移动到第一个位置。我的问题是当我运行我的代码时它会给我两次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;
}

Answer 1

您可以制作for循环

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

如果(i+1)%SIZE小于i+1，i+1将评估为SIZE。否则，它会缠绕。

或者你可以

int t=arr[SIZE-1];
for(i=SIZE-1; i>0; --i)
{
    arr[i]=arr[i-1];
}
arr[0]=t;

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

正如Gourav指出的那样，在您的第一个for循环的第一次迭代中，arr[x-1]将成为arr[-1]，x为0 。您正在尝试访问不属于该阵列的内存。这会调用未定义的行为。

Answer 2

我将尝试使用最简单的算法来解释它，并且从性能角度来看，简单的意思是效率不高。例如，让我们说你有一个由六个元素组成的数组：
6 5 4 3 2 1

从这个问题来看，我所理解的是你想要反转这个数组以得到一个最终数组：
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;
   }
 }

所以，循环将是：

MarketedProgramService.getMarketedPrograms().then(function( programs ) {
        $scope.programs = [];
        var userPrograms = $filter("filter")( programs, 
MarketedProgramService.userHasAccessToProgram.bind( null, UserProfile ) );
        //userPrograms.unshift( defaultProgram );

        // Exclude FirstComp/Maverick programs
        angular.forEach( userPrograms, function( program ) {
            if( program.mbu != "FC" ) {
                $scope.programs.push( program );
            }
        });
    });

Answer 3

你可以通过在移位例程中添加一个方向并将移位代码放在一个函数中，使得数组，成员数和作为参数移位的方向，使事情变得更通用。然后它只是在正确的方向上迭代并将元素移动到正确的方向并将最终值放在适当的位置。例如，您可以编写一个简单的函数，如下所示：

/** 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

您还可以传递元素数以移动数组，并使用 modulo 运算符来帮助编制索引。（剩下一天了）

没有让所有结果改变我的阵列

3 个答案: