算法训练Day1：二分查找，移除元素，双指针

算法训练Day1二分查找，移除元素，双指针

1.二分查找

Category	Difficulty	Likes	Dislikes	ContestSlug	ProblemIndex	Score
algorithms	Easy (54.46%)	1212	0	-	-	0

Tags

Companies

给定一个 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]之间。

自己第一次错误代码：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0 ,right = nums.size()-1;
        
        while(left<right) {
            if(nums[left]<target)
                left = (left + right)/2;
            else if(nums[right]>target)
                right = (left + right)/2;
            else return left;
        }
        return -1;
        
    }
};

查看其他文章更正后：

左闭右闭[left, right]解法

class Solution {
public:
    int search(vector<int>& nums, int target) {

        int left = 0 ,right = nums.size()-1;
        // 定义target在左闭右闭的区间里，[left, right]
        
        while(left<=right) {// 当left==right，区间[left, right]依然有效，所以用 <=
            int middle = left + (right - left >> 1);
            //还可以写成left + ((right -left)/2)
            // 防止溢出 等同于(left + right)/2
            if(nums[middle]<target)
                left = middle + 1;// target 在右区间，所以[middle + 1, right]
            else if(nums[middle]>target)
                right = middle - 1;// target 在左区间，所以[left, middle - 1]
            else 
                return middle; // 数组中找到目标值，直接返回下标
        }
        return -1;
    }
};

• 时间复杂度：O(log n)
• 空间复杂度：O(1)

分析总结：

** 这道题目的前提是数组为有序数组**，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件。

​ 第一次错误主要是因为对区间的定义没有想清楚，区间的定义就是不变量。要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。

写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。

2.移除元素

Category	Difficulty	Likes	Dislikes	ContestSlug	ProblemIndex	Score
algorithms	Easy (59.35%)	1705	0	-	-	0

Tags

数组 | 双指针

Companies

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

提示：

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

---

Discussion | Solution

暴力解法：

这个题目暴力的解法就是两层for循环，一个for循环遍历数组元素 ，第二个for循环更新数组。

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;
                --size;
            }
        }
        return size;
    }
};

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

双指针法

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
       int slowindex = 0 ;
       for(int fastindex = 0; fastindex <nums.size();++fastindex) {
        if(val != nums[fastindex]) {
            nums[slowindex++] = nums[fastindex];
        }
       }
       return slowindex; 
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)

相向双指针法

/**
* 相向双指针方法，基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素
* 时间复杂度：O(n)
* 空间复杂度：O(1)
*/
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int leftIndex = 0;
        int rightIndex = nums.size() - 1;
        while (leftIndex <= rightIndex) {
            // 找左边等于val的元素
            while (leftIndex <= rightIndex && nums[leftIndex] != val){
                ++leftIndex;
            }
            // 找右边不等于val的元素
            while (leftIndex <= rightIndex && nums[rightIndex] == val) {
                -- rightIndex;
            }
            // 将右边不等于val的元素覆盖左边等于val的元素
            if (leftIndex < rightIndex) {
                nums[leftIndex++] = nums[rightIndex--];
            }
        }
        return leftIndex;   // leftIndex一定指向了最终数组末尾的下一个元素
    }
};

分析总结

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

参考文章：代码随想录 (programmercarl.com)