力扣高频|算法面试题汇总(三）：数组

力扣高频|算法面试题汇总(一）：开始之前
力扣高频|算法面试题汇总(二）：字符串
力扣高频|算法面试题汇总(三）：数组
力扣高频|算法面试题汇总(四）：堆、栈与队列
力扣高频|算法面试题汇总(五）：链表
力扣高频|算法面试题汇总(六）：哈希与映射
力扣高频|算法面试题汇总(七）：树
力扣高频|算法面试题汇总(八）：排序与检索
力扣高频|算法面试题汇总(九）：动态规划
力扣高频|算法面试题汇总(十）：图论
力扣高频|算法面试题汇总(十一）：数学&位运算

力扣高频|算法面试题汇总(三）：数组

力扣链接
目录：

• 1.乘积最大子数组
• 2.多数元素
• 3.旋转数组
• 4.存在重复元素
• 5.移动零
• 6.打乱数组
• 7.两个数组的交集 II
• 8.递增的三元子序列
• 9.搜索二维矩阵 II
• 10.除自身以外数组的乘积

1.乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字）。
示例 1:
输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
示例 2:
输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组

思路一：暴力，这就不做多介绍了。

思路二：
循环求解，这有点想剑指offer中的《连续子数组的最大和》
同时也参考了思路
需要从前向后遍历数组，

• 记录当前遍历到的局部最大值和全局最大值，然后两者随着遍历的进行不断的比较。
• 由于负数的出现，需要额外增加一个当前局部最小值变量，在遍历到负数的时候，局部最小值和局部最大值需要做交换，从而解决负数导致的“颠倒”问题。
  以序列[2,3,-2,4]为例：
  
  C++

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int Max;
        int imax = 1; 
        int imin = 1;
        for(int i = 0; i < nums.size(); ++i){
            if(nums[i] < 0){
                // 如果是负数，则交换局部最大值和最小值
                int temp = imax;
                imax = imin;
                imin = temp;
            }
            // 局部最大值
            imax = (imax * nums[i] > nums[i]) ? imax * nums[i] : nums[i];
            // 局部最小值
            imin = (imin * nums[i] < nums[i]) ? imin * nums[i] : nums[i];
            // 局部最大值和最大值进行比较
            if(i == 0)
                Max = imax;
            else
                Max = Max > imax ? Max :imax;
        } 
        return Max;
    }
};

Python

class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        imax = 1
        imin = 1
        for i in range(len(nums)):
            if nums[i] < 0:
                imax, imin = imin, imax
            imax = max(imax*nums[i], nums[i])
            imin = min(imin*nums[i], nums[i])
            if i == 0:
                Max = imax
            else:
                Max = max(Max, imax)
        return Max

2.多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例 1:
输入: [3,2,3]
输出: 3
示例 2:
输入: [2,2,1,1,1,2,2]
输出: 2

思路：排序，出现在数组中间的那个数字一定是出现次数大于n/2的元素。
其余解法可参考《数组中出现超过一半的数字》
C++

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        // 排序
        sort(nums.begin(), nums.end());
        return nums[nums.size() / 2];
    }
};

Python

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        nums = sorted(nums)
        return nums[len(nums)//2]

3.旋转数组

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
示例 1:
输入: [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]
示例 2:
输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
说明:
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的 原地 算法。

思路1：暴力循环，成功超时。

思路2：
直接计算元素移动的最终位置。比如移动k次，那么索引为i的元素会被移动到(i + k)%n的位置上去，其中n是数组的长度。但是这样会存在一个问题：无法全部移动，以输入nums: [1, 2, 3, 4, 5, 6];k: 2为例。挨着交换i%k==0上的元素，是无法交换全部的元素的，所以当完成索引满足i%k==0的元素交换之后，需要对i%k==1上的元素进行交换，一共交换n次。如力扣官方图示：

C++

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int temp;
        int counts = 0;
        k = k % nums.size();
        for(int start = 0; counts < nums.size(); ++start){
            int currentID = start;
            int pre = nums[start];
            do{
                int nextID = (currentID + k)% nums.size();
                temp = nums[nextID];
                nums[nextID] = pre;
                pre = temp;
                ++counts;
                currentID = nextID;
            }while(currentID != start);
        }

    }
};

Python:

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        k = k % len(nums)
        start = 0
        counts = 0
        while counts < len(nums):
            currentID = start
            pre = nums[currentID]
            while True:
                nextID = (currentID + k) % len(nums)
                nums[nextID], pre = pre, nums[nextID]
                counts += 1
                currentID = nextID
                if currentID == start:
                    start += 1
                    break

思路3：
翻转，这个和剑指offer的《翻转单词顺序》类似。
一下参考力扣官方：

• 这个方法基于这个事实：当我们旋转数组 k 次， k%nk%n 个尾部元素会被移动到头部，剩下的元素会被向后移动。
• 在这个方法中，我们首先将所有元素反转。然后反转前 k 个元素，再反转后面 n-kn−k 个元素，就能得到想要的结果。

假设 n=7n=7 且 k=3k=3 。
原始数组                  : 1 2 3 4 5 6 7
反转所有数字后             : 7 6 5 4 3 2 1
反转前 k 个数字后          : 5 6 7 4 3 2 1
反转后 n-k 个数字后        : 5 6 7 1 2 3 4 --> 结果

C++

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int temp;
        k = k % nums.size();
        int pStart = 0;
        int pEnd = nums.size() - 1;
        while(pStart < pEnd){
            temp = nums[pStart];
            nums[pStart] = nums[pEnd];
            nums[pEnd] = temp;
            ++pStart;
            --pEnd;
        }
        pStart = 0;
        pEnd = k - 1;
        while(pStart < pEnd){
            temp = nums[pStart];
            nums[pStart] = nums[pEnd];
            nums[pEnd] = temp;
            ++pStart;
            --pEnd;
        }
        pStart = k;
        pEnd = nums.size() - 1;
        while(pStart < pEnd){
            temp = nums[pStart];
            nums[pStart] = nums[pEnd];
            nums[pEnd] = temp;
            ++pStart;
            --pEnd;
        }
        
    }
};

Python

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        k = k % len(nums)
        start = 0
        counts = 0
        nums.reverse()
        pStart = 0
        pEnd = k-1
        while pStart < pEnd:
            nums[pStart], nums[pEnd] = nums[pEnd], nums[pStart]
            pStart += 1
            pEnd -= 1
        pStart = k
        pEnd = len(nums)-1
        while pStart < pEnd:
            nums[pStart], nums[pEnd] = nums[pEnd], nums[pStart]
            pStart += 1
            pEnd -= 1

4.存在重复元素

给定一个整数数组，判断是否存在重复元素。
如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true

思路1：
使用哈希表记录每个元素出现的次数，如果第二次遇到该数字，直接return true
C++

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        map<int, int> idHash;
        for(auto itear = nums.begin(); itear < nums.end(); ++itear){
            // 第一次遇到数字
            if(idHash.find(*itear) == idHash.end()){
                idHash[*itear] = 1;
            }else{
                // 第二次遇到
                return true;
            }
        }
        return false;
    }
};

Python

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        idHash = {}
        for num in nums:
            if not num in idHash:
                idHash[num] = 1
            else:
                return True
        return False

5.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

思路：
参考这位博主的思路。
把0元素往后移动，实质上等于把非0元素往前移动。
用一个标志记录非0元素，先把非0元素全部移动到前面，剩下的部分再进行填充。
C++

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
       if(nums.size() == 0)
           return;
        // 记录非0的位置
        int k = 0;
        for(int i = 0; i < nums.size(); ++i){
            if(nums[i] != 0){
                // 移动非0元素
                nums[k] = nums[i];
                ++k;
            }
        }
        // 从k开始填补0、
        while(k < nums.size()){
            nums[k] = 0;
            ++k;
        }
    }
};

Python

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        if len(nums) == 0:
            return
        k = 0
        for i in range(len(nums)):
            if nums[i] != 0:
                nums[k] = nums[i]
                k += 1
        while k < len(nums):
            nums[k] = 0
            k = k + 1

6.打乱数组

打乱一个没有重复元素的数组。
示例:
// 以数字集合 1, 2 和 3 初始化数组。
int[] nums = {1,2,3};
Solution solution = new Solution(nums);
// 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。
solution.shuffle();
// 重设数组到它的初始状态[1,2,3]。
solution.reset();
// 随机返回数组[1,2,3]打乱后的结果。
solution.shuffle();

C++

class Solution {
private:
    vector<int> stroeNums;
    vector<int> shuffleNums;
    
public:
    Solution(vector<int>& nums) {
        stroeNums = nums;
    }
    
    /** Resets the array to its original configuration and return it. */
    vector<int> reset() {
        return stroeNums;
    }
    
    /** Returns a random shuffling of the array. */
    vector<int> shuffle() {
        shuffleNums = stroeNums;
        random_shuffle(shuffleNums.begin(),shuffleNums.end());
        return shuffleNums;
    }
};

/**
 * Your Solution object will be instantiated and called as such:
 * Solution* obj = new Solution(nums);
 * vector<int> param_1 = obj->reset();
 * vector<int> param_2 = obj->shuffle();
 */

Python:

class Solution:
    
    def __init__(self, nums: List[int]):
        self.storeNum = nums

    def reset(self) -> List[int]:
        """
        Resets the array to its original configuration and return it.
        """
        return self.storeNum

    def shuffle(self) -> List[int]:
        """
        Returns a random shuffling of the array.
        """
        shuffleNums = self.storeNum.copy()
        random.shuffle(shuffleNums)
        return shuffleNums
# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.reset()
# param_2 = obj.shuffle()

7.两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
进阶:
如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

思路1：
本题的交集是不考虑顺序的，也就是等同于找出两个数组共同的数字。
那么首先遍历第一个数字，建立哈希表，记录每个数字出现的次数。
再遍历第二个数字，如果哈希表存在这个数字，且这个数字的次数大于0，那么为其中一个答案，且将出现的次数减1。
C++

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        map<int, int> idHash;
        for(auto num : nums1){
            // 第一次遇到字符
            if(idHash.find(num) == idHash.end()){
                idHash[num] = 1;
            }else{
                ++idHash[num];
            }
        }
        vector<int> ans;
        for( auto num : nums2){
            // 如果有字符，且大于0
            if(idHash.find(num) != idHash.end() && idHash[num] > 0){
                --idHash[num];
                ans.push_back(num);
            }
        }
        return ans;
    }
};

