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

这个问题可以通过将数组分成两部分来解决。首先，我们将数组分成前面 n-m 个元素和后面 m 个元素。然后，我们将前面 n-m 个元素逆序排列，再将后面 m 个元素逆序排列。最后，我们将整个数组逆序排列即可。

下面是 Java 代码实现：

public static void rotate(int[] nums, int k) {
    int n = nums.length;
    k %= n;
    reverse(nums, 0, n - k - 1);
    reverse(nums, n - k, n - 1);
    reverse(nums, 0, n - 1);
}

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

这段代码中，rotate 方法接受一个数组和一个整数 k，它将数组中前面 n-k 个元素与后面 k 个元素交换位置并返回新的数组。

reverse 方法用于将数组中某个范围内的元素逆序排列。它接受一个数组、开始索引和结束索引，然后使用两个指针来交换这两个索引之间的元素。

使用这个算法，可以在 O(n) 的时间复杂度内解决这个问题。

相关问题

用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)。