排序题目：第三大的数

题目

标题和出处

标题：第三大的数

出处：414. 第三大的数

难度

2 级

题目描述

要求

给定整数数组 $\text{nums}$，返回数组中第三大的不同数。如果不存在，则返回数组中最大的数。

示例

示例 1：

输入：$\text{num = [3, 2, 1]}$
输出：$\text{1}$
解释：
第一大的不同数是 $\text{3}$。
第二大的不同数是 $\text{2}$。
第三大的不同数是 $\text{1}$。

示例 2：

输入：$\text{num = [1, 2]}$
输出：$\text{2}$
解释：
第一大的不同数是 $\text{2}$。
第二大的不同数是 $\text{1}$。
第三大的不同数不存在，所以返回最大的数 $\text{2}$。

示例 3：

输入：$\text{num = [2, 2, 3, 1]}$
输出：$\text{1}$
解释：
第一大的不同数是 $\text{3}$。
第二大的不同数是 $\text{2}$（两个 $\text{2}$ 都是第二大的不同数，因为值相同）。
第三大的不同数是 $\text{1}$。

数据范围

• $\text{1}\le \text{nums.length}\le {\text{10}}^{\text{4}}$
• ${\text{-2}}^{\text{31}}\le \text{nums[i]}\le {\text{2}}^{\text{31}}-\text{1}$

进阶

你能设计一个时间复杂度 $\text{O(n)}$ 的解决方案吗？

解法一

思路和算法

这道题目要求返回数组 $\text{nums}$ 中第三大的不同数，即排序时相同的元素只计算一次。为了确保相同的元素只计算一次，可以使用哈希集合存储数组中的元素。

将数组中的元素全部加入哈希集合之后，新建一个数组存储哈希集合中的全部元素，然后对新数组排序，新数组的长度即为数组 $\text{nums}$ 中的不同元素个数。

当新数组的长度至少为 $3$ 时，存在第三大的不同数，返回新数组中的第三大元素。当新数组的长度小于 $3$ 时，不存在第三大的不同数，返回新数组中的最大元素。

代码

class Solution {
    public int thirdMax(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        for (int num : nums) {
            set.add(num);
        }
        int size = set.size();
        int[] distinct = new int[size];
        int index = 0;
        for (int num : set) {
            distinct[index++] = num;
        }
        Arrays.sort(distinct);
        return size >= 3 ? distinct[size - 3] : distinct[size - 1];
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。使用哈希集合与新数组存储数组 $\text{nums}$ 中的元素需要 $O(n)$ 的时间，对新数组排序需要 $O(n\log n)$ 的时间，因此时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。哈希集合与新数组需要 $O(n)$ 的空间。

解法二

思路和算法

解法一使用哈希集合确保相同的元素只计算一次，也可以直接对原数组排序和遍历，达到确保相同的元素只计算一次的目的。

对数组 $\text{nums}$ 排序，由于 Java 自带的 $\text{Arrays.sort}$ 对于基本数据类型排序都是升序排序，因此排序后的数组中，末尾元素是最大元素。

排序之后，从后往前遍历数组 $\text{nums}$，遍历过程中维护遍历到的不同元素个数。由于末尾元素是最大元素，因此遍历时跳过末尾元素，将不同元素个数初始化为 $1$。对于每个遍历到的元素，执行如下操作。

• 如果当前元素等于上一个遍历到的元素（即当前元素下标加 $1$ 位置的元素），则没有遇到新的不同元素，跳过当前元素。

• 如果当前元素不等于上一个遍历到的元素，则当前元素一定小于上一个遍历到的元素（由于数组已经有序），将不同元素个数加 $1$。如果不同元素个数等于 $3$，则当前元素为第三大的不同数，返回当前元素。

如果遍历结束之后，不同元素个数小于 $3$，则第三大的不同数不存在，返回排序后的数组的末尾元素。

代码

class Solution {
    public int thirdMax(int[] nums) {
        Arrays.sort(nums);
        int length = nums.length;
        int count = 1;
        for (int i = length - 2; i >= 0; i--) {
            if (nums[i] != nums[i + 1]) {
                count++;
                if (count == 3) {
                    return nums[i];
                }
            }
        }
        return nums[length - 1];
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。排序需要 $O(n\log n)$ 的时间，反向遍历数组需要 $O(n)$ 的时间，因此时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。排序需要 $O(\log n)$ 的递归调用栈空间。

解法三

思路和算法

上述两种解法都需要排序，时间复杂度是 $O(n\log n)$。如果要将时间复杂度降低到 $O(n)$，则需要直接遍历数组找到第三大的不同数。

使用三个变量 $\text{first}$、$\text{second}$ 和 $\text{third}$ 分别表示第一大的不同数、第二大的不同数和第三大的不同数。由于数组 $\text{nums}$ 中的元素范围是整个 $\text{int}$ 类型的取值范围，为了避免初始化的值与数组中的元素重复，将 $\text{first}$、$\text{second}$ 和 $\text{third}$ 都声明成 $\text{long}$ 类型，并初始化为 $\text{long}$ 类型的最小值，即 $-2^{63}$。

遍历数组 $\text{nums}$，遍历过程中维护遍历到的不同元素个数。对于每个元素 $\text{num}$，如果 $\text{num}$ 与 $\text{first}$、$\text{second}$ 或 $\text{third}$ 相等，则跳过，当 $\text{num}$ 与 $\text{first}$、$\text{second}$ 和 $\text{third}$ 都不相等时，执行如下操作。

• 如果 $\text{num}>\text{first}$，则将 $\text{first}$、$\text{second}$ 和 $\text{third}$ 的值分别更新为 $\text{num}$、$\text{first}$ 和 $\text{second}$，将不同元素个数加 $1$。

• 如果 $\text{second}<\text{num}<\text{first}$，则将 $\text{second}$ 和 $\text{third}$ 的值分别更新为 $\text{num}$ 和 $\text{second}$，$\text{first}$ 的值不变，将不同元素个数加 $1$。

• 如果 $\text{third}<\text{num}<\text{second}$，则将 $\text{third}$ 的值更新为 $\text{num}$，$\text{first}$ 和 $\text{second}$ 的值不变，将不同元素个数加 $1$。

遍历结束之后，如果不同元素个数大于等于 $3$，则第三大的不同数存在，返回 $\text{third}$，否则第三大的不同数不存在，返回 $\text{first}$。

代码

class Solution {
    public int thirdMax(int[] nums) {
        long first = Long.MIN_VALUE;
        long second = Long.MIN_VALUE;
        long third = Long.MIN_VALUE;
        int count = 0;
        for (long num : nums) {
            if (num == first || num == second || num == third) {
                continue;
            }
            if (num > first) {
                third = second;
                second = first;
                first = num;
                count++;
            } else if (num > second) {
                third = second;
                second = num;
                count++;
            } else if (num > third) {
                third = num;
                count++;
            }
        }
        return count >= 3 ? (int) third : (int) first;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。需要遍历数组一次。

• 空间复杂度：$O(1)$。