算法训练——数组

理论基础

• 数组是存放在连续空间内存空间上的相同类型数据的集合。
• 数组可以通过下标索引方式获取到下标下对应的数据。
  
  • 数组下标都是从0开始的
  • 数组内存空间的地址是连续的。
• 二维数组
  

力扣相关题目

704 二分查找

注意：

• 二分法的区间一般都是左闭右闭，或者左闭右开。
• 数组必须有序，否则，二分查找就会失效
• 二分法题目一般都可以分为三步
  1. 确定是否满足二分法使用条件：有序数组和查找特定元素
  2. 确定特定元素target的伪代码
  3. 确定变化的边界

class Solution {
    public int search(int[] nums, int target) {
        int left =0, right=nums.length-1;
    
            while(left<=right){
                //本来加不加left无所谓，但是不加会溢出，会超时
                // 在计算机里可能两个int相加会溢出，先减除后加确实可以用于更大的数组
                int middle=left+(right-left)/2;
                if(nums[middle]==target){
                    //记得是返回目标的下标值，不是下标
                return middle;
                }
                else if(nums[middle]<target){
                    left=middle+1;
                }
                else{
                    right=middle-1;
                }
            }
        
        return -1;
    }
}

双指针法：977.有序数组的平方

方法一：暴力排序

class Solution {
    public int[] sortedSquares(int[] nums) {
        //注意怎么新定义二维数组
        int[] newnums= new int[nums.length];
        for(int i=0;i<nums.length;i++){
            newnums[i]=nums[i]*nums[i];

        }
        //本来以为不用排序，但是报错了，示例排了也排一下吧。
        Arrays.sort(newnums);
        return newnums;
    }
}

方法二：双指针

class Solution {
    public int[] sortedSquares(int[] nums) {
   int[] res=new int[nums.length];
   int left=0;
   int right=nums.length-1;
   int index=res.length-1;
   //第一次写的时候出口错了while后面的条件错误。并且少了一种相等时的情况
    while(index>=0){
    if(nums[left]*nums[left]<=nums[right]*nums[right]){
        res[index]=nums[right]*nums[right];
        index--;
        right--;
    }
    //这里必须要用else，只用if会报错
    else if(nums[left]*nums[left]>nums[right]*nums[right]){
        res[index]=nums[left]*nums[left];
         index--;
        left++;
    }
}
    return res;
    }
}

作者：silly-mayerkqu
链接：https://leetcode.cn/problems/squares-of-a-sorted-array/solution/shuang-zhi-zhen-by-silly-mayerkqu-lndj/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

27.移除元素

数组的元素在地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。


双指针法：

class Solution {
    public int removeElement(int[] nums, int val) {
   int left=0;
   int right=nums.length-1;
   while(left<=right){
       if(nums[left]==val){
           nums[left]=nums[right];
           right--;
       }else{
           left++;
       }
   }
return left;

    }
}

Java暴力

class Solution {
    public int removeElement(int[] nums, int val) {
           int size = nums.length;
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) { // 发现需要移除的元素，就将数组集体向前移动一位
                for (int j = i + 1; j < size; j++) {
                    nums[j - 1] = nums[j];
                }
                i--; // 抵消上面的i++，在往前移一位之后判断旧位置上的新数字。
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
}

JS暴力解法

var removeElement = function(nums, val) {
    let k=0;
    for(let i=0;i<nums.length;i++){
        if(nums[i]!=val){
            nums[k]=nums[i];
            k++;
        }
    }
return k;

};

class Solution {
    public int mySqrt(int x) {
        return (int)Math.sqrt(x);

    }
}

在Java中，类型转换运算符的优先级比数学运算符低。因此，在上述代码中，如果没有加括号，则会先执行Math.sqrt(x)，将结果转换为double类型，然后再强制转换为int类型，这样可能会导致精度丢失或者返回错误的结果。

加上括号之后，先将x作为参数传递给Math.sqrt()函数，计算出平方根并返回一个double类型的结果，然后再将该结果强制转换为int类型并返回。这样可以确保返回正确的整数部分。

可以用上但是我没用上的一张图片