Question

所以我想用32个整数“ n”次切换数组的元素。

所有元素应位于下一个位置，最后一个元素应位于第一个位置。

我尝试过这样的事情：

while(scanf("%d", &n) != EOF)
{
    for(int j=0; j<n; j++)
    for(int i=1; i<31; i++)
    {
        t[0]=t[31];
        tmp=t[i];
        t[i]=t[i+1];
    }
}

我不确定如何使用tmp变量来解决此问题。

这是数组的元素：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

，如果n = 1，它应该看起来像这样：

32 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Answer 1

以下内容不是对代码的编辑，而是O（n）运行时的更有效解决方案：

void rightshift(char array[LENGTH])
{
    int i, next = array[0];

    for (i = 1; i < LENGTH; i++)
    {
        char temp = array[i];
        array[i] = next;
        next = temp;
    }

    array[0] = next;
}

Answer 2

您的交换是错误的，应该看起来像这样：

char temp = t[i];
t[i] = t[i + 1];
t[i + 1] = temp;

此外，如果您想要这样的无限循环，建议您像这样跳过scanf中的空格：

while (scanf(" %d", &n) == 1) // note the space before %d

总而言之，它看起来像这样：

int main(int argc, char** argv) {
    char t[33] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456"; // 33 elements to leave space for '\0'
    int n;
    while (scanf(" %d", &n) == 1)
    {
        for (int j = 0; j < n; j++)
            for (int i = 0; i < 31; i++)
            {
                char temp = t[i];
                t[i] = t[i + 1];
                t[i + 1] = temp;
            }
        printf("string: %s\n", t);
    }
    return 0;
}

Answer 3

由于元素每次都移动1个位置，因此可以提高效率。您不需要为每个元素使用临时变量，而只需为第一个/最后一个使用临时变量。您无需交换每对相邻元素。

void rotate_by_1(char array[], size_t elem)
{
    int i;

#ifdef ROTATE_LEFT
    // Rotate in one direction...
    char tmp = array[0];
    for (i = 0; i < elem-1; i++)
    {
        array[i] = array[i+1];
    }
    array[elem-1] = tmp;
#endif

#ifdef ROTATE_RIGHT
    // Rotate in the other direction...
    char tmp = array[elem-1];
    for (i = elem-1; i > 0; i--)
    {
        array[i] = array[i-1];
    }
    array[0] = tmp;
#endif
}

未测试...

Answer 4

首先，请注意，要旋转具有 32 个元素 n 次的数组，只需旋转n % 32次。作为可能不是最快的解决方案的替代方案，下面的代码以相反的顺序复制原始数组的两个内存块，这等同于右移数组 n 次，这可能不是最快的解决方案。

#define LEN 32
#define NUMBER_OF_ROTATIONS 56

int array_to_rotate[LEN];

int* tmp = malloc(sizeof(int) * LEN);

int n = NUMBER_OF_ROTATIONS % LEN;

// copying the last n elements of array_to_rotate to the beginning of tmp array
memcpy(tmp, (array_to_rotate + LEN - n), n * sizeof(int));

// copying first (LEN - n) elements of array_to_rotate behind the elements already copied to tmp array
memcpy((tmp + n), array, (LEN - n) * sizeof(int));

//replacing the original array with the one obtained after rotation n times
memcpy(array, tmp, sizeof(int) * LEN));

free(tmp);

在C中切换数组的元素

4 个答案: