「旋转数组」核心考察数组操作技巧与空间复杂度优化思路。这道题看似简单，却能延伸出多种解题方法，从暴力模拟到极致的空间优化，层层递进的思路能帮我们理解算法设计的核心 —— 用最少的资源解决问题。实际开发中，类似循环数组操作、数据位移处理等场景都能用到它的思路。今天我们从暴力解法出发，一步步优化到 O (1) 空间复杂度的最优解，带你吃透旋转数组的本质～
📌 题目重述
给你一个整数数组nums，以及一个整数k，请你将数组中的元素向右旋转k个位置。旋转规则是：数组末尾的k个元素移到数组开头，其余元素依次向右移动。
这里要注意两个关键点：
- k 可能大于数组长度：比如数组长度为 5，k=7，实际等效于旋转
k % 5 = 2个位置（因为旋转 5 次会回到原数组）； - 原地旋转要求：最优解法需要在原数组上操作，不使用额外的数组空间。
举个例子，输入nums = [1,2,3,4,5,6,7]，k = 3，输出应为[5,6,7,1,2,3,4]（末尾 3 个元素移到开头）；输入nums = [-1,-100,3,99]，k = 2，输出应为[3,99,-1,-100]。
🚶 阶梯思路拆解
第一步：暴力思路（逐次旋转 + 临时变量）🥾
最直观的想法是，模拟每次向右旋转 1 个位置的过程，重复k次。这种方法逻辑简单，容易理解，但效率极低，仅适合入门理解。
💡 核心逻辑
- 先处理
k：计算k = k % nums.length（避免重复旋转）； - 循环
k次，每次旋转 1 个位置：- 保存数组最后一个元素到临时变量
temp； - 从后往前遍历数组，将每个元素向右移动一位（
nums[i] = nums[i-1]）； - 将
temp放到数组第一个位置；
- 保存数组最后一个元素到临时变量
- 循环结束后，数组即为旋转后的结果。
📊 图文演示（以 nums = [1,2,3,4,5,6,7]， k=3 为例）
（如图所示）暴力旋转过程（仅展示第一次旋转）：
- 初始数组：
[1,2,3,4,5,6,7] - 保存最后一个元素：
temp = 7 - 从后往前移动元素：
nums[6] = nums[5] → [1,2,3,4,5,6,6]nums[5] = nums[4] → [1,2,3,4,5,5,6]- …
nums[1] = nums[0] → [1,1,2,3,4,5,6]
- 放入临时变量：
nums[0] = 7 → [7,1,2,3,4,5,6]（第一次旋转完成） - 重复 3 次后，最终数组：
[5,6,7,1,2,3,4]
✅ 代码实现（Java）
publicclassSolution{publicvoidrotate(int[]nums,intk){intn=nums.length;k=k%n;// 处理k大于数组长度的情况for(inti=0;i<k;i++){// 每次旋转1个位置inttemp=nums[n-1];// 保存最后一个元素// 从后往前移动元素for(intj=n-1;j>0;j--){nums[j]=nums[j-1];}nums[0]=temp;// 放到第一个位置}}}⚙️ 复杂度分析
| 复杂度类型 | 计算结果 | 说明 |
|---|---|---|
| 时间复杂度 | O(n×k) | 外层循环 k 次，内层循环 n 次，最坏情况下 k=n，时间复杂度为 O (n²) |
| 空间复杂度 | O(1) | 仅使用临时变量 temp，无额外空间开销 |
🚫 遇到的问题
时间效率过低！当数组长度n=10⁵，k=10⁵（等效于 k=0，但实际代码会先取模），若 k=5×10⁴，n×k会达到 5×10⁹次运算，完全超出时间限制。核心问题是重复移动元素—— 每次旋转都要移动整个数组，做了大量无用功。
第二步：优化思路（额外数组存储）🗺️
为了解决暴力解法的时间问题，我们可以用额外的数组存储旋转后的结果，再复制回原数组。这种方法时间复杂度降到 O (n)，但需要额外的空间。
💡 核心逻辑
- 处理
k：k = k % nums.length； - 创建一个与原数组长度相同的新数组
newNums； - 遍历原数组，将每个元素放到新数组的对应位置：原数组索引
i的元素，旋转后应位于(i + k) % n的位置；（或更直观：前n-k个元素移到末尾，后k个元素移到开头） - 将新数组的元素复制回原数组。
📊 图文演示（以 nums = [1,2,3,4,5,6,7]， k=3 为例）
（如图所示）额外数组存储过程：
- 原数组索引：
0:1, 1:2, 2:3, 3:4, 4:5, 5:6, 6:7 - 后 k=3 个元素（索引 4、5、6）移到新数组开头：
newNums[0] = 5, newNums[1] = 6, newNums[2] = 7
- 前 n-k=4 个元素（索引 0、1、2、3）移到新数组末尾：
newNums[3] = 1, newNums[4] = 2, newNums[5] = 3, newNums[6] = 4
- 新数组：
[5,6,7,1,2,3,4]，复制回原数组即可。
✅ 代码实现（Java）
publicclassSolution{publicvoidrotate(int[]nums,intk){intn=nums.length;k=k%n;int[]newNums=newint[n];// 方法1：按“前n-k移末尾，后k移开头”处理// 后k个元素移到开头for(inti=0;i<k;i++){newNums[i]=nums[n-k+i];}// 前n-k个元素移到末尾for(inti=0;i<n-k;i++){newNums[k+i]=nums[i];}// 方法2：通用公式 (i + k) % n（两种方法等价）// for (int i = 0; i < n; i++) {// newNums[(i + k) % n] = nums[i];// }// 复制回原数组System.arraycopy(newNums,0,nums,0,n);}}⚙️ 复杂度分析
| 复杂度类型 | 计算结果 | 说明 |
|---|---|---|
| 时间复杂度 | O(n) | 仅遍历数组两次（一次赋值新数组，一次复制回原数组），线性时间 |
| 空间复杂度 | O(n) | 需要额外的数组存储结果，空间复杂度为 O (n) |
💡 优化亮点与待改进点
- 亮点：时间复杂度从 O (n²) 降到 O (n)，效率大幅提升，能应对大规模数据；
- 待改进：需要额外的 O (n) 空间，不符合原地旋转的最优要求（面试中通常会要求原地操作）。
第三步：最优解法（三步反转法 / 原地旋转）🔑
这是本题的最优解：利用数组反转的特性，通过三次反转实现原地旋转，时间复杂度 O (n)，空间复杂度 O (1)。核心思想是将旋转问题转化为反转问题。
先理解反转的特性
- 反转整个数组：
[1,2,3,4,5,6,7] → [7,6,5,4,3,2,1]； - 反转前 k 个元素：
[7,6,5,4,3,2,1] → [5,6,7,4,3,2,1]； - 反转后 n-k 个元素：
[5,6,7,4,3,2,1] → [5,6,7,1,2,3,4]（最终结果）。
💡 核心逻辑
- 处理
k：k = k % nums.length； - 第一步反转：反转整个数组；
- 第二步反转：反转数组前
k个元素； - 第三步反转：反转数组后
n-k个元素； - 三次反转完成后，数组即为旋转后的结果。
📊 图文演示（以 nums = [1,2,3,4,5,6,7]， k=3 为例）
（如图所示）三步反转过程：
- 反转整个数组：
[1,2,3,4,5,6,7] → [7,6,5,4,3,2,1] - 反转前 k=3 个元素：
[7,6,5,4,3,2,1] → [5,6,7,4,3,2,1] - 反转后 n-k=4 个元素：
[5,6,7,4,3,2,1] → [5,6,7,1,2,3,4]（旋转完成）
✅ 代码实现（Java，最优解）
publicclassSolution{publicvoidrotate(int[]nums,intk){intn=nums.length;k=k%n;// 处理k大于数组长度的情况reverse(nums,0,n-1);// 反转整个数组reverse(nums,0,k-1);// 反转前k个元素reverse(nums,k,n-1);// 反转后n-k个元素}// 辅助方法：反转数组中[start, end]区间的元素privatevoidreverse(int[]nums,intstart,intend){while(start<end){// 交换start和end位置的元素inttemp=nums[start];nums[start]=nums[end];nums[end]=temp;start++;end--;}}}⚙️ 复杂度分析
| 复杂度类型 | 计算结果 | 说明 |
|---|---|---|
| 时间复杂度 | O(n) | 三次反转总共遍历数组 n 次（反转整个数组 n 次，前 k 和后 n-k 共 n 次），线性时间 |
| 空间复杂度 | O(1) | 仅使用临时变量交换元素，原地操作，无额外空间开销 |
✨ 核心优势
- 时间最优：O (n) 时间复杂度，效率与额外数组法相同；
- 空间最优：O (1) 空间复杂度，完全原地操作，满足面试最优要求；
- 逻辑巧妙：将旋转转化为反转，思路清晰，代码简洁易记。
第四步：边界情况与易错点
常见边界场景
k=0（或 k 是数组长度的倍数）：数组无需旋转，直接返回原数组（代码中k%n会处理为 0，三次反转后数组不变）；- 数组长度为 1：无论 k 是多少，数组都不会变化；
k=1：等效于暴力解法的一次旋转，三步反转法同样适用；- 数组元素全相同：旋转后结果不变，所有方法都能正确处理。
易错点提醒
- 忘记处理 k：直接使用原始 k 值，当 k>n 时会导致数组越界或重复旋转；
- 反转区间错误：第三步反转的起始索引是
k而非k+1（比如 k=3，后 n-k 个元素从索引 3 开始）； - 反转函数实现错误：交换元素时未正确移动
start和end指针（如遗漏start++或end--）。
📝 总结
「旋转数组」的解题思路，核心是从暴力模拟到空间优化的递进：
- 暴力解法：逐次旋转，直观但效率低（O (n²) 时间）；
- 额外数组法：空间换时间，效率提升但需要 O (n) 空间；
- 三步反转法：最优解，利用反转特性实现原地旋转（O (n) 时间 + O (1) 空间）。
关键技巧可以总结为：
- 处理 k 的通用方法：
k = k % n（避免重复操作）； - 旋转与反转的转化：向右旋转 k 个位置 = 三次反转（整体→前 k→后 n-k）；
- 原地操作的核心：通过交换元素实现反转，不使用额外空间。
同类题扩展建议
掌握了这道题的思路后，可以尝试这些进阶题目：
- LeetCode 33. 搜索旋转排序数组：旋转数组的延伸，考察二分查找的变种；
- LeetCode 153. 寻找旋转排序数组中的最小值：旋转排序数组的最小值查找，同样用二分优化；
- LeetCode 48. 旋转图像：二维数组的旋转，思路与本题的反转法类似；
- LeetCode 61. 旋转链表：链表的旋转操作，考察链表指针的移动技巧。
旋转类问题的核心是找到元素的新位置，无论是数组还是链表，掌握位置映射的规律就能轻松解决～
📢 关注不迷路，算法学习更高效！
如果这篇拆解对你有帮助，别忘了关注我的微信公众号【小镇冥想人】～ 后续会持续更新 LeetCode 高频题的阶梯式解题思路，从暴力到最优解层层递进，每道题都搭配详细图文和代码注释，帮你轻松攻克算法难关。
