力扣刷题数组

1. 两数之和
   给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
   输入：nums = [2,7,11,15], target = 9
   输出：[0,1]

class Solution {
      public int[] twoSum(int[] nums, int target) {
            int[]nums2= Arrays.copyOf(nums,nums.length);
        Arrays.sort(nums);
        int i=0,j=nums.length-1;
        while(nums[i]+nums[j]!=target) {
            if(nums[i]+nums[j]<target)
                i++;
            else if(nums[i]+nums[j]>target)
                j--;
        }

        int r1=0,r2=0;
        for(int k=0;k<nums2.length;k++)
            if(nums2[k]==nums[i]) {
                r1=k;
                break;
            }

        for(int k=nums2.length-1;k>=0;k--)
            if(nums2[k]==nums[j]) {
                r2=k;
                break;
            }
        return new int[] {r1,r2};
    } 
}

 

 2. 26  删除有序数组中的重复项
 给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

在这里插入代码片

class Solution {
    public int removeDuplicates(int[] nums) {
        //定义快指针，表示原数组坐标
        int fast = 1;
        //定义慢指针，表示新数组坐标
        int slow = 0;

        while(fast < nums.length){
            //找出不重复元素
            if(nums[fast] != nums[slow]){
                //慢指针后移
                slow++;
                //将不重复的元素赋给新数组的slow位置
                nums[slow] = nums[fast];
            }
            //快指针后移
            fast++;
        }
        //slow从0开始，返回长度需要加1
        
        return slow + 1;
       

    }
}

27 移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

在这里插入代码片
```class Solution {
    public int removeElement(int[] nums, int val) {
int l=0,r=nums.length;
while(l<r){
    if(nums[l]==val){
        nums[l]=nums[r-1];
        r--;
    }
    else{
        l++;
    }
}
return l;
    }
}
35 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

class Solution {
    public int searchInsert(int[] nums, int target) {
 int len = nums.length;
        // 特殊判断
        if (nums[len - 1] < target) {
            return len;
        }

        // 程序走到这里一定有 nums[len - 1] >= target
        int left = 0;
        int right = len - 1;
        // 在区间 nums[left..right] 里查找第 1 个大于等于 target 的元素的下标
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target){
                // 下一轮搜索的区间是 [mid + 1..right]
                left = mid + 1;
            } else {
                // 下一轮搜索的区间是 [left..mid]
                right = mid;
            }
        }
        return left;
    }
}
53 最大子数组和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和

class Solution {
public int maxSubArray(int[] nums) {
int sum =nums[0];
int max =nums[0];
for (int i=1;i<nums.length;i++){
if(sum<0)
sum=0;
sum=sum+nums[i];
max=(max<sum)? sum:max;

    }
    return max;
}

}