力扣刷题——数组1

最大连续的1个数

• 题目介绍
  
• 思路分析
  1.本题比较简单，根据题目我们可以分析得出数组中的任何一个元素只有0和1两种情况，统计最大连续1的个数，我们可以用一个变量len来统计被0分开的每个相邻1的个数，然后用另外一个变量len1来记录最大的len，len1即为最后的结果
• 相关代码片段

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        int len = 0;
        int len1 = 0;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] == 1){
                len1++;
            }
            if(nums[i] == 0){
                len1 = 0;
            }
            if(len < len1){
                len = len1;
            }
        }
        return len;
    }
}

第三个大的数

• 题目介绍
  

• 思路分析

  1. 根据题目的描述我们首先想到的肯定是将数组进行排序，然后取数组中的第三大的数，首先说明这种做法是可以的，但对数组进行排序最优的时间复杂度为O(nlogn)，本题我们考虑在时间复杂度为O(n)的前提下完成这道题。
  2. 在这里我们介绍两种解法，其中第一种是本人想到的，第二种是看的官方的题解
     (😔~~)。因为我们是找第三大个数，因此我们可以考虑在一次遍历的过程中将第一大和第二大的数全部设置为比可能出现的最小的数还要小即可，改善后的数组的最大值即为原数组中的第三个大的数。由于题目给出的元素的范围为int型整数的范围，所以我们需要用long型中的最小值作为我们设置的最小值。
  3. 值得注意的是，当数组中的元素个数小于3时或者不存在第3个大的数时，我们需要输出的是数组的最大值，因此我们在将原数组中最大的数设置为最小时要将该数记录下来，然后再最后输出的时候进行判断：当第三大的数为我们设置的最小的数时说明原数组中不存在第3大的数，所以我们需要输出的为数组中最大的数，否则就输出第三大的数。
  4. 官方给出的题解利用treeset数据结构：该数据结构的特点是存入的数据是有序且不重复的。。。感觉这道题就是为treeset出的，奈何本人的知识掌握的实在是。。。所以愣是没想到。好了，言归正传，将数组中的元素存入treeset集合中，然后当集合中的元素个数大于三时，删掉第一个元素，这样最后集合中只存在3个元素，即第三大的数、第二大的数、第一大的数，这时集合中第一个元素即为所求，当最后集合中存在的元素个数不是3时，说明原数组中没有第3大的数，这时输出集合的最后一个元素即可。

• 相关代码片段

/**
官方题解:利用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();
    }
}

/**
本人的题解
*/
class Solution {
    public int thirdMax(int[] num) {
    // 当数组中的元素个数小于3时直接给出结果即可
        if (num.length < 3) {
            if (num.length == 1) {
                return num[0];
            } else {
                return Math.max(num[0], num[1]);
            }
        }
        //改为long型数组
        long[] nums = new long[num.length];
        for(int i = 0; i < num.length;i++){
            nums[i] = num[i];
        }
        long[] arr = new long[2];
        int l = 0;
        //将数组中的前两大的元素设置成最小值
        for (int i = 0; i < 2; i++) {
            long k = nums[0];
            for (int j = 0; j < nums.length; j++) {
                if (k < nums[j]) {
                    k = nums[j];
                }
            }
            arr[l++] = k;
            for (int m = 0; m < nums.length; m++) {
                if (nums[m] == k) {
                    nums[m] = Long.MIN_VALUE;
                }
            }
        }
        long out = nums[0];
        //遍历得到我们改善后的数组中的最大值即可
        for (int i = 0; i < nums.length; i++) {
            if (out < nums[i]) {
                out = nums[i];
            }
        }
        //判断最终的元素是否是我们设置的最大值
        return out < Integer.MIN_VALUE ? (int)arr[0] : (int)out;
    }
}

三个数的最大乘积

• 题目介绍
  

• 思路分析

  1. 好，我承认这个题有充数的嫌疑。
  2. 直接将数组排序后输出三个最大的值的乘积即可，当然，这里也有一个小坑：即到底是三个最大的数的乘积大还是两个最小的数和一个最大的数的乘积最大，因为两个负数相乘也为正数。所以在最后判断一下。

• 相关代码片段

class Solution {
    public int maximumProduct(int[] nums) {
        Arrays.sort(nums);
        //两个最小的数和一个最大的数相乘
        int out1 = nums[0]*nums[1]*nums[nums.length-1];
        //三个最大的数相乘
        int out2 = nums[nums.length-3]*nums[nums.length-2]*nums[nums.length-1];
        return Math.max(out1, out2);
    }
}

错误的集合

• 题目介绍
  

• 思路分析

  1. 第一种解法：将数组进行排序，然后对排序后的数组进行相邻元素相减(大减小)，当某个差的值为0时说明该元素即为重复的元素，当某个差的值为2时说明被减数和减数之间的那个值为丢失的元素。
  2. 当丢失的元素位于首尾时，即丢失的元素为1或者数组的长度时，通过作差我们是无法得到丢失的元素的，这时我们可以单独进行讨论。
  3. 第二种解法：利用纯数学去求解。重复的元素即为：sum(nums) - sum(set(nums)) set数据结构不存放重复的元素；丢失的元素即为：sums(1~nums.length) - sum(set(nums))，这里的详细推导过程就由读者自己推导(不是很难，利用数列的求和思想)
  4. 第三种解法：利用计数器求解。根据题意我们可以得到重复的元素在数组中出现的次数为2，丢失的元素在数组中出现的次数为0。

• 相关代码片段

/**
第一种解法
*/
class Solution {
    public int[] findErrorNums(int[] nums) {
         Arrays.sort(nums);
        int[] out = new int[2];
        for(int i = 0; i < nums.length-1; i++){
            if(nums[i] == nums[i+1]){
                out[0] = nums[i];
            }
            if(nums[i] + 2 == nums[i+1]){
                out[1] = nums[i] + 1;
            }
        }
        if(out[1] == 0){
           if (nums[0] != 1) {
                out[1] = 1;
            } else {
                out[1] = nums[nums.length - 1] + 1;
            }
        }
        return out;
    }
}

/**
第二种解法
*/
class Solution {
    public int[] findErrorNums(int[] nums) {
        HashSet<Integer> hashSet = new HashSet<>();
        for(int i:nums){
            hashSet.add(i);
        }
        int[] out = new int[2];
        int sum1 = 0;
        int sum2 = 0;
        for (int num : nums) {
            sum1 += num;
        }
        for( int num : hashSet){
            sum2 += num;
        }
        int sum3 = (1+nums.length)*nums.length/2;
        out[0] = sum1 - sum2;
        out[1] = sum3 - sum2;
        return out;
    }
}

/**
第三种解法
*/
class Solution {
    public int[] findErrorNums(int[] nums) {
        
        int[] counter = new int[nums.length+1];
        
        for (int i: nums) {
            counter[i]++;
        }
        
        int[] result = new int[2];
        for (int i = 1; i<counter.length; i++) {
            if (counter[i] == 0) {
                result[1] = i;
            } else if (counter[i] == 2) {
                result[0] = i;
            }
        }
        
        return result;
    }
}

总结

这次总结的题的难度总体来说都是很简单的。由简入繁吧，希望自己能够坚持下去，和大家一起努力变强！