代码随想录算法训练营第33期day01:第一章数组 part01

704. 二分查找 7分24秒

        给定一个 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）左闭右闭 2）左闭右开

/*
	二分查找
*/

#include<iostream>
using namespace std;

/* 二分查找 左闭右闭 */
/* left=0, right = A.length-1 */
int midSearch01(int A[], int left, int right, int key) {
	int mid;
	while (left <= right) {										// 注意 left 和 right 之间的关系 是否可以 =
		mid = left + (right - left) / 2;						// 中间元素
		if (key == A[mid]) return mid;							// 查找成功 返回下标
		else if (key > A[mid]) left = mid + 1;					// 目标元素大于中间元素 区间往右移
		else if (key < A[mid]) right = mid - 1;					// 目标元素小于中间元素 区间往左移
	}
	return 0;
}

/* 左闭右开 */
/* left=0, right=A.length */
int midSearch02(int A[], int left, int right, int key) {
	int mid;
	while (left < right) {										// 注意 left <= right
		mid = left + (right - left) / 2;						// 中间元素
		if (key == A[mid]) return mid;							// 查找成功 返回下标
		else if (key > A[mid]) left = mid + 1;					// 目标元素大于中间元素 区间往右移
		else if (key < A[mid]) right = mid;						// 目标元素小于中间元素 区间往左移 注意注意！区别于 left < right 情况
	}
	return 0;
}

int main() {
	int A[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
	int key = 7;
	cout << midSearch02(A, 0, 8, 7);
}

---

算法思路

---

        由于题目上要求没有查找到就返回 -1，其实只要在最后结束循环之后，添加一条 return -1; 就行，因为如果查找到 早就在循环内 返回了。

int search(vector<int>& nums, int target) {

    if (nums.size() == 1) {   						// 每次都没有考虑边界值
        if (nums[0] == target) return 0;
        else return -1;
    }
    int left = 0;
    int right = nums.size() - 1;
    int mid;
    while (left <= right) {  // 左闭右闭
        mid = left + (right - left) / 2;                                           
        if (nums[mid] > target) right = mid - 1;    // 防止 left + right 过大而造成数据溢出
        if (nums[mid] < target) left = mid + 1;
        if (nums[mid] == target) return mid;
    }

    return -1;                                      // 没有查找到直接返回 -1 
}

        这里左闭右开的情况我就不写了，小伙伴自己写一下吧。

收获：主要收获了自己每次都不会考虑边界值，然后白白错过一次机会(╯▔皿▔)╯，最主要的收获还是重温了二分查找

---

 27.移除元素  11分26

         给你一个数组 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,3,0,4]

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

---

双指针

---

        双指针算法是一种常用的算法技巧，它通常用于解决数组或链表相关的问题。该算法使用两个指针在数据结构中进行迭代、搜索或比较操作。以下是一些常见的双指针算法场景：

1. 快慢指针：快慢指针是双指针算法的一种特殊形式，常用于解决链表中的问题。通过设置两个指针，一个指针每次移动一个节点，另一个指针每次移动两个节点，可以用来判断链表是否有环、找到链表的中间节点等。
2. 左右指针：左右指针是双指针算法的另一种形式，常用于解决数组中的问题。通过设置两个指针，一个指向数组的起始位置，另一个指向数组的末尾位置，可以用来查找满足某种条件的子数组或子序列。
3. 对撞指针：对撞指针也是双指针算法的一种形式，常用于解决有序数组或字符串中的问题。通过设置两个指针，一个从数组的起始位置开始，另一个从数组的末尾位置开始，根据题目要求移动指针，可以用来查找两数之和、反转字符串等。
4. 快慢指针与对撞指针的结合：在某些问题中，可以结合使用快慢指针和对撞指针来解决。例如，在有序数组中查找两数之和时，可以使用对撞指针确定两个数的位置，然后使用快慢指针来查找是否存在满足条件的两个数。

---

算法思想

---

        本题采用的是快慢指针的思想，一个 while 循环即可，初始时 slow 和 fast 同时指向数组的初始下标 ，fast 先走, 当 nums[fast] != val 时，将 fast 所指向的值赋值给 slow 指向的（在原有的数组上改变值），slow 和 fast 同时向右移，否则只有 fast 向右移。

int removeElement(vector<int>& nums, int val) {

    /*
        if (nums.size() == 0) return 0;
        if(nums.size() == 1&&nums[0]!= val) return 1;
    */

    int slow = 0, fast = 0;
    while (fast < nums.size()) {
        if (nums[fast] != val) {                 // 不等于目标值 就赋值给 slow 所指向的
            nums[slow] = nums[fast];
            ++slow;
        }
        ++fast;
    }
    return slow;
}

---

亮点部分：循环范围（边界）

---

        fast < nums.size() ==》而不是将循环条件设置为 fast < nums.size() - 1，如果设置为 fast < nums.size() - 1 不仅需要判断 数组长度为 0 和 1 的情况，而且 当 nums = [1, 1]，target = 2 时， 返回的 slow 长度只有1，也就是说最后的 1 会因为 fast ++ -> nums.size() - 1而不符合条件退出循环，因此没有包括到判断范围，所以改成 fast < nums.size()。

收获：这是二刷了，自己没多久就想到了这个方法，一刷的时候还不知道原地是啥意思嘞，而且当时还漏洞百出，代码像是打补丁一样改来改去，最后还是看了卡哥的思路。二刷真的很高兴能够写出这样简洁的代码，很有一种成就感ヾ(≧▽≦*)o，加油加油加油。又对双指针更熟悉了。