算法面试高频题解指南【一】

Choice～

已于 2022-07-22 17:04:16 修改

阅读量1.6k

点赞数 85

分类专栏：算法与数据结构文章标签： java c++ 数据结构算法面试

于 2022-07-22 17:00:54 首次发布

本文链接：https://blog.csdn.net/weixin_51568389/article/details/125934515

版权

算法与数据结构专栏收录该内容

6 篇文章 25 订阅

订阅专栏

👩‍💻博客主页：choice~的博客主页

✨欢迎关注🖱点赞🎀收藏⭐留言✒

🔮本文由choice~原创，csdn首发！

👕参考网站：牛客网

💻首发时间：🎞2022年7月22日🎠

🎨你的收入跟你的不可替代成正比

🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦
💬给大家介绍一个求职刷题收割offer的地方👉点击进入网站

1.NC110 旋转数组

描述：

一个数组A中存有 n 个整数，在不允许使用另外数组的前提下，将每个整数循环向右移 M（ M >=0）个位置，即将A中的数据由（A0 A1 ……AN-1 ）变换为（AN-M …… AN-1 A0 A1 ……AN-M-1 ）（最后 M 个数循环移至最前面的 M 个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

数据范围：0 < n \le 1000<n≤100，0 \le m \le 10000≤m≤1000

进阶：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

这是C语言给的OJ模块：

/**
 * 旋转数组
 * @param n int整型 数组长度
 * @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 ) {

}

探讨：

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

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

题目主要信息:

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

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

解题思路：

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

图解：

代码展示：

JAVA版本

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版本

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版本

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代码实现:

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++代码实现:

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实现代码：

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
}

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