力扣-数组-数组的遍历

国服最强貂蝉

已于 2023-11-08 20:04:43 修改

阅读量45

点赞数

分类专栏： C++ 文章标签： c++ 算法 leetcode

于 2021-02-18 21:35:17 首次发布

本文链接：https://blog.csdn.net/zrg_hzr_1/article/details/113850077

版权

C++ 专栏收录该内容

26 篇文章 113 订阅

订阅专栏

这篇博客介绍了数组中几种常见的算法问题，包括最大连续1的个数、中毒状态总时长、第三大的数以及三个数的最大乘积。文章通过代码示例展示了如何使用双指针、排序以及线性扫描等方法解决这些问题，强调了时间复杂度和空间复杂度的优化。

摘要由CSDN通过智能技术生成

485 最大连续 1 的个数

485 最大连续 1 的个数
给定一个二进制数组，计算其中最大连续 1 的个数。

事例

输入：[1,1,0,1,1,1]
输出：3
解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.

提示

输入的数组只包含 0 和 1 。
输入数组的长度是正整数，且不超过 10,000。

双指针我重拳出击

class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int result = 0;
        int l = 0;
        int r = 0;
        int n = nums.size();

        while(r < n) {
            nums[r] == 1 ? ++r : l = ++r;
            result = max(result, r - l);
        }
        return result;
    }
};

时间复杂度：O(n)，其中 n 是数组的长度。需要遍历数组一次。
空间复杂度：O(1)。

495 提莫攻击

495 提莫攻击
在《英雄联盟》的世界中，有一个叫 “提莫” 的英雄，他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。现在，给出提莫对艾希的攻击时间序列和提莫攻击的中毒持续时间，你需要输出艾希的中毒状态总时长。
你可以认为提莫在给定的时间点进行攻击，并立即使艾希处于中毒状态。

示例1:

输入: [1,4], 2
输出: 4
原因: 第 1 秒初，提莫开始对艾希进行攻击并使其立即中毒。中毒状态会维持 2 秒钟，直到第 2 秒末结束。
第 4 秒初，提莫再次攻击艾希，使得艾希获得另外 2 秒中毒时间。
所以最终输出 4 秒。

示例2:

输入: [1,2], 2
输出: 3
原因: 第 1 秒初，提莫开始对艾希进行攻击并使其立即中毒。中毒状态会维持 2 秒钟，直到第 2 秒末结束。
但是第 2 秒初，提莫再次攻击了已经处于中毒状态的艾希。
由于中毒状态不可叠加，提莫在第 2 秒初的这次攻击会在第 3 秒末结束。
所以最终输出 3 。

提示：

你可以假定时间序列数组的总长度不超过 10000。
你可以假定提莫攻击时间序列中的数字和提莫攻击的中毒持续时间都是非负整数，并且不超过 10,000,000。

英雄联盟我也重拳出击

class Solution {
public:
    int findPoisonedDuration(vector<int>& timeSeries, int duration) {
        int n = timeSeries.size();
        if (n == 0) return 0;
        int ans = 0;
        for (int i = 0; i < n - 1; ++i) ans += min(timeSeries[i + 1] - timeSeries[i], duration);
        return ans + duration;
    }
};

时间复杂度：O(N)，其中 N 是数组 A 的长度。
空间复杂度：O(1)。

414 第三大的数

414 第三大的数
给你一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。

示例 1：

输入：[3, 2, 1]
输出：1
解释：第三大的数是 1 。

示例 2：

输入：[1, 2]
输出：2
解释：第三大的数不存在, 所以返回最大的数 2 。

示例 3：

输入：[2, 2, 3, 1]
输出：1
解释：注意，要求返回第三大的数，是指第三大且唯一出现的数。
存在两个值为2的数，它们都排第二。

提示：

1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1

进阶：你能设计一个时间复杂度 O(n) 的解决方案吗？

1. 用三个变量记录最大的三个数，遍历的同时更新

三个循环，t是判断是否有三个（不一样的）数，如果有，那就会进入第三个循环改变t的值。复杂度还是O((k)n)，k为3的时候k就是常数，时间复杂度为o(n)好像也没啥问题。k值小时比set高效。

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        int max1 = INT_MIN, max2 = INT_MIN, max3 = INT_MIN, n = nums.size(), t = 0;
        for (int i = 0; i < n; i++) max1 = max(max1, nums[i]);
        for (int i = 0; i < n; i++) if (nums[i] != max1) max2 = max(max2, nums[i]);
        for (int i = 0; i < n; i++) if (nums[i] != max1 && nums[i] != max2) {
            if (nums[i] >= max3) {
                max3 = nums[i];
                t++;
            }
        }
        return (t == 0) ? max1 : max3;
    }
};

利用set中元素的有序性和唯一性，将元素放入set中，若set的size不小于3输出倒数第三个元素；若set的size小于3，输出最后一个元素。

c.begin(); 返回指向容器最开始位置数据的指针
c.end(); 返回指向容器最后一个数据单元+1的指针

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        set<int> s(nums.begin(), nums.end());
        auto it = s.end();
        it--;
        if (s.size() >= 3) {
            it--;
            it--;
        }
        return *it;
    }
};

628 三个数的最大乘积

给你一个整型数组 nums ，在数组中找出由三个数组成的最大乘积，并输出这个乘积。

示例 1：

输入：nums = [1,2,3]
输出：6

示例 2：

输入：nums = [1,2,3,4]
输出：24

示例 3：

输入：nums = [-1,-2,-3]
输出：-6

提示：

3 <= nums.length <= 104
-1000 <= nums[i] <= 1000

排序
考虑三种情况两行解决

三种情况

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        return max(nums[nums.size() - 1] * nums[nums.size() - 2] * nums[nums.size() - 3], nums[0] * nums[1] * nums[nums.size() - 1]);
    }
};

时间复杂度：O(NlogN)，其中 N 为数组长度。排序需要 O(NlogN) 的时间。
空间复杂度：O(logN)，主要为排序的空间开销。

线性扫描

不用排序，用线性扫描直接得出这五个数（数组中最大的三个数以及最小的两个数）

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        int min1 = INT_MAX, min2 = INT_MAX;   // 最小第二小
        int max1 = INT_MIN, max2 = INT_MIN, max3 = INT_MIN;   // 最大第二大第三大

        for(int x: nums){
            if (x < min1) {
                min2 = min1;
                min1 = x;
            } 
            else if (x < min2) min2 = x;

            if (x > max1) {
                max3 = max2;
                max2 = max1;
                max1 = x;
            }
            else if (x > max2) {
                max3 = max2;
                max2 = x;
            }
            else if (x > max3) max3 = x;
        }
        return max(min1 * min2 * max1, max1 * max2 * max3);        
    }
};