系列文章目录
力扣刷题篇
目录
前言
本系列是个人力扣刷题，本文是最简单的数组。刷题顺序按照[力扣刷题攻略] 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<n&&cnt<2;i++){
if(nums[i-1]<=nums[i]) continue;
cnt++;
if(i-2>=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<nums.length;i++){
if(nums[i]!=0) nums[j++]=nums[i];
}
for(int i=j;i<nums.length;i++){
nums[i]=0;
}
}
}
二、数组的旋转
先反转整个数组，再反转前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<right){
int temp=nums[left];
nums[left]=nums[right];
nums[right]=temp;
left++;
right--;
}
}
}
其实是个数学问题，拿例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<nums.length;i++){
sum+=nums[i];
res+=i*nums[i];
}
int f=res;
for(int j=nums.length-1;j>=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<count.length;i++){
if(count[i]==0) res[1]=i+1;
else if(count[i]==2) res[0]=i+1;
}
return res;
}
}
首先去找度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.length;i++){
if(count[i]!=degree) continue;
int num=i+min;
int left=0,right=nums.length-1;
while(left<right && num!=nums[left]) left++;
while(left<right && num!=nums[right]) right--;
res=Math.min(res,right-left+1);
}
return res;
}
} 
用count数组记录每个元素出现的次数，出现0次，找到缺失的数。
class Solution {
public List<Integer> findDisappearedNumbers(int[] nums) {
int[] count=new int[nums.length];
List<Integer> res=new ArrayList<>();
for(int num:nums){
count[num-1]++;
}
for(int i=0;i<count.length;i++){
if(count[i]==0) res.add(i+1);
}
return res;
}
} 
思路差不多，不计次数，就计有没有出现，没有出现的就是消失的数，速度略微提升。
class Solution {
public List<Integer> findDisappearedNumbers(int[] nums) {
boolean[] arr = new boolean[nums.length];
for (int num : nums) {
arr[num - 1] = true;
}
List<Integer> 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<Integer> findDuplicates(int[] nums) {
List<Integer> res=new ArrayList<>();
int[] count=new int[nums.length];
for(int num:nums){
count[num-1]++;
}
for(int i=0;i<count.length;i++){
if(count[i]==2) res.add(i+1);
}
return res;
}
}
实现时间复杂度为 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;i<n;i++){
while(nums[i]>0&&nums[i]<=n&&nums[i]!=nums[nums[i]-1]){
swap(nums,i,nums[i]-1);
}
}
for(int i=0;i<n;i++){
if(nums[i]!=i+1){
return i+1;
}
}
return n+1;
}
public void swap(int []nums,int i,int j){
int temp=nums[i];
nums[i]=nums[j];
nums[j]=temp;
}
}
四、数组的遍历
用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<timeSeries.length;i++){
if(pTime<timeSeries[i]){
res+=duration;
pTime=timeSeries[i]+duration-1;
}else{
res=res-(pTime-timeSeries[i]+1)+duration;
pTime=timeSeries[i]+duration-1;
}
}
return res;
}
}
把第一二三大的数都持续更新，最后如果第三大的数还等于初始值，说明没有第三大的数，就返回第一大的数。
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(a<x){
c=b;
b=a;
a=x;
}else if(b<x){
c=b;
b=x;
}else if(c<x){
c=x;
}
}
for(int x:nums){
if(d>x){
e=d;
d=x;
}else if(e>x){
e=x;
}
}
return Math.max(a*b*c,a*d*e);
}
}
总结
今天完成了一位数组的题，如图：
都是很简单的题，多敲敲就会了。
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
