• 【Leetcode60天带刷】day01——704.二分查找、27.移除元素

     题目： 704. 二分查找 

    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

    提示：

    1. 你可以假设 nums 中的所有元素是不重复的。
    2. n 将在 [1, 10000]之间。
    3. nums 的每个元素都将在 [-9999, 9999]之间。

    思考历程与知识点： 

            考查二分查找能力，注意mid的取值。

    注意：

            右端点的大小，需要在数组长度上-1。也就是nums.size()-1，因为下标是从0开始的。

     题解：

    c++:

    1. class Solution {
    2. public:
    3.     int search(vector<int>& nums, int target) {
    4.         int mid;
    5.         int i = 0, j = nums.size() - 1;
    6.         while(j >= i) {
    7.          // mid = (i + j + 1)/2; //这个也对，但为了防止溢出选择下面这种写法
    8.             mid = i + ((j - i) / 2);
    9.             if(nums[mid] == target) return mid;
    10.             else if(nums[mid] > target) j = mid - 1;
    11.             else i = mid + 1;
    12.         }
    13.         return -1;
    14.     }
    15. };

     其他语言版本：

    java

    1. class Solution {
    2.     public int search(int[] nums, int target) {
    3.         int left = 0, right = nums.length;
    4.         while (left < right) {
    5.             int mid = left + ((right - left) >> 1);
    6.             if (nums[mid] == target)
    7.                 return mid;
    8.             else if (nums[mid] < target)
    9.                 left = mid + 1;
    10.             else if (nums[mid] > target)
    11.                 right = mid;
    12.         }
    13.         return -1;
    14.     }
    15. }

    python:

    1. class Solution:
    2.     def search(self, nums: List[int], target: int) -> int:
    3.         left, right = 0, len(nums)  # 定义target在左闭右开的区间里，即：[left, right)
    4.  
    5.         while left < right:  # 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
    6.             middle = left + (right - left) // 2
    7.  
    8.             if nums[middle] > target:
    9.                 right = middle  # target 在左区间，在[left, middle)中
    10.             elif nums[middle] < target:
    11.                 left = middle + 1  # target 在右区间，在[middle + 1, right)中
    12.             else:
    13.                 return middle  # 数组中找到目标值，直接返回下标
    14.         return -1  # 未找到目标值

     题目： 27.移除元素

     Leetcode原题链接：力扣27.移除元素

    ​​

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

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

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

    说明:

    为什么返回数值是整数，但输出的答案是数组呢?

    请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

    你可以想象内部操作如下:

    // nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

    示例 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。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

     思考历程与知识点： 

        第一反应是求有几个val，用总长度减掉就可以了。发现题目要求原地修改数组。

        既然题目说顺序可变，那每当找到一个val，就把它丢到最后面，然后数组长度减1，不就是丢掉了。再把当前最后面那个放回这个val丢完之后的空位，就可以了

    注意：

            当 i > j 时就要跳出for，而不是遍历到数组最后一个再跳，因为 j 后面都是我们丢过去的val，不能遍历到他们。

     题解：

    c++:

    1. class Solution {
    2. public:
    3.     int removeElement(vector<int>& nums, int val) {
    4.         int j = nums.size() - 1;
    5.         for(int i = 0; i <= j; i++) {
    6.             if(nums[i] == val) swap(nums[i--], nums[j--]);;
    7.         }
    8.         return j+1;
    9.     }
    10. };

     其他语言版本：

    java:

    1. class Solution {
    2.     public int removeElement(int[] nums, int val) {
    3.         // 快慢指针
    4.         int slowIndex = 0;
    5.         for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
    6.             if (nums[fastIndex] != val) {
    7.                 nums[slowIndex] = nums[fastIndex];
    8.                 slowIndex++;
    9.             }
    10.         }
    11.         return slowIndex;
    12.     }
    13. }

    python:

    1. class Solution:
    2.     def removeElement(self, nums: List[int], val: int) -> int:
    3.         # 快慢指针
    4.         fast = 0  # 快指针
    5.         slow = 0  # 慢指针
    6.         size = len(nums)
    7.         while fast < size:  # 不加等于是因为，a = size 时，nums[a] 会越界
    8.             # slow 用来收集不等于 val 的值，如果 fast 对应值不等于 val，则把它与 slow 替换
    9.             if nums[fast] != val:
    10.                 nums[slow] = nums[fast]
    11.                 slow += 1
    12.             fast += 1
    13.         return slow

    欢迎点赞，收藏，评论，你的鼓励就是我创作的最大动力！(๑╹◡╹)ﾉ"""

    版权声明：本文为CSDN博主「渡梦酒」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    原文链接：渡梦酒的博客_CSDN博客-csdn领域博主

  • 相关阅读:
    [附源码]Python计算机毕业设计本科生外出请假管理信息系统
    以“社交和品质”打通长线运营，UTONMOS打造真正的Web3.0链游破圈之作
    【Apache Flink 介绍与学习】
    工信部教考中心：什么是《研发效能(DevOps)工程师》认证，拿到证书之后有什么作用！（上篇）丨IDCF
    MybatisPlus使用
    探索设计模式：从组合到享元的软件架构之旅 (软件设计师笔记)
    easyExcel获取动态表头和筛选数据导出的问题
    留学生作业Java程序帮做Javaweb帮做
    Hybrid app混合开发的一些经验和总结
    NP9 十六进制数字的大小牛客网python答案（已测试通过）
  • 原文地址：https://blog.csdn.net/weixin_53310927/article/details/130838664