数组——414.第三大的数

题干：

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

提示：

• 1 <= nums.length <= 10^4
• -2^31 <= nums[i] <= 2^31 - 1

除第一种解法外，皆是官方给出的解法，作个人记录用

第一种解法-强解

非常弱智的解法，也是第一次看完之后选择的解法。。。先找出最大值，然后将最大值的部分重置为-2^31。如是循环。注意要讨论原数组中是否正好存在这个值

class Solution {
    public int thirdMax(int[] nums) {
        int fir = -2147483648;
        int sec = -2147483648;
        int thi = -2147483648;
        boolean it = false;

        for(int i = 0;i < nums.length;i++){
            if(nums[i] == -2147483648){
                it = true;
            }
        }

        fir = max(nums);

        if(nums.length<3){//不足两个数直接返回最大值
            return fir;
        }

        reset(nums,fir);//重置

        sec = max(nums);
        reset(nums,sec);
        thi = max(nums);
        if(it){
            //有最小值存在的情况
            if(thi != sec){
                return thi;
            }else{
                return fir;
            }
        }else{
            if(thi != -2147483648){
                return thi;
            }else{
                return fir;
            }
        }
    }
    public int max(int[] nums){
        int max = -2147483648;
        for(int i = 0;i < nums.length;i++){
            if(max < nums[i]){
                max = nums[i];
            }
        }
        return max;
    }
    public void reset(int[] nums, int max){
        for(int i = 0;i < nums.length;i++){
            if(nums[i]==max){
                nums[i] = -2147483648;
            }
        }
    }
}

第二种解法-数组排序再选择

官方解法

import java.util.Arrays;

class Solution {
    public int thirdMax(int[] nums) {
        Arrays.sort(nums);
        reverse(nums);
        int indexSec = 0;
        boolean a = false;
        for(int i = 1;i < nums.length;i++){
            if(nums[i] != nums[0] && !a){
                indexSec = i;
                a = true;//记录第二个数
            }
            if(nums[i] != nums[indexSec]){
                return nums[i];
            }
        }
        return nums[0];
    }
    public void reverse(int[] nums) {
        int left = 0, right = nums.length - 1;
        while (left < right) {
            int temp = nums[left];
            nums[left] = nums[right];
            nums[right] = temp;
            left++;
            right--;
        }
    }
}

第三种解法-TreeSet

简单学习到了相关，初见红黑。原理是维护动态数组，也可以使用abc变量手动维护

import java.util.Arrays;
import java.util.TreeSet;

class Solution {
    public int thirdMax(int[] nums) {
        TreeSet<Integer> s = new TreeSet<Integer>();
        for(int num:nums){
            s.add(num);
            if(s.size() > 3){
                s.remove(s.first());
            }
        }
        return s.size() > 3 ? s.first() : s.last();
    }
}

第四种解法-输入流

也是初见输入流，写起来很方便简洁，时间复杂度好像不算很优化

import java.util.stream.IntStream;

class Solution {
    public int thirdMax(int[] nums) {
        int[] ints = IntStream.of(nums).distinct().sorted().toArray();
        return ints[ints.length > 3 ? ints.length - 1 : 0];
    }
}