将数组旋转K个位置
在本教程中，我们将看到如何将数组旋转到K个位置。
问题：
N = 6和k = 2
如果Arr [] = {1,2,3,4,5,6}并且k = 2
则旋转数组将为{5，6，1，2，3，4}
解：
有多种方法可以解决此问题。
方法1：
将每个数字移动1位，然后进行k次。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
上市 静态的 整型[] rotateBruteForce(整型[] nums, 整型 k) { 对于 (整型 i = 0; i < k; i++) { 对于 (整型 j = nums.长度 - 1; j > 0; j-) { //将每个数字移动1位 整型 温度 = nums[j]; nums[j] = nums[j - 1]; nums[j - 1] = 温度; } 系统.出.打印(“阵列旋转后”+(i+1)+“ 步”); 打印Array(nums); 系统.出.打印(); } 返回 nums; } |
时间复杂度：o（n * k）
其中n是元素数，k表示位置偏移。
空间复杂度：o（1）
方法二：
您可以使用o（n）中的临时数组旋转数组。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
上市 静态的 整型[] 回转ExtraSpace(整型[] nums, 整型 k) { 整型 n=nums.长度; 如果(k > n) k=k%n; 整型[] 结果 = 新 整型[n]; 对于(整型 i=0; i < k; i++){ 结果[i] = nums[n-k+i]; } 整型 指数=0; 对于(整型 i=k; i<n; i++){ 结果[i] = nums[指数++]; } 返回 结果; } |
时间复杂度：o（n）
空间复杂度：o（n）
方法3：
这是最优化的方法。
此方法的算法如下：
- 反转整个数组。
- 反转前k个元素
- 反向休息n-k个元素。
例如：
让’s说Array是{1,2,3,4,5,6,7,8}
您想旋转k位置。
它将按以下方式工作：
- 旋转整个阵列。因此数组变成：{8,7,6,5,4,3,2,1}
- 反转前k个元素，因此数组变为：{7,8,6,5,4,3,2,1}
- 反转其余元素，因此数组变成了：{7,8,1,2,3,4,5,6}
爪哇代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
上市 静态的 整型[] 旋转优化(整型[] nums,整型 k) { 整型 n=nums.长度; 如果(k > n) k=k%n; nums=逆转(nums,0,n-1); nums=逆转(nums,0,k-1); nums=逆转(nums,k,n-1); 返回 nums; } 上市 静态的 整型[] 逆转(整型[] nums,整型 开始,整型 结束) { 而 (开始 <= 结束 ) { 整型 温度=nums[开始]; nums[开始]=nums[结束]; nums[结束]=温度; 开始++; 结束-; } 返回 nums; } |
时间复杂度：o（n）
空间复杂度：o（1）
完整的Java程序以K个位置旋转数组：
|
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 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 |
包 组织.Arpit.爪哇2blog; 上市 类 旋转ArrayMain { 上市 静态的 虚空 主要(串[] args) { 整型 nums[]={1,2,3,4,5,6,7,8}; 系统.出.打印(“通过将一个元素移位1并旋转k次来旋转数组”); 整型[] 结果1=rotateBruteForce(nums,2); 系统.出.打印(“最终旋转数组：”); 打印Array(结果1); 系统.出.打印(); 系统.出.打印(“ ===============================”); 系统.出.打印(“使用额外的空间旋转数组”); 整型 nums2[]={10,20,30,40,50,60}; 整型[] 结果2=回转ExtraSpace(nums2,5); 打印Array(结果2); 系统.出.打印(); 系统.出.打印(“ ===============================”); 系统.出.打印(“旋转阵列最优化的方法”); 整型 nums3[]={1,2,3,4,5,6,7,8,9,10}; 整型[] 结果3=旋转优化(nums3,4); 打印Array(结果3); } 上市 静态的 整型[] rotateBruteForce(整型[] nums, 整型 k) { 整型 n=nums.长度; 如果(k > n) k=k%n; 对于 (整型 i = 0; i < k; i++) { 对于 (整型 j = n - 1; j > 0; j-) { //将每个数字移动1位 整型 温度 = nums[j]; nums[j] = nums[j - 1]; nums[j - 1] = 温度; } 系统.出.打印(“阵列旋转后”+(i+1)+“ 步”); 打印Array(nums); 系统.出.打印(); } 返回 nums; } 上市 静态的 整型[] 回转ExtraSpace(整型[] nums, 整型 k) { 整型 n=nums.长度; 如果(k > n) k=k%n; 整型[] 结果 = 新 整型[n]; 对于(整型 i=0; i < k; i++){ 结果[i] = nums[n-k+i]; } 整型 指数=0; 对于(整型 i=k; i<n; i++){ 结果[i] = nums[指数++]; } 返回 结果; } 上市 静态的 整型[] 旋转优化(整型[] nums,整型 k) { 整型 n=nums.长度; 如果(k > n) k=k%n; nums=逆转(nums,0,n-1); nums=逆转(nums,0,k-1); nums=逆转(nums,k,n-1); 返回 nums; } 上市 静态的 整型[] 逆转(整型[] nums,整型 开始,整型 结束) { 而 (开始 <= 结束 ) { 整型 温度=nums[开始]; nums[开始]=nums[结束]; nums[结束]=温度; 开始++; 结束-; } 返回 nums; } 上市 静态的 虚空 打印Array(整型 []rr) { 对于 (整型 i = 0; i < rr.长度; i++) { 系统.出.打印(rr[i]+”); } } } |
当您运行上述程序时，将获得以下输出：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
旋转 数组 通过 转移 一 元素 通过 1 和 做 它 k 次 数组 回转 后 1 步 8 1 2 3 4 5 6 7 数组 回转 后 2 步 7 8 1 2 3 4 5 6 最后 旋转的 数组 : 7 8 1 2 3 4 5 6 ================================ 旋转 数组 使用 额外 空间 20 30 40 50 60 10 ================================ 旋转 数组 最 优化 方法 7 8 9 10 1 2 3 4 5 6 |
