数组刷题篇

二分法题:

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

输入: nums = [-1,0,3,5,9,12], target = 9     
输出: 4       
解释: 9 出现在 nums 中并且下标为 4   

方法;二分:循环和递归

class Solution {
    //循环和递归两种做法
    public int search(int[] nums, int target) {
         int left=0;
         int right=nums.length-1;

         int mid=0;
         while(left<=right){
            mid=left+((right-left)>>1); //防止溢出
            if(nums[mid]==target) return mid;
            else if(nums[mid]>target) right=mid-1;
            else if(nums[mid]<target) left=mid+1;
         }

        //不满足
         return -1;
    }
}

class Solution {
    //循环和递归两种做法
    public int search(int[] nums, int target) {
       return  Recursion(nums,target,0,nums.length-1);
    }

    //递归
    public int Recursion(int[] nums,int target,int left,int right){
        if(left>right) return -1;

        int mid=left+((right-left)>>1);
        if(nums[mid]==target) return mid;
        if(nums[mid]>target)  return Recursion(nums,target,left,mid-1);
       
         //if(nums[mid]<target) 
         return Recursion(nums,target,mid+1,right);

    }
}

删除数组多个值题

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

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

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

方法
1:暴力直接删除然移动
2:双指针移动

class Solution {
    public int removeElement(int[] nums, int val) {
        //暴力解法和双指针解法

        int length=nums.length;
        for(int i=0;i<nums.length;i++){
            if(nums[i]==val){
                for(int j=i+1;j<nums.length;j++){
                    nums[j-1]=nums[j];
                } 
                length--;
            }
        }
        return length;
    }
}

双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。
 class Solution {
    public int removeElement(int[] nums, int val) {
        //暴力解法和双指针解法

        int slowPtr=0;
        int length=nums.length;

        //循环一遍,复制需要的东西
        for(int fastPtr=0;fastPtr<nums.length;fastPtr++){
            if(nums[fastPtr]!=val){
                //否则就是不需要的,就不要复制了
                nums[slowPtr++]=nums[fastPtr];
            }
        
            else length--;
        }

        //也不用length,因为slow最后一步是多加了1的,返回slowPtr即可
        return length ;    
    }
}

有序数组平方题

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

方法:
1:暴力平方排序
2:双指针前后移动

class Solution {
    public int[] sortedSquares(int[] nums) {
        //暴力平方调用sort
        //双指针,没有平的最大值不是在最左就是最右
        int[] result=new int[nums.length];

        for(int i=0;i<nums.length;i++){
            result[i]=nums[i]*nums[i];
        }

        Arrays.sort(result);
        
        return result;
    }
}

class Solution {
    public int[] sortedSquares(int[] nums) {
        //暴力平方调用sort
        //双指针,没有平方的数的最大值不是在最左就是最右
        int[] result=new int[nums.length];
        int left=0;
        int right=nums.length-1;
        int index=nums.length-1;
        //遍历数组,left和right遇见结束===>一般双指针都是两个相遇为结束点
        while(left<=right){
            //等于放左边下,一定程度有点保护稳定性的感觉
            if(nums[left]*nums[left]>=nums[right]*nums[right]){
                result[index--]=nums[left]*nums[left];
                left++;
            }
            
            else{
                result[index--]=nums[right]*nums[right];
                right--;
            }
        }
        return result;
    }
}