【LeetCode 手撕算法】（普通数组）53-最大子数组和、56-合并区间、189-轮转数组、238-除了自身以外数组的乘积

53-最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组是数组中的一个连续部分。

示例 1：

输入：nums = $-2,1,-3,4,-1,2,1,-5,4$ 输出：6 解释：连续子数组 $4,-1,2,1$ 的和最大，为 6 。示例 2：

输入：nums = $1$ 输出：1

示例 3：

输入：nums = $5,4,-1,7,8$ 输出：23

**思路：**求最大和，先考虑一点点累加。但是前面有很多是负数，sum要么新开=num $i$ ，要么+num $i$ ，判断条件是前面的sum是否为负数，负数我就新开了要他干啥拖后腿。

java 复制代码

class Solution {
    public int maxSubArray(int[] nums) {
        int sum=nums[0],max=nums[0];
        for(int i=1;i<nums.length;i++){
            
            if(sum<0){sum=nums[i];}
            else{sum+=nums[i];}
            max=Math.max(sum,max);
        }
        return max;
    }
}

**注意：**Math.max() 可以求最大值不需要遍历了

56-合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：
复制代码
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2：
复制代码
输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
示例 3：
复制代码
输入：intervals = [[4,7],[1,4]]
输出：[[1,7]]
解释：区间 [1,4] 和 [4,7] 可被视为重叠区间。

**思路：**看见区间的就考虑先排序，然后依次比较区间，用右指针比左指针判断是否重叠，重叠则换右指针，不重叠则添加进动态数组，把最后的区间也添加进去。

java 复制代码

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals,(arr1,arr2)->arr1[0]-arr2[0]);//排序
        List <int[]> ans=new ArrayList<>();//新建动态ans动态存结果区间
        int left=intervals[0][0];//初始化双指针
        int right=intervals[0][1];
        for(int i=0;i<intervals.length;i++){//按照区间顺序依次对比
            int nextLeft=intervals[i][0];
            int nextRight=intervals[i][1];
            if(nextLeft<=right){right=Math.max(right,nextRight);}//合并重叠的         
            else{
                ans.add(new int[]{left,right});//不重叠给结果集添区间加        
                left=nextLeft;//初始化新区间 
                right=nextRight;}
        }
        ans.add(new int[]{left,right});//把剩余的区间加进去
        return ans.toArray(new int[ans.size()] []);//返回格式动态数组变成静态
    }
}

注意事项：

1、注意二维数组排序写法格式 intervals,(arr1,arr2)->arr1 $0$ -arr2 $0$

2、结果不能直接输出，必须转存进动态数组

3、将重叠区间添加进动态数组用 ans.add(new int\[\]{left,right}，新建一个新数组 $left,right$ 添加

4、每次添加完要初始化双指针

5、注意返回格式，存入的动态数组，要返回静态

189-轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 k个位置，其中 k是非负数

示例 1:

输入: nums = $1,2,3,4,5,6,7$ , k = 3 输出: [5,6,7,1,2,3,4]

示例 2:

输入：nums = $-1,-100,3,99$ , k = 2 输出： $3,99,-1,-100$ 解释: 向右轮转 1 步: $99,-1,-100,3$ 向右轮转 2 步: $3,99,-1,-100$

思路：简单题，（位置+k）mod 长度，注意最后新数组要返回原数组

java 复制代码

class Solution {
    public void rotate(int[] nums, int k) {
        int l=nums.length;
        int [] nums2=new int[l];
        for(int i=0;i<l;i++){
            nums2[(i+k)%l]=nums[i];
        }
        for(int i=0;i<l;i++){
            nums[i]=nums2[i];
        }
    }
}

238-除了自身以外数组的乘积

给你一个整数数组 nums，返回数组 answer ，其中 answer[i] 等于 nums 中除了 nums[i] 之外其余各元素的乘积。

题目数据保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位整数范围内。

请不要使用除法，且在 O(n) 时间复杂度内完成此题。

示例 1:

输入: nums = $1,2,3,4$

输出: $24,12,8,6$
示例 2:

输入: nums = $-1,1,0,-3,3$ 输出: $0,0,9,0,0$

**思路：**求除了自己之外的乘积和，正常思路是全部累乘除以自身，但题目要求不让。该位置最终得数包括前缀积和后缀积，因此考虑双指针，前缀走完只存前缀积（除了自己），后缀走完只存后缀积（除了自己），最后二者相乘。

输入【1 , 2 , 3 , 4 】

前缀【1 , 1 , 2 , 6 】

后缀积【24,12, 4 , 1 】

输出【24,12, 8 , 6 】

java 复制代码

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n=nums.length;
        int []ans=new int[n];
        Arrays.fill(ans,1);//初始设为1
        int leftSum=1;
        int rightSum=1;
        for(int l=0,r=n-1;r>0||l<n;l++,r--){
            ans[l]*=leftSum;  //前缀累积
            ans[r]*=rightSum;
            leftSum*=nums[l]; //不包括自身，留到下一个位置
            rightSum*=nums[r];
        }
        return ans;
    }
}

注意细节：

1、 Arrays.fill(ans,1); 将ans全部设置为1，Arrays不忘s

2、ans $l$ *=leftSum; leftSum*=nums $l$ ; 顺序不能变，避免乘以自身