算法面试高频题解指南【一】_js一个数组a中存有n个整数在不允许(1)

最新推荐文章于 2024-05-30 16:39:23 发布

2401_84141419

最新推荐文章于 2024-05-30 16:39:23 发布

阅读量398

点赞数 5

文章标签：大数据面试学习

本文链接：https://blog.csdn.net/2401_84141419/article/details/138955731

版权

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

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

@param m int整型右移距离
@param a int整型一维数组给定数组
@param aLen int a数组长度
@return int整型一维数组
@return int* returnSize 返回数组行数
/
int solve(int n, int m, int* a, int aLen, int* returnSize ) {

}


#### 探讨：


这道题呢是[牛客网](https://bbs.csdn.net/topics/618545628)的面试高频榜单题**NC110 旋转数组，**中等级别,关联的企业和关联职位都要这道题，大家可以拿着这道题好好刷。


![](https://img-blog.csdnimg.cn/57e4b5ea26614a5f9559eaeee1f1013a.gif)


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


![](https://img-blog.csdnimg.cn/03f4cd15c7774460af0d51bb4d6cb7f9.png)


题目主要信息:



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


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


**解题思路：**


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


**图解：**![](https://img-blog.csdnimg.cn/0503ee529e744863972ead5deaf0926d.png)




### 代码展示：


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 个位置。  
 该方法为数组的翻转：翻转算法参考 反转链表中的双指针方法 [题解 | #反转链表#\_牛客博客](https://bbs.csdn.net/topics/618545628)


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. 顺时针旋转矩阵](https://bbs.csdn.net/topics/618545628)


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


**思路：**



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


**具体做法:**


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


**图示：**![](https://img-blog.csdnimg.cn/07e99d984d2143edb3d6e3c5298b2769.gif)




**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}**。


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


![](https://img-blog.csdnimg.cn/586457b1f13c44228e1005bb3b20236c.png)


 我们看输出样式


![](https://img-blog.csdnimg.cn/a237c9202fa54097a3df1e973dc95dec.png)

/**

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
}


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


![](https://img-blog.csdnimg.cn/79222dc522f542bfb11ab5038ac1ad8f.png)


### 解法一：迭代


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


  
 图解：![](https://img-blog.csdnimg.cn/030ff61c9f664e04a530b0531e03ea51.png)



#### Java参考代码：




![img](https://img-blog.csdnimg.cn/img_convert/98cc284fa4560ecd4d61e75e6dcd641c.png)
![img](https://img-blog.csdnimg.cn/img_convert/d327a1e8c375a5ae5e895b8f3a329760.png)

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

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


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



#### Java参考代码：




[外链图片转存中...(img-ChPliKz7-1715832600661)]
[外链图片转存中...(img-4TciIjPu-1715832600661)]

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

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


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