【算法面试题汇总】LeetBook列表的算法面试题汇总---数组题目及答案
如果有错的还请各位大佬指出呀
有些是copy的还望不要介意
本人只做学习记录
数组
-
-
- 乘积最大子数组
- 多数元素
- 旋转数组
- 存在重复元素
- 移动零
- 打乱数组
- 两个数组的交集Ⅱ
- 递增的三元子序列
- 搜索二维矩阵Ⅱ
- 除自身以外数组的乘积
-
乘积最大子数组
题目描述：
给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
测试用例的答案是一个 32-位 整数。
子数组 是数组的连续子序列。
示例：
输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
- 代码实现
class Solution {
public int maxProduct(int[] nums) {
int max = Integer.MIN_VALUE,mx = 1,mi = 1;
for(int i=0;i<nums.length;i++){
//出现负数时，会导致大的变小，小的变大
//mx=6 6*(-2)=-12 mi=3 3*(-2)=-6
//所以先交换mx和mi再进行计算
//这也是为什么要维护mi的原因
if(nums[i]<0){
int temp = mx;
mx = mi;
mi = temp;
}
mx = Math.max(mx*nums[i],nums[i]);
mi = Math.min(mi*nums[i],nums[i]);
max = Math.max(max,mx);
}
return max;
}
}
多数元素
题目描述：
给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例：
输入：nums = [2,2,1,1,1,2,2]
输出：2
- 排序
class Solution {
public int majorityElement(int[] nums) {
Arrays.sort(nums);
return nums[nums.length/2];
}
}
- Boyer-Moore 投票
class Solution {
public int majorityElement(int[] nums) {
//先假设第一个数是众数，票数为1
int num = nums[0],count = 1;
for(int i=1;i<nums.length;i++){
//与假设的众数值相同则票数+1
if(num == nums[i]){
count++;
}else{
//值不同则-1
count--;
//若此时票数为0了，则替换众数
if(count==0){
num = nums[i];
count = 1;
}
}
}
//因为存在多数元素，所以每个众数元素与其他元素进行抵消，剩下的便是众数
return num;
}
}
旋转数组
题目描述：
给你一个数组，将数组中的元素向右轮转 `k` 个位置，其中 `k` 是非负数
示例：
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]
- 额外的数组
class Solution {
public void rotate(int[] nums, int k) {
int n = nums.length;
//防止原本的数丢失
int[] newNums = new int[n];
for(int i = 0;i<n;i++){
//k可能大过n
newNums[(i+k)%n] = nums[i];
}
//深拷贝,源数组，原数组起始位置，目标数组，目标数组起始位置，复制的元素数量
System.arraycopy(newNums,0,nums,0,n);
}
}
进阶：
尽可能想出更多的解决方案，至少有 **三种** 不同的方法可以解决这个问题。
你可以使用空间复杂度为 `O(1)` 的 **原地** 算法解决这个问题吗？
- 翻转数组
class Solution {
public void rotate(int[] nums, int k) {
//k可能大于n，直接取余可以获取最终位置
k = k%nums.length;
//先将整个数组反转
reverse(nums,0,nums.length-1);
//以k为切割分别反转
reverse(nums,0,k-1);
reverse(nums,k,nums.length-1);
}
private void reverse(int[] nums,int i,int j){
while(i<j){
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
i++;
j--;
}
}
}
存在重复元素
题目描述：
给你一个整数数组 `nums` 。如果任一值在数组中出现 **至少两次** ，返回 `true` ；如果数组中每个元素互不相同，返回 `false` 。
示例：
输入：nums = [1,2,3,1]
输出：true
- 排序
时间O(nlogn)空间O(logn)
class Solution {
public boolean containsDuplicate(int[] nums) {
Arrays.sort(nums);
int n = nums.length;
for(int i=0;i<n-1;i++){
//排好序后相邻的相等
if(nums[i] == nums[i+1]){
return true;
}
}
return false;
}
}
- 哈希表
时间O(n)，空间O(n)
class Solution {
public boolean containsDuplicate(int[] nums) {
Set<Integer> set = new HashSet<>();
for(int i=0;i<nums.length;i++){
//hashset如果插入已存在的元素则会返回false
if(!set.add(nums[i])){
return true;
}
}
return false;
}
}
移动零
题目描述：
给定一个数组 `nums`，编写一个函数将所有 `0` 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例：
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
进阶： 你能尽量减少完成的操作次数吗？
-
代码实现
时间O(n)空间O(1)
class Solution {
public void moveZeroes(int[] nums) {
if(nums == null){
return;
}
int i=0,j = 0;
for(;i<nums.length;i++){
if(nums[i] != 0){
int temp = nums[i];
nums[i] = nums[j];
nums[j++] = temp;
}
}
}
}
打乱数组
题目描述：
给你一个整数数组 nums ，设计算法来打乱一个没有重复元素的数组。打乱后，数组的所有排列应该是 等可能 的。
实现 Solution class:
Solution(int[] nums) 使用整数数组 nums 初始化对象
int[] reset() 重设数组到它的初始状态并返回
int[] shuffle() 返回数组随机打乱后的结果
示例：
输入
["Solution", "shuffle", "reset", "shuffle"]
[[[1, 2, 3]], [], [], []]
输出
[null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]
解释
Solution solution = new Solution([1, 2, 3]);
solution.shuffle(); // 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。例如，返回 [3, 1, 2]
solution.reset(); // 重设数组到它的初始状态 [1, 2, 3] 。返回 [1, 2, 3]
solution.shuffle(); // 随机返回数组 [1, 2, 3] 打乱后的结果。例如，返回 [1, 3, 2]
- 代码实现
class Solution {
int[] nums;
int[] tnums;
public Solution(int[] nums) {
this.nums = nums;
this.tnums = new int[nums.length];
//调用java内存模型中本地方法栈区
System.arraycopy(nums,0,tnums,0,nums.length);
}
public int[] reset() {
return tnums;
}
public int[] shuffle() {
//洗牌算法
Random random = new Random();
int n = nums.length;
for(int i=0;i<n;i++){
int j = i+random.nextInt(n - i);
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
return nums;
}
}
/**
* Your Solution object will be instantiated and called as such:
* Solution obj = new Solution(nums);
* int[] param_1 = obj.reset();
* int[] param_2 = obj.shuffle();
*/
两个数组的交集Ⅱ
题目描述：
给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。
示例：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]
进阶：
如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小，哪种方法更优？
如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
-
哈希表
时间O(m+n)空间O(min(m,n))
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
if(nums1.length > nums2.length){
intersect(nums2,nums1);
}
Map<Integer,Integer> map = new HashMap<>();
for(int num:nums1){
int count = map.getOrDefault(num,0) + 1;
map.put(num,count);
}
int[] temp = new int[nums1.length];
int index = 0;
for(int num:nums2){
int count = map.getOrDefault(num,0);
if(count > 0){
temp[index++] = num;
count--;
if(count > 0){
map.put(num,count);
}else{
map.remove(num);
}
}
}
return Arrays.copyOfRange(temp,0,index);
}
}
-
双指针
时间O(mlogm+nlogn)，空间O(min(m,n))
class Solution {
public int[] intersect(int[] nums1, int[] nums2) {
Arrays.sort(nums1);
Arrays.sort(nums2);
int length1 = nums1.length,length2 = nums2.length;
int[] temp = new int[Math.min(length1,length2)];
int i = 0,j = 0,index = 0;
while(i<length1 && j<length2){
//两个元素不相等则小的那个指针右移动
if(nums1[i] < nums2[j]){
i++;
}else if(nums1[i] > nums2[j]){
j++;
}else if(nums1[i] == nums2[j]){
//相等则添加，并指针都右移
temp[index] = nums1[i];
index++;
i++;
j++;
}
}
return Arrays.copyOfRange(temp,0,index);
}
}
递增的三元子序列
题目描述：
给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。
如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。
示例：
输入：nums = [1,2,3,4,5]
输出：true
解释：任何 i < j < k 的三元组都满足题意
进阶： 你能实现时间复杂度为 O(n) ，空间复杂度为 O(1) 的解决方案吗？
-
贪心
时间O(n)空间O(1)
class Solution {
public boolean increasingTriplet(int[] nums) {
int f = nums[0],s = Integer.MAX_VALUE;
int n = nums.length;
if(n < 3){
return false;
}
//保证第二个值比第一个值大，此时只要找到第三个数便可
for(int i=1;i<n;i++){
if(nums[i] > s){
//如果第三个数比第二个数大则满足
return true;
}else if(nums[i] > f){
//比第二个数小比第一个数大则将该值赋给第二个数，继续找第三个数
s = nums[i];
}else{
//比第一个数小则将该值赋给第一个数，此时新的第一个值就在旧第二个值前面
f = nums[i];
}
}
return false;
}
}
搜索二维矩阵Ⅱ
题目描述：
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：
每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
示例：
输入：matrix = [[1,4,7,11,15],
[2,5,8,12,19],
[3,6,9,16,22],
[10,13,14,17,24],
[18,21,23,26,30]], target = 5
输出：true
- 代码实现
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int row = matrix.length - 1;
int col = matrix[0].length;
int temp=0;
while(row>=0 || temp<=col-1){
if(matrix[row][temp] == target){
return true;
}else if(matrix[row][temp] < target){
temp++;
if(temp > col-1) return false;
}else if(matrix[row][temp] > target){
row--;
if(row < 0) return false;
}
}
return false;
}
}
除自身以外数组的乘积
题目描述：
给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。
请不要使用除法，且在 O(n) 时间复杂度内完成此题
进阶：你可以在 O(1) 的额外空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组**不被视为额外空间。）
示例：
输入: nums = [1,2,3,4]
输出: [24,12,8,6]
- 代码实现
class Solution {
public int[] productExceptSelf(int[] nums) {
int n = nums.length;
int[] answer = new int[n];
int l=1,r = 1;
for(int i=0;i<n;i++){
answer[i] = l;
l *= nums[i];
}
for(int i = n-1;i>0;i--){
r *= nums[i];
//该位置的值等于左边所有的元素乘积乘以右边所有元素的乘积
answer[i-1] *= r;
}
return answer;
}
}