java有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数

这道题目可以使用数组来解决。具体步骤如下：

1. 定义一个长度为n的数组，用来存储n个整数。

2. 将数组中前面的n-m个数顺序向后移动m个位置，可以使用循环来实现。

3. 将数组中后面的m个数移动到数组的最前面，同样可以使用循环来实现。

4. 最后输出移动后的数组即可。

下面是示例代码：

public static void main(String[] args) {
    int n = 10; // 数组长度
    int m = 3; // 移动的位置数
    int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 原始数组

    // 将前面的n-m个数顺序向后移动m个位置
    for (int i = n - m - 1; i >= ; i--) {
        arr[i + m] = arr[i];
    }

    // 将后面的m个数移动到数组的最前面
    for (int i = ; i < m; i++) {
        arr[i] = arr[n - m + i];
    }

    // 输出移动后的数组
    for (int i = ; i < n; i++) {
        System.out.print(arr[i] + " ");
    }
}

输出结果为：4 5 6 7 8 9 10 1 2 3

相关问题

用Java实现：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。

以下是Java实现：

import java.util.Arrays;

public class MoveArray {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        int m = 2;
        moveArray(nums, m);
        System.out.println(Arrays.toString(nums));
    }

    public static void moveArray(int[] nums, int m) {
        int n = nums.length;
        if (m > n) {
            m %= n;
        }
        int[] temp = new int[m];
        for (int i = n - m, j = 0; i < n; i++, j++) {
            temp[j] = nums[i];
        }
        for (int i = n - 1, j = i - m; j >= 0; i--, j--) {
            nums[i] = nums[j];
        }
        for (int i = 0; i < m; i++) {
            nums[i] = temp[i];
        }
    }
}

首先判断移动的位数m是否大于数组长度n，如果是则取余数。

然后将后m个数保存到临时数组temp中。

接着从后往前遍历数组，将前n-m个数向后移动m个位置。

最后将临时数组中的m个数复制到数组的前面m个位置。

运行结果：

[4, 5, 1, 2, 3]

利用Java求数组中有 n 个数据，要将它们顺序循环向后移 k 位，即前面的元素向后移 k 位，后面的元素则循环向前移 k 位，例：1、2、3、4、5 循环移 3 位后为：3、4、5、1、2。考虑到 n会很大，不允许用 2*n 以上个空间来完成此题。写出完整代码

你可以使用Java的数组操作和索引来解决这个问题，不需要额外的空间。下面是一个完整的解决方案：

public class RotateArray {
    public void rotate(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k == 0) {
            return;
        }
        
        k = k % nums.length; // 取模，处理k大于数组长度的情况
        
        reverse(nums, 0, nums.length - 1); // 先反转整个数组
        reverse(nums, 0, k - 1);      // 反转前k个元素
        reverse(nums, k, nums.length - 1); // 再反转剩余的元素
    }
    
    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }
}

在这个代码中，我们定义了一个`rotate`方法，接受一个整型数组`nums`和一个整数`k`作为参数。首先检查边界情况，如数组为空、长度为0或k为0。然后取k对数组长度的余数，避免不必要的旋转。

接着，我们先调用`reverse`方法反转整个数组，再反转前k个元素，最后反转剩下的元素。这里使用了三次反转，一次处理所有元素，另两次处理部分元素，达到最终的旋转效果。

`reverse`方法内部使用了双指针技术，从数组两端开始交换元素直到相遇，实现了数组片段的反转。

这个解决方案只使用了原地操作，时间复杂度是O(n)，其中n是数组的长度，空间复杂度是O(1)。