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

XnyuDo

已于 2022-11-07 16:54:29 修改

阅读量427

点赞数

分类专栏：代码随想录训练营文章标签：算法 leetcode 数据结构

于 2022-10-26 22:35:08 首次发布

本文链接：https://blog.csdn.net/a976903676/article/details/127538629

版权

代码随想录训练营专栏收录该内容

14 篇文章 1 订阅

订阅专栏

LeetCode 704. 二分查找

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

示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

思路：首先考虑到元素是有序的，并且是根据给定目标去查找数据，可以考虑二分查找。需要注意的是区间的定义，左闭右开或左开右闭或左闭右闭。

二分查找的做法是，定义查找的范围 [left,right]，初始查找范围是整个数组。每次取查找范围的中点 mid，比较 nums[mid] 和 target 的大小，如果相等则mid 即为要寻找的下标，如果不相等则根据 nums[mid] 和 target 的大小关系将查找范围缩小一半。由于每次查找都会将查找范围缩小一半，因此二分查找的时间复杂度是 O*(log*n)。

nums.length求的是数组的长度，如nums = [-1,0,3,5,9,12]中，nums.length = 6，但是数组下标对应的是0,1,2,3,4,5，所以区间的考虑十分重要，左闭右闭区间就是nums.length - 1，左闭右开区间就是nums.length。

//左闭右闭区间算法
class Solution {
    public int search(int[] nums, int target) {
        int right = nums.length - 1;//考虑了左闭右闭,即[left, right]
        int left = 0;
        while(left <= right){//当left==right，区间[left, right]依然有效，所以用 <=
            int mid = left + ((right - left)>>1);//一开始写的是((right - left) / 2),后来发现位运算效率也可以的
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target){
                left = mid + 1;// target 在右区间，所以[mid + 1, right]
            }else if(nums[mid] > target){
                right = mid - 1;// target 在左区间，所以[left, mid - 1]
            }
        }
        return -1; // 未找到目标值
    }
}

//左闭右开区间算法
class Solution {
    public int search(int[] nums, int target) {
        int right = nums.length;//考虑了左闭右开,即[left, right)
        int left = 0;
        while(left < right){
            int mid = left + ((right - left)>>1);
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target){
                left = mid + 1;
            }else if(nums[mid] > target){
                right = mid;// target 在左区间，在[left, mid)中
            }
        }
        return -1; // 未找到目标值
    }
}

扩展：位运算；return -1 、return 1 、 return 0 的区别

位运算：

语法格式：需要移位的数字 >> 移位的次数
数学意义：右移一位相当于除2，右移n位相当于除以2的n次方。

如：>> 1 表示二进制数右移一位，即去掉末尾的0或1，与除以2是一样的效果，同理 >> 2 是右移2位，>>>2 是无符号右移2位，左边补充0
语法格式：需要移位的数字 << 移位的次数
数学意义：在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2的1次方，左移n位就相当于乘以2的n次方。

return -1 、return 1 、 return 0 的区别

0和-1使用时：

0一般表示成功执行
-1一般表示不成功
0和1使用时：

1真
0假

LeetCode 27. 移除元素

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

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

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

示例 1:

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例 2:

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

思路：首先考虑到不使用额外的数组空间，直接暴力算法，第一个for循环遍历数组元素，第二个for循环更新数组。暴力算法的时间复杂度是 O(n^2)。

由于题目要求删除数组中等于val 的元素，因此输出数组的长度一定小于等于输入数组的长度，我们可以把输出的数组直接写在输入数组上。可以使用双指针算法，时间复杂度是 O(n)

//暴力算法
class Solution {
    public int removeElement(int[] nums, int val) {
	int len =nums.length;
        for(int i = 0;i < len;i++){
            if(nums[i] == val){//发现需要移除的元素，就将数组集体向前移动一位
                for(int j=i+1; j < len;j++){
                    nums[j-1]=nums[j];
                }
                i--;// 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                len--;// 数组的大小-1
            }
        }
        return len;
    }
}

//双指针算法
class Solution {
    public int removeElement(int[] nums, int val) {
	    int leftIndex = 0;//右指针rightIndex指向当前将要处理的元素，左指针leftIndex指向下一个将要赋值的位置。
        for(int rightIndex = 0;rightIndex < nums.length;rightIndex++){
        /*如果右指针指向的元素不等于val，它一定是输出数组的一个元素，
         *就将右指针指向的元素复制到左指针位置，然后将左右指针同时右移；
         *如果右指针指向的元素等于val，它不能在输出数组里，此时左指针不动，右指针右移一位。
         */
            if(nums[rightIndex] != val){
                nums[leftIndex] = nums[rightIndex];
                leftIndex++;
            }
        }
    return leftIndex;
    }
}