【LeetCode算法题】414. 第三大的数

不仅要学习，还要改变

已于 2024-01-16 11:44:16 修改

阅读量810

点赞数 17

分类专栏：算法题文章标签：算法 leetcode c++ 面试 stl

于 2024-01-16 11:41:39 首次发布

本文链接：https://blog.csdn.net/qq_46403377/article/details/135619561

版权

算法题专栏收录该内容

3 篇文章 0 订阅

订阅专栏

414. 第三大的数

标签：数组，排序
力扣原题链接，点我直达

题目

给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。

示例1：

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

示例2：

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

示例3：

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

第一个版本：排序

使用set容器并进行从大到小排序，排好序后赋值给vector容器方便随机查找。最后找到第三大的数。

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        set<int,greater<int>> s(nums.begin(),nums.end()); 
        vector<int> v(s.begin(),s.end());
        
        if(v.size()<=2)return v[0];
        return v[2];
    }
};

复杂度分析：

set 的构建：将 nums 中的元素插入到 set 中，set 的构建时间复杂度为 O(n * log(n))，其中 n 是数组的大小。
vector 的构建：将 set 转换为 vector，vector 的构建时间复杂度为 O(n)，其中 n 是 set 的大小。

所以总体时间复杂度为 O(n * log(n))。
空间复杂度：O(n)。

或者添加一个字段来检测是否为第三大数：

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        sort(nums.begin(), nums.end(), greater<int>());
        for (int i = 1, diff = 1; i < nums.size(); ++i) {
            if (nums[i] != nums[i - 1] && ++diff == 3) { // 此时 nums[i] 就是第三大的数
                return nums[i];
            }
        }
        return nums[0];
    }
};

时间复杂度：O(nlog⁡n)，其中 n 是数组 nums 的长度。排序需要 O(nlog⁡n)的时间。
空间复杂度：O(log⁡n)。排序需要的栈空间为 O(log⁡n)。

优化思路：

我们可以遍历数组，同时用一个有序集合来维护数组中前三大的数。具体做法是每遍历一个数，就将其插入有序集合，若有序集合的大小超过 3，就删除集合中的最小元素。这样可以保证有序集合的大小至多为 3，且遍历结束后，若有序集合的大小为 3，其最小值就是数组中第三大的数；若有序集合的大小不足 3，那么就返回有序集合中的最大值。

第二个版本：有序集合

class Solution {
public:
    int thirdMax(vector<int> &nums) {
        set<int> s;
        for (int num : nums) {
            s.insert(num);
            if (s.size() > 3) {
                s.erase(s.begin());
            }
        }
        return s.size() == 3 ? *s.begin() : *s.rbegin();
    }
};

时间复杂度：O(n)，其中 n 是数组 nums 的长度。由于有序集合的大小至多为 3，插入和删除的时间复杂度可以视作是 O(1) 的，因此时间复杂度为 O(n)。
空间复杂度：O(1)。

第三个版本：一次遍历

我们可以遍历数组，并用三个变量 a、b 和 c 来维护数组中的最大值、次大值和第三大值，以模拟方法二中的插入和删除操作。为方便编程实现，我们将其均初始化为小于数组最小值的元素，视作「无穷小」，比如-2^{63} 等。

遍历数组，数组元素的操作：

若 num>a，我们将 c 替换为 b，b 替换为 a，a 替换为 num，这模拟了将 num 插入有序集合，并删除有序集合中的最小值的过程；
若 a>num>b，类似地，我们将 c 替换为 b，b 替换为 num，a 保持不变；
若 b>num>c，类似地，我们将 c 替换为 num，a 和 b 保持不变;

遍历结束后，若 c 仍然为 -2^{63} ，则说明数组中不存在三个或三个以上的不同元素，即第三大的数不存在，返回 a，否则返回 c。

class Solution {
public:
    int thirdMax(vector<int> &nums) {
        long a = LONG_MIN, b = LONG_MIN, c = LONG_MIN;
        for (long num : nums) {
            if (num > a) {
                c = b;
                b = a;
                a = num;
            } else if (a > num && num > b) {
                c = b;
                b = num;
            } else if (b > num && num > c) {
                c = num;
            }
        }
        return c == LONG_MIN ? a : c;
    }
};