c语言数组旋转180度

以下是C语言数组旋转180度的代码：

#include <stdio.h>

void reverse(int arr[], int start, int end) {
    while (start < end) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
}

void rotate(int arr[], int n) {
    reverse(arr, 0, n-1);
    reverse(arr, 0, n/2-1);
    reverse(arr, n/2, n-1);
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    rotate(arr, n);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

这个程序可以将一个长度为n的数组旋转180度。

相关问题

c语言 三维数组旋转90度

可以通过以下步骤来旋转一个三维数组90度：

1. 定义一个新的三维数组，其维度与原数组旋转后的维度相同。
2. 使用三重循环，遍历原数组，将每个元素旋转并存储到新数组中。
3. 返回新数组。

以下是一个示例代码：

#include <stdio.h>

void rotate(int arr[][3][3], int size) {
    int new_arr[size][size][size];
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            for (int k = 0; k < size; k++) {
                new_arr[k][j][size-i-1] = arr[i][j][k];
            }
        }
    }
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            for (int k = 0; k < size; k++) {
                arr[i][j][k] = new_arr[i][j][k];
            }
        }
    }
}

int main() {
    int arr[3][3][3] = {
        {{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}}
    };
    rotate(arr, 3);
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 3; k++) {
                printf("%d ", arr[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}

这个程序定义了一个3x3x3的三维数组，然后将其旋转90度，并输出结果。对于更大的数组，只需要更改数组的维度即可。

c语言数组和java数组

C语言数组和Java数组都是用来存储一组相同类型的数据的数据结构，但是它们在定义、使用和内存管理等方面有一些不同。

在C语言中，数组的定义方式为：类型 数组名[元素个数]，例如 int arr。而在Java中，数组的定义方式为：类型[] 数组名 = new 类型[元素个数]，例如 int[] arr = new int。

在C语言中，数组的下标从0开始，而在Java中也是从0开始。但是在C语言中，数组的长度需要手动计算或者通过sizeof()函数获取，而在Java中可以通过数组的length属性获取。

在C语言中，数组的内存分配是静态的，即在编译时就确定了数组的大小和内存地址。而在Java中，数组的内存分配是动态的，即在运行时根据元素个数动态分配内存。