代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素

原创已于 2024-05-08 13:56:25 修改 · 1.1k 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #java #数据结构

于 2024-05-08 13:43:38 首次发布

学习任务：数组part01

数组理论知识

数组在内存中的存储方式
数组是存放在连续内存空间上的相同类型数据的集合
数组元素操作

获取元素：
按照元素对应的下表进行访问，元素下标从零开始
添加和删除元素：

一维数组：
数组内存空间的地址是连续的，因此在添加和删除元素是需要移动其他元素的地址，并且数组的元素是不能删的，只能覆盖
如图删除下标为3处的元素，需要将下标为3之后的所有元素主意逐一向前移一位覆盖前面的元素，输出下标从零到原数组长度减一个元素即可
以上是一维数组的相关操作，那么在java中二维数组又是如何存储和更新的呢？
二维数组：
java中二维数组的存储方式如图：

二维数组的每一行头结点的地址是没有规则的，更谈不上连续；而在c++中，二维数组的每个元素地址是连续的。

题目练习： 704. 二分查找、27. 移除元素

704. 二分查找

力扣连接

看到题目的第一想法

查找元素的题目中，通常有以下查找方式：

线性查找：

按数组下标顺序从0开始遍历，知道找到元素位置，时间复杂度为O(n)

二分查找：

设置一个指向中间元素下标的变量mid，mid=(left + right)/2
让要查找的元素和数组mid下标的元素进行比较
1. 如果查找的元素大于arr[mid]，则left变为mid后面一个元素的下标
2. 如果查找的元素小于arr[mid]，则right变为mid前一个元素的下标
3. 如果查找的元素等于arr[mid]，则mid就是要查找元素所在的位置
停止条件：当left > rigth时，说明元素不在该数组中
时间复杂度：O(log n)

因此优先采用二分查找法
下面是两种实现方式的完整代码：
线性查找

public static int search1(int[] nums, int target){
        int res = -1;
        for (int i = 0; i < nums.length; i++) {
            if(nums[i] == target)
                return i;
        }
        return res;
    }

二分查找

public static int search(int[] nums, int target) {
        int index = -1;
        int left = 0;
        int right = nums.length-1;
        while(left<=right){
            int mid = left + (right-left)/2;
            if(nums[mid] > target)
                right = mid-1;
            else if(nums[mid]<target){
                left = mid+1;
            }
            else{
                return mid;
            }
        }
        return index;
    }

看完代码随想录之后的想法

与此想法基本一致，
随想录中给出的解释：有两种写法：

法一：[left,right] 左闭右闭，即 left = 0， right = nums.length-1

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

//左闭右闭
   public static int search1(int[] nums, int target) {
       int index = -1;
       int left = 0;
       int right = nums.length-1;
       while(left<=right){
           int mid = left + (right-left)/2;
           if(nums[mid] > target)
               right = mid-1;
           else if(nums[mid]<target){
               left = mid+1;
           }
           else{
               return mid;
           }
       }
       return index;
   }

法二：[left,right) 左闭右开，即 left = 0， right = nums.length

while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

 //左闭右开
    public static int search2(int[] nums, int target) {
        int index = -1;
        int left = 0;
        int right = nums.length;
        while(left<right){
            int mid = left + (right-left)/2;
            if(nums[mid] > target)
                right = mid;
            else if(nums[mid]<target){
                left = mid+1;
            }
            else{
                return mid;
            }
        }
        return index;
    }

问题总结

这个题目的纠结点在于：right的初始化和while循环条件中left和right的关系
以上两种方法掌握一种即可，左闭右闭是我要重点掌握的

27.移除元素

力扣链接

看到题目的第一想法

使用暴力方法解决：数组线性遍历，遇到要移除的元素就将该元素后面的所有元素前移覆盖，然后再从该元素位置处继续往后遍历，重复以上操作，直到数组中不存在该元素为止，时间复杂度：O（n^2）
完整代码如下：

public static int removeElement(int[] nums, int val) {
        int len = nums.length;
        int i = 0;
        while(i<len){
            if(nums[i] == val){
                for (int j = i+1; j < len; j++) {
                    nums[j-1] = nums[j];
                }
                len --;
            }
            else i++;
        }
        return len;
    }

看完代码随想录之后的想法

随想录给出的解答思路简直太诱人了，其思路为：使用快慢指针和一层for循环完成

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组
慢指针：指向更新新数组下标的位置
具体实现代码为：

       int slow = 0;
       for (; fast < nums.length; fast++) {
           if(nums[fast] != val){
               nums[slow++] = nums[fast];
           }
       }
       return slow;