Python

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        idHash = {}
        for num in nums1:
            if not num in idHash:
                idHash[num] = 1
            else:
                idHash[num] += 1
        ans = []
        for num in nums2:
            if num in idHash and idHash[num] > 0:
                idHash[num] -= 1
                ans.append(num)
        return ans

思路2：
对两个数字进行排序，小的前，大的在后。依次比较两个数组的值，如果值相等，则为共同元素。如果数组1的值大于数组2的值，则把数组2的索引加1反之对数组1的索引加1（因为排序的缘故）。
C++

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans;
        // 排序
        sort(nums1.begin(), nums1.end());
        sort(nums2.begin(), nums2.end());
        
        size_t index1 = 0;
        size_t index2 = 0;
        while( index1 < nums1.size() && index2 <nums2.size()){
            if(nums1[index1] == nums2[index2]){
                ans.push_back(nums1[index1]);
                ++index1;
                ++index2;
                    
            }else if(nums1[index1] > nums2[index2]){
                ++index2;
            }else if(nums1[index1] < nums2[index2]){
                ++index1;
            }
        
        }
        return ans;                 
    }
};

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        ans = []
        nums1 = sorted(nums1)
        nums2 = sorted(nums2)
        index1 = 0
        index2 = 0
        while index1 < len(nums1) and index2 < len(nums2):
            if nums1[index1] == nums2[index2]:
                ans.append(nums1[index1])
                index1 += 1
                index2 += 1
            elif nums1[index1] < nums2[index2]:
                index1 += 1
            else:
                index2 += 1
        return ans

8.递增的三元子序列

给定一个未排序的数组，判断这个数组中是否存在长度为 3 的递增子序列。
数学表达式如下:
如果存在这样的 i, j, k, 且满足 0 ≤ i < j < k ≤ n-1，
使得 arr[i] < arr[j] < arr[k] ，返回 true ; 否则返回 false 。
说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1) 。
示例 1:
输入: [1,2,3,4,5]
输出: true
示例 2:
输入: [5,4,3,2,1]
输出: false

思路1：
参考这位大佬的思路。
思路非常的巧妙。
1.使用两个变量small和mid，用来保存序列的最小值和中间值，且满足关系small<mid。
2.遍历数组，遇到的值num，如果比small小，则替换small。如果比mid小，则替换mid。如果比mid大，则找到递增序列。
3.比较巧妙的地方1.：如果遇到比small小的值，则替换。比如序列small和mid为[4,9],当遇到num=1时，则small和mid则变为[1, 9]。如果不替换这个small，那么接下来遇到2，3，其实是存在递增序列的，但却没有找到，所以需要替换。
4.比较巧妙的地方2.：当[4, 9]被替换成[1, 9]之后，虽然1和9不是序列递增的关系，但是当遇到的num比mid（即9）大，仍然是存在递增序列的，这是因为即使我们更新了 small ，这个 small 在 mid 后面，没有严格遵守递增顺序，但它隐含着的真相是，有一个比 small 大比 mid 小的前·最小值出现在 mid 之前。因此，当后续出现比 mid 大的值的时候，我们一样可以通过当前 small 和 mid 推断的确存在着长度为 3 的递增序列。 所以，这样的替换并不会干扰后续的计算。
C++

class Solution {
public:
    bool increasingTriplet(vector<int>& nums) {
        int small = INT_MAX;
        int mid = INT_MAX;
        for(auto num : nums){
            if(num <= small){
                small = num;
            }else if(num <= mid){
                mid = num;
            }else{
                return true;
            }
        }
        return false;
    }
};

Python

class Solution:
    def increasingTriplet(self, nums: List[int]) -> bool:
        small = sys.maxsize
        mid = sys.maxsize
        for num in nums:
            if num <= small:
                small = num
            elif num <= mid:
                mid = num
            else:
                return True
        return False

思路2：
动态规划，每次寻找比当前数小的元素个数，当大于等于3时则退出。
C++

class Solution {
public:
    bool increasingTriplet(vector<int>& nums) {
        int size = nums.size();
        vector<int> dp(size, 1);
        for(int i = 0; i < nums.size(); ++i)
            for(int j = 0; j < i; ++j){
                // 从左边开始计算比i小的数
                if(nums[j] < nums[i]){
                    dp[i] = max(dp[i], dp[j] + 1);
                }
                if(dp[i] >= 3)
                    return true;
            }
        return false;
    }
};

Python

class Solution:
    def increasingTriplet(self, nums: List[int]) -> bool:
        dp = [1] * len(nums)
        for i in range(len(nums)):
            for j in range(0, i):
                if nums[j] < nums[i]:
                    dp[i] = max(dp[i], dp[j] + 1)
                if dp[i] >= 3:
                    return True
        return False

9.搜索二维矩阵 II

见：力扣高频|算法面试题汇总(一）：开始之前

10.除自身以外数组的乘积

给你一个长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
示例:
输入: [1,2,3,4]
输出: [24,12,8,6]
提示：题目数据保证数组之中任意元素的全部前缀元素和后缀（甚至是整个数组）的乘积都在 32 位整数范围内。
说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。
进阶：
你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）

思路1：

首先这题是不能使用除法的。假设有数组$[a_0,a_1,a_2,a_3]$,那么得到的答案为：$[a_1{a}_2{a}_3,a_0{a}_2{a}_3,a_0{a}_1{a}_3,a_0{a}_1{a}_2]$。拆分答案，可以得到的数组$[1,a_0,a_0{a}_1,a_0{a}_1{a}_2]$和$[a_1{a}_2{a}_3,a_2{a}_3,a_3,1]$,这两个数组分布通过正序和逆序遍历得到。
时间复杂度：$O(N)$，其中 N 指的是输入数组的大小。
空间复杂度：$O(N)$，使用了 L 和 R 数组去构造答案
C++

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector<int> temp1(nums.size(), 1);
        vector<int> temp2(nums.size(), 1);
        for(int i = 1; i < nums.size(); ++i){
            temp1[i] = temp1[i - 1] * nums[i - 1];
        }
        for(int i = nums.size() - 2; i > -1; --i){
            temp2[i] = temp2[i + 1] * nums[i + 1];
        }
        for(int i = 0; i < nums.size(); ++i){
            temp1[i] *= temp2[i];
        }
        return temp1;
            
    }
};

Python

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        temp1 = [1] * len(nums)
        temp2 = temp1.copy()
        for i in range(1, len(nums)):
            temp1[i] = temp1[i - 1] * nums[i - 1]
        for i in range(len(nums) - 2, -1, -1):
            temp2[i] = temp2[i + 1] * nums[i + 1]
        for i in range(len(nums)):
            temp1[i] *= temp2[i]
        return temp1

思路2：
由于输出数组不算在空间复杂度内，那么可以将 L 或 R 数组在用输出数组来计算，然后再动态构造另一个。也就是首先得到数组得到的数组$[1,a_0,a_0{a}_1,a_0{a}_1{a}_2]$，再使用一个中间变量temp，temp = temp * nums[i]来从1开始到$a_1{a}_2{a}_3$依次赋值。
C++

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector<int> ans(nums.size(), 1);
        for(int i = 1; i < nums.size(); ++i)
            ans[i] = ans[i - 1] * nums[i - 1];
        int temp = 1;
        for(int i = nums.size() -1; i > -1; --i){
            ans[i] = temp * ans[i];
            temp *= nums[i]; 
        }
        return ans;
    }
};

Python

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        ans = [1] * len(nums)
        # 第一次构造
        for i in range(1 , len(nums)):
            ans[i] = ans[i - 1] * nums[i - 1]
        # 使用中间变量，动态构造
        temp = 1
        for i in reversed(range(len(nums))):
            ans[i] = temp * ans[i]
            temp = temp * nums[i]
        return ans