力扣刷题篇之一维数组

系列文章目录

力扣刷题篇

---

目录

系列文章目录

前言

一、数组的改变、移动

二、数组的旋转

三、统计数组中的元素

四、数组的遍历

总结

---

前言

本系列是个人力扣刷题，本文是最简单的数组。刷题顺序按照[力扣刷题攻略] Re：从零开始的力扣刷题生活 - 力扣（LeetCode）

 

 

 

---

一、数组的改变、移动

找到数组中元素的最小值，让所有元素相等的最小操作数其实就是每个元素和最小值的差的sum。 

class Solution {
    public int minMoves(int[] nums) {
        int n=nums.length , res=0 , min=Integer.MAX_VALUE;
        for(int num:nums){
            min=Math.min(min,num);

        }
        for(int num:nums){
            res+=num-min;
        }
        return res;
    }
}

cnt是记录要变化的次数； 

 不能成立的的情况有两种，一是像[ 4, 2 ,1]这种通过简单的两两比较就能判别false；

二是像[ 4 ,4 , 2, 3]这种前面非递减，后面也是非递减，但nums[i-2]>nums[i]；让后面的2变4，3变4，超过一次，就是false。

class Solution {
    public boolean checkPossibility(int[] nums) {
        int n=nums.length;
        int cnt=0;
        if(n<=2 || nums==null) return true;
        for(int i=1;i=0 && nums[i-2]>nums[i]){
                nums[i]=nums[i-1];
            }else{
                nums[i-1]=nums[i];
            }
        }
        return cnt<=1;
    }
}

 

 j即为不为0的个数，

遍历两遍数组，第一遍找到不为0的元素，并依次排到前面去；第二遍给后面全部赋值0。

class Solution {
    public void moveZeroes(int[] nums) {
        if(nums.length<2) return;
        int j=0;
        for(int i=0;i

二、数组的旋转

 先反转整个数组，再反转前k个元素，最后反转后面的元素。

class Solution {
    public void rotate(int[] nums, int k) {
        k=k%nums.length;
        reverse(nums,0,nums.length-1);
        reverse(nums,0,k-1);
        reverse(nums,k,nums.length-1);
    }
    private void reverse(int[] nums,int left,int right){
        while(left

 其实是个数学问题，拿例1来说，nums数组的和为15，F(0) = 25,F(1) = 16 = 25+15-24， F(2) = 23 = 16+15-8，F(3)= 26 = 23+15 - 4*3，也就是拿前一个函数的和加上数组的和再减去上一个数组末尾的n倍。

class Solution {
    public int maxRotateFunction(int[] nums) {
        if(nums == null || nums.length == 0) return 0;
        int sum=0,res=0;
        for(int i=0;i=0;j--){
            f=f+sum-nums.length*nums[j];
            res=Math.max(res,f);
        }
        return res;
    }
}

三、统计数组中的元素

 

 用count计数的办法找到丢失数，count==0.说明此数丢失，放在res[1];

count==2,说明此数重复，放在res[0]。

class Solution {
    public int[] findErrorNums(int[] nums) {
        int[] count=new int[nums.length];
        int[] res=new int[2];
        for(int num:nums){
            count[num-1]++;
        }
        for(int i=0;i

 首先去找度degree，用count数组去记录每个元素出现的次数，找到出现最多的就是度；

找到度之后，就直接用左右双指针的办法找到左边出现度和右边出现的度，res=right-left+1。

class Solution {
    public int findShortestSubArray(int[] nums) {
        //采用计数排序
        int max = nums[0];
        int min = nums[0];
        //找到数组中的最大值和最小值
        for (int i = 1; i < nums.length; i++) {
            if(max < nums[i]){
                max = nums[i];
            }
            if(min > nums[i]){
                min = nums[i];
            }
        }
        int[] count = new int[max - min + 1];
        //记录最大次数
        int degree = 0;
        for (int i : nums) {
            degree = Math.max(degree, ++count[i - min]);
        }
        //如果数组的度为 1，则结果必为 1
        if(degree == 1){
            return 1;
        }

        int result = nums.length;
        for (int i = 0; i < count.length; i++) {
            if(count[i] != degree){
                continue;
            }
            //还原原数的值
            int temp = min + i;
            int start = 0, end = nums.length - 1;
            while (start < end && temp != nums[start]) {
                start++;
            }

            while (start < end && temp != nums[end]) {
                end--;
            }
            result = Math.min(result, end - start + 1);
        }

        return result;
    }
}

 思路一样，重写了一下。

class Solution {
    public int findShortestSubArray(int[] nums) {
        int max=0,min=49999;
        int res=49999;
        for(int num:nums){
            max=Math.max(max,num);
            min=Math.min(min,num);
        }
        int[] count=new int[max-min+1];
        int degree=1;
        for(int num:nums){
            degree=Math.max(degree,++count[num-min]);
        }
        if(degree==1) return 1;
        for(int i=0;i

 

 用count数组记录每个元素出现的次数，出现0次，找到缺失的数。

class Solution {
    public List findDisappearedNumbers(int[] nums) {
        int[] count=new int[nums.length];
        List res=new ArrayList<>();
        for(int num:nums){
            count[num-1]++;
        }
        for(int i=0;i

 

思路差不多，不计次数，就计有没有出现，没有出现的就是消失的数，速度略微提升。

class Solution {
    public List findDisappearedNumbers(int[] nums) {
        boolean[] arr = new boolean[nums.length];
        for (int num : nums) {
            arr[num - 1] = true;
        }
        List res = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if (!arr[i]) {
                res.add(i + 1);
            }
        }
        return res;
    }
}

 与之前类似，用count数组记录，出现两次的返回。

class Solution {
    public List findDuplicates(int[] nums) {
        List res=new ArrayList<>();
        int[] count=new int[nums.length];
        for(int num:nums){
            count[num-1]++;
        }
        for(int i=0;i

实现时间复杂度为 O(n) 并且只使用常数级别额外空间

将数组还原成1到N的形式，数组的第 x−1个元素为x 。

如果nums[i]!=i+1，即最小就是i+1;否则就是n+1,即还原后数组全都是连续正数。

在恢复后，数组应当有 [1, 2, ..., N] 的形式，但其中有若干个位置上的数是错误的，每一个错误的位置就代表了一个缺失的正数。以题目中的示例二 [3, 4, -1, 1] 为例，恢复后的数组应当为 [1, -1, 3, 4]，我们就可以知道缺失的数为 2。

那么我们如何将数组进行恢复呢？我们可以对数组进行一次遍历，对于遍历到的数 x=nums[i]，如果 x∈[1,N]，我们就知道 x应当出现在数组中的 x−1的位置，因此交换 nums[i]和 nums[x−1]，这样 x就出现在了正确的位置。在完成交换后，新的 nums[i]可能还在 [1,N]的范围内，我们需要继续进行交换操作，直到 x∉[1,N]。

注意到上面的方法可能会陷入死循环。如果 nums[i]恰好与 nums[x−1] 相等，那么就会无限交换下去。此时我们有 nums[i]=x=nums[x−1]，说明 x已经出现在了正确的位置。因此我们可以跳出循环，开始遍历下一个数。

由于每次的交换操作都会使得某一个数交换到正确的位置，因此交换的次数最多为 NNN，整个方法的时间复杂度为 O(N)。

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n=nums.length;
        for(int i=0;i0&&nums[i]<=n&&nums[i]!=nums[nums[i]-1]){
                swap(nums,i,nums[i]-1);
            }
        }
        for(int i=0;i

四、数组的遍历

 用one和maxOne来记录每次一连续出现的次数和最大连续1的个数，频繁更新就好。

// 2ms
// class Solution {
//     public int findMaxConsecutiveOnes(int[] nums) {
//         int maxOne=0;
//         int one=0;
//         for(int num:nums){
//             if(num==1){
//                 one++;
//                 maxOne=Math.max(one,maxOne);
//             }else{
//                 one=0;
//             }
//         }
//         return maxOne;
//     }
// }
class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        int cnt = 0;
        int max = 0;
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] != 1) {
                max = Math.max(max, cnt);
                cnt = 0;
            }else {
                cnt++;
            }
        }
        return Math.max(max, cnt);
    }
}

用res记录总中毒的时间，pTime记录中毒的最后时刻，分情况讨论。

如果最后时刻与下次发动攻势时间不重叠，则res直接加上duration；

如果时间重叠，就要进行时间的更新，res加上duration-(pTime-timeSeries[i]+1)。

记得攻击完都要更新最后的中毒时间。

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        int res=duration;
        int pTime=timeSeries[0]+duration-1;//中毒最后时刻
        for(int i=1;i

 把第一二三大的数都持续更新，最后如果第三大的数还等于初始值，说明没有第三大的数，就返回第一大的数。

class Solution {
    public int thirdMax(int[] nums) {
        long firstMax = Long.MIN_VALUE;
        long secondMax = Long.MIN_VALUE;
        long thirdMax = Long.MIN_VALUE;

        for (int num : nums) {
            if (num > firstMax) {
                thirdMax = secondMax;
                secondMax = firstMax;
                firstMax = num;
            } else if (num < firstMax && num > secondMax) {
                thirdMax = secondMax;
                secondMax = num;
            } else if (num < secondMax && num > thirdMax) {
                thirdMax = num;
            }
        }

        return thirdMax == Long.MIN_VALUE ? (int) firstMax : (int) thirdMax;
    }
}

这个题就两种情况使得三个元素的乘积最大，一是两个负数一个正数；二是三个正数；

要使乘积最大，比较 最小两个数和最大数的乘积  和   最大三个数的乘积， 大的那个就是res。

// class Solution {
//     public int maximumProduct(int[] nums) {
//         Arrays.sort(nums);
//         int mul3=nums[nums.length-1]*nums[nums.length-2]*nums[nums.length-3];
//         int mul2=nums[0]*nums[1]*nums[nums.length-1];
//         return Math.max(mul3,mul2);
//     }
// }
class Solution {
    public int maximumProduct(int[] nums) {
        int a=Integer.MIN_VALUE;
        int b=Integer.MIN_VALUE;
        int c=Integer.MIN_VALUE;
        int d=Integer.MAX_VALUE;
        int e=Integer.MAX_VALUE;
        for(int x:nums){
            if(ax){
                e=d;
                d=x;
            }else if(e>x){
                e=x;
            }
        }
        return Math.max(a*b*c,a*d*e);

    }
}

---

总结

今天完成了一位数组的题，如图：

 都是很简单的题，多敲敲就会了。