2024年算法面试高频题解指南【一】_js一个数组a中存有n个整数在不允许，2024年最新真的醉了

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

探讨：

这道题呢是牛客网的面试高频榜单题**NC110 旋转数组，**中等级别,关联的企业和关联职位都要这道题，大家可以拿着这道题好好刷。

分析一下这道题的出现概率是非常大的居然考察数高达87次，这是多么庞大的数字啊，难度也是中等一般，（看下图）通过率也是偏低的；我们知道了为什么我拿这道题讲解的原因了吧！所以很有必要看看

题目主要信息:

• 一个长度为nnn的数组，将数组整体循环右移mmm个位置（mmm可能大于nnn）
• 循环右移即最后mmm个元素放在数组最前面，前n−mn-mn−m个元素依次后移
• 不能使用额外的数组空间

算法思想一：使用额外数组

解题思路：

可以使用额外的数组来将每个元素放至正确的位置。遍历原数组，将原数组下标为 i 的元素放至新数组下标为 (i+m) mod n （为了防止右移的长度大于数组的长度，所以才有取余）的位置，最后返回新数组即可

图解：

代码展示：

JAVA版本

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23	import java.util.*; public class Solution { /** * 旋转数组 * @param n int整型 数组长度 * @param m int整型 右移距离 * @param a int整型一维数组 给定数组 * @return int整型一维数组 */ public int``[] solve (``int n,``int m,``int``[] a) { // write code here // 额外新数组 int``[] newArr =``new int``[n]; // 遍历原数组 for (``int i =``0``; i < n; ++i) { // 数组元素旋转 newArr[(i + m) % n] = a[i]; } return newArr; } }

复杂度分析

时间复杂度 O(n)：其中 n 为数组的长度，遍历数组时间O(n)

空间复杂度O(n)： 额外新数组占用空间

算法思想二：数组翻转

解题思路：

该方法基于如下的事实：将数组的元素向右移动 k 次后，尾部 m mod n 个元素会移动至数组头部，其余元素向后移动 m mod n 个位置。
该方法为数组的翻转：翻转算法参考 反转链表中的双指针方法 题解 | #反转链表#_牛客博客

1、可以先将所有元素翻转，这样尾部的 m mod n 个元素就被移至数组头部，

2、然后再翻转 [0,m mod n−1] 区间的元素

3、 最后翻转[m mod n,n−1] 区间的元素即能得到最后的答案。

实例：
以 n=7，m=3 为例进行如下展示：

操作	结果
原始数据	【1，2，3，4，5，6，7】
翻转所有元素	【7，6，5，4，3，2，1】
翻转 [0,m mod n −1] 区间的元素	【5，6，7，4，3，2，1】
翻转 [m mod n, n −1] 区间的元素	【5，6，7，1，2，3，4】

最后返回：【5，6，7，1，2，3，4】

代码展示：

Python版本

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class Solution: def solve(``self , n , m , a ): # write code here m``= m``% n # 数组反转 # 翻转全部 self``.reverse(a,``0``, n``- 1``); # 再翻转 【0，m-1】 self``.reverse(a,``0``, m``- 1``); # 再翻转 【m，n-1】 self``.reverse(a, m, n``- 1``); return a   def reverse(``self``, nums, start, end): # 数组翻转 while start < end : # 双指针遍历翻转 temp``= nums[start]; nums[start]``= nums[end]; nums[end]``= temp; start``+``= 1``; end``-``= 1``;

复杂度分析

时间复杂度：O(N)，其中 N 为数组的长度。每个元素被翻转两次，一共 N 个元素，因此总时间复杂度为 O(2N)=O(N)。
空间复杂度：O(1)。使用常数级空间变量

算法思想三：数组变换

解题思路：

简单便利的方法：数组直接变换

1、tmp = m mod n，找到右移的距离

2、采用 a[:tmp], a[tmp:] = a[-tmp:],a[:n-tmp] 直接变换

代码展示：

Python版本

1 2 3 4 5 6 7 8	class Solution: def solve(``self , n , m , a ): # write code here # 获取移动的距离 tmp``= m``% n # 交换移动数组 a[:tmp], a[tmp:]``= a[``-``tmp:],a[:n``-``tmp] return a

复杂度分析

时间复杂度：O(n)，其中 n 为数组的长度。一共移动n个元素
空间复杂度：O(1)。使用常数级空间变量

举一反三：

学习完本题的思路你可以解决如下题目：

BM99. 顺时针旋转矩阵

方法：三次翻转（推荐使用）

思路：

循环右移相当于从第mmm个位置开始，左右两部分视作整体翻转。即abcdefg右移3位efgabcd可以看成AB翻转成BA（这里小写字母看成数组元素，大写字母看成整体）。既然是翻转我们就可以用到reverse函数。

具体做法:

• step 1：因为mmm可能大于nnn，因此需要对nnn取余，因为每次长度为nnn的旋转数组相当于没有变化。
• step 2：第一次将整个数组翻转，得到数组的逆序，它已经满足了右移的整体出现在了左边。
• step 3：第二次就将左边的mmm个元素单独翻转，因为它虽然移到了左边，但是逆序了。
• step 4：第三次就将右边的n−mn-mn−m个元素单独翻转，因此这部分也逆序了。

图示：

Java代码实现:

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

public class Solution { public int``[] solve (``int n,``int m,``int``[] a) { //取余，因为每次长度为n的旋转数组相当于没有变化 m = m % n; //第一次逆转全部数组元素 reverse(a,``0``, n -``1``); //第二次只逆转开头m个 reverse(a,``0``, m -``1``); //第三次只逆转结尾m个 reverse(a, m, n -``1``); return a; } //反转函数 public void reverse(``int``[] nums,``int start,``int end){ while``(start < end){ swap(nums, start++, end--); } } //交换函数 public void swap(``int``[] nums,``int a,``int b){ int temp = nums[a]; nums[a] = nums[b]; nums[b] = temp; } }

C++代码实现:

1 2 3 4 5 6 7 8 9 10 11 12 13 14	class Solution { public``: vector<``int``> solve(``int n,``int m, vector<``int``>& a) { //取余，因为每次长度为n的旋转数组相当于没有变化 m = m % n; //第一次逆转全部数组元素 reverse(a.begin(), a.end()); //第二次只逆转开头m个 reverse(a.begin(), a.begin() + m); //第三次只逆转结尾m个 reverse(a.begin() + m, a.end()); return a; } };

Python实现代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	class Solution: def solve(self , n:``int``, m:``int``, a: List[``int``]) -> List[``int``]: #取余，因为每次长度为n的旋转数组相当于没有变化 m = m % n #第一次逆转全部数组元素 a.reverse() b = a[:m] #第二次只逆转开头m个 b.reverse() c = a[m:] #第三次只逆转结尾m个 c.reverse() a[:m] = b a[m:] = c return a

复杂度分析：

• 时间复杂度：O(n)O(n)O(n)，三次reverse函数的复杂度都最坏为O(n)O(n)O(n)
• 空间复杂度：O(1)O(1)O(1)，没有使用额外的辅助空间

接下来再来一道

2.NC78 反转链表

描述：

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0\leq n\leq10000≤n≤1000

要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。

如当输入链表**{1,2,3}**时，

经反转后，原链表变为**{3,2,1}，所以对应的输出为{3,2,1}**。

以上转换过程如下图所示：

我们看输出样式

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */

/**
 * 
 * @param pHead ListNode类 
 * @return ListNode类
 */
struct ListNode* ReverseList(struct ListNode* pHead ) {
    // write code here
}

相关企业职位有百度快手，大企 …

解法一：迭代

• 在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

图解：

Java参考代码：

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

/* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } }*/ public class Solution { public ListNode ReverseList(ListNode head) { //pre指针：用来指向反转后的节点，初始化为null ListNode pre =``null``; //当前节点指针 ListNode cur = head; //循环迭代 while``(cur!=``null``){ //Cur_next 节点，永远指向当前节点cur的下一个节点 ListNode Cur_next = cur.next; //反转的关键：当前的节点指向其前一个节点(注意这不是双向链表，没有前驱指针) cur.next = pre; //更新pre pre = cur; //更新当前节点指针 cur = Cur_next ; } //为什么返回pre？因为pre是反转之后的头节点 return pre; } }

复杂度分析：

时间复杂度：O(N)，其中 N 是链表的长度。需要遍历链表一次。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

，其中 N 是链表的长度。需要遍历链表一次。

[外链图片转存中…(img-ZTDuQmHF-1715664094944)]
[外链图片转存中…(img-35ABKdBY-1715664094944)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！