代码随想录 day1

今天的任务是：

数组理论基础，​​​​​​704.二分查找，27.移除元素

数组理论基础

虽然在c和Java基础中学过，还是要再注意一下

1. 数组的元素不能删除，只能覆盖
2. 那么二维数组在内存的空间地址是连续的么？

对于不同的语言来说，内存管理是不一样的，例如C和C++，二维数组是连续分布的

但在Java中，没有指针，寻址操作交给虚拟机，

在Java中，当你声明一个二维数组，如 int[][] array = new int[M][N];，实际上发生的是：

1. 外层数组分配：首先，JVM分配了一个大小为M的一维数组，数组的每个元素都是引用类型（在Java中，这是int[]类型的引用）。

2. 内层数组分配：然后，对于外层数组的每个元素（即每个int[]引用），JVM会分别分配一个大小为N的整数数组。这些内层数组（行）在内存中并不是连续分布的，它们可以分布在内存的任意位置，只要它们的引用被保存在外层数组中。--对于高亮语句的解释：对于多维数组来说，外层数组的每个元素都是一个引用变量，这些变量存储了指向内层数组的引用。当你通过外层数组的索引访问某个元素时，你实际上是在获取该索引位置上的引用，然后通过这个引用来访问内层数组（或更低维度的数组）。

二分查找

关于这个算法还是先了解基本内容：
也叫折半查找，每次考察数组当前部分的中间元素（middle），如果中间元素刚好是目标元素(target)，就结束搜索。如果中间元素小于所查找的值，就在数组左半部分[left,middle]查找；如果中间元素大于所查找的值，就在数组右半部分[middle,right]查找。

注意：

1. 查找的元素必须是有序排列
2. 数组中无重复元素，这样能保证查找下标的唯一性

代码思路：

1. 极限情况要排除，避免循环

2. 设置左右起始位置

3. 开始循环判断（先调整mid位置，再与target值比较判断，最后得出结果）

易错点：区间的缺点、mid的设置

情况一：左闭右闭

public int search(int[] nums, int target) {
        // 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
        if (target < nums[0] || target > nums[nums.length - 1]) {
            return -1;
        }
    left=0;
    right=maxsize-1;
    //确定区间，要保证合法，
    while(left<=right)//按照情况来说应该是小于等于
    {
        mid=(left+right)/2;
        //判断
        if(nums[mid]>target)//范围缩小在左半边，更改right的值
            right=mid-1；
    //由于是闭区间包含mid，既然mid不是要找的下标，应该-1，而不是right=mid，若right为mid，则代表mid没有满足nums[mid]>target，但又被包含在范围内，是错误处理，所以应为mid-1，将不满足要求的mid越过
        elseif(nums[mid]<target)
            left=mid+1;
        else return mid;
    
    }
    return -1;
}

情况二：左闭右开

left=0;
right=maxsize;//右开不包含右边界，所以right取值应取到右边界
//确定区间，要保证合法，
while(left<right)//按照情况来说应该是小于
{
    mid=(left+right)/2;
    //判断
    if(nums[mid]>target)//范围缩小在左半边，更改right的值
        right=mid；
    //由于右开，所以mid取值的过程不包括right的值，不用+1
    elseif(nums[mid]<target)
        left=mid+1;//左闭包含left，更新范围时应除去left
    else return mid;
    
}
return -1;

练习题

35. 搜索插入位置 - 力扣（LeetCode）

唯一不同的是要返回left，因为题目说明如果找不到target对应的下标，就按顺序插入到里面

移除元素--暴力、双指针

注意

1. 数组的删除操作其实是覆盖而不是删除，即使一些方法例如length返回操作之后的个数，但其实实际上还是操作之前的空间大小，只是内部计数器返回的值
2. erase函数：时间复杂度是O(n)而不是O(1)

暴力解法

题目要求与erase函数作用一致，思路是外层循环找到删除的值，内层循环将后面的数值向前移动

// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        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以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
};

双指针解法

思路

双指针代替了双层循环，分为快指针和慢指针

快指针是指向删除之后数组所需要的元素值，慢指针是用来标记新数组所需元素的下标，也可以理解为reader和writer指针(一个读一个写)，将快指针读取到的值赋给慢指针

class Solution {
    public int removeElement(int[] nums, int val) {
        slow=0;
        for(fast=0;fast<nums.size;fast++)
        {
            if(nums[fast]!=val)
            {
                nums[fast]=nums[slow];
                slow++;
                //更简洁的写法：nums[slow++]=nums[fast];
            }
    
        }
        return slow;//最后一步时，slow所指向的下标就是更新后的数组下标，即新数组长度
    }
}