【算法C++实现】2、二分查找与简单递归

原视频为左程云的B站教学

---

---

1 二分查找

二分法（Binary Search）是一种在有序数组中查找特定元素的搜索算法。

基本思想：将数组从中间分割，然后判断目标元素与中间元素的大小关系，以确定目标元素在左半部分还是右半部分。然后再在相应的子数组中继续进行同样的操作，直到找到目标元素或确定目标元素不存在。

具体步骤如下：

• 将数组的左边界设为 left，右边界设为 right。
• 计算中间位置 mid，即 mid = (left + right) / 2。
• 比较目标元素与中间元素的大小关系：
  • 如果目标元素等于中间元素，则找到目标元素，返回其索引。
  • 如果目标元素小于中间元素，则更新右边界 right = mid - 1，并继续在左半部分进行二分查找。
  • 如果目标元素大于中间元素，则更新左边界 left = mid + 1，并继续在右半部分进行二分查找。
• 重复步骤 2 和步骤 3，直到找到目标元素或左边界大于右边界。

时间复杂度O(logN)，其中 n 是数组的长度。由于每次都将搜索范围减半，因此算法的效率非常高。但要求数组是有序的，否则无法应用二分法进行查找。

1.1 在有序数组中查找特定元素

基本思想是通过比较中间元素与目标元素的大小关系，将查找范围缩小一半，直到找到目标元素或查找范围为空为止。

比如说数组个数为N=16, 最差的情况要分 4 次$([8|8]\to [4|4]\to [2|2]\to [1|1])$，而$4=lo{g}_{2}16$。即时间复杂度为$O(logN)$

/* 注意：题目保证数组不为空，且 n 大于等于 1 ，以下问题默认相同 */
int binarySearch(const std::vector<int>& arr, const int value)
{
    int left = 0;
    int right = arr.size() - 1;
    // 如果这里是 int right = arr.size() 的话，那么下面有两处地方需要修改
    // 1、循环的条件 while(left < right)
    // 2、循环内当 array[middle] > value 的时候，right = middle

    while (left <= right)
    {
        int mid = left + ((right - left) >> 1);  // 不用right+left，避免int溢出，且更快
        if (array[mid] > value)
            right = mid - 1;
        else if (array[mid] < value)
            left = mid + 1;
        else
            return mid;
        // 可能会有读者认为刚开始时就要判断相等，但毕竟数组中不相等的情况更多
        // 如果每次循环都判断一下是否相等，将耗费时间
    }
    return -1;
}

留意 left + ((right - left) >> 1) 结果等用于(right + left) / 2，但更快，且不会int溢出

1.2 在一个有序数组中查找>=某个数的最左侧的位置

思路依然是二分法，不同于查找某个值找到目标值就停止二分，找最左/右侧位置问题一定是二分到底

int nearLeftSearch(const std::vector<int>& arr, const int target)
{
	int left = 0;
	int right = arr.size() - 1;
	int result = -1;
	
	while (left <= right)
	{
		int mid = left + ((right - left) >> 1);
		if (target <= arr[mid]){ // 目标值小于等于mid，就要往左继续找
			result = mid;// 暂时记录下这个位置，因为左边可能全都比目标值小了，就已经找到了
			right = mid - 1;
		} else{		// target > arr[mid]
			left = mid + 1;
		}
	}
	return result;
}

1.3 在一个有序数组中查找<=某个数最右侧位置

int nearRightSearch(const std::vector<int>& arr, int target) 
{
    int left = 0;
    int right = arr.size() - 1;
    int result = -1;

    while (left <= right) {
        int mid = left + ((right - left) >> 1);

        if (target < arr[mid]) {
            right = mid - 1;
        } else {	// target >= arr[mid]
            result = mid;
            left = mid + 1;
        }
    }

    return result;
}

---

1.2和1.3一个是 <= ，一个是 >= 怎么理解记忆
以1.3为例，其实自己写的时候，没看过算法，思考过程是这样的：

while(left <= right){
	mid = left + ((right - left) >> 1);

	if (target < arr[mid]){
		right = mid - 1;
	} else if (target > arr[mid]){ // 右侧可能有<=目标值的数(也可能没有)，因此要暂存
		result = mid;
		left = mid + 1;
	} else{ // target == arr[mid]，如果相等，暂存结果，还要往右找有没有等于的
		result = mid;
		left = mid + 1;
	}
}

发现 > 和 = 的操作是一样的，因此可以合并

1.4 局部最小值问题（无序数组使用二分法的案例）

数组arr无序，任意相邻的两个数不等，求一个局部最小的位置（极小值），要求时间复杂度优于O(N)

无序也能二分，只要目标问题在某一边必有解，另一边无所谓，就能够使用二分

1.先判断数组两个边界

• 如果左边界arr[0] < arr[1]，已找到
• 如果右边界arr[n-1] < arr[n-2]，已找到
• 如果两个边界都不是局部最小，又因为任意相邻的两个数不等，则左边界必然局部单调递减，右边界处局部单调递增。所以在数组内，必然有极小值点
  

2.进行二分，判断mid与相邻位置的关系，分为3种情况： （提醒：数组中相邻两个元素是不相等的！）

3.重复过程2直到找到极小值

int LocalMinimumSearch(const std::vector<int>& arr) 
{
    int n = arr.size();
    // 先判断元素个数为0，1的情况，如果题目给出最少元素个>1数则不需要判断
    if (n == 0) return -1;
    if (n == 1) return 0; // 只有一个元素，则是局部最小值
	
	if (arr[0] < arr[1]) return 0;
	if (arr[n-1] < arr[n-2] return 0;
	
	int left = 0;
    int right = n - 1;
	// 再次提醒，数组中相邻两个元素是不相等的！
    while (left < right) 
    {
        int mid = left + ((right - left) >> 1);

        if (arr[mid] < arr[mid - 1] && arr[mid] < arr[mid + 1]) {
            return mid;  	// 找到局部最小值的位置
        } else if (arr[mid - 1] < arr[mid]) {
            right = mid - 1;// 局部最小值可能在左侧
        } else {
            left = mid + 1; // 局部最小值可能在右侧
        }
    }
}

2 简单的递归思想

来自左哥P4开头部分，属于归并排序的前置知识。这里也用到二分法。主要是理解执行过程

例题：在数组的指定范围上求最大值，利用递归实现

#incldue <vector>
#include 
int process(const std::vector<int>& arr, int L, int R)
{
	if (L == R) return arr[L]; 
	
	int mid = L + ((R - L) >> 1);	// 求中点,右移1位相当于除以2
	int leftMax = process(arr, L, mid);
	int rightMax = process(arr, mid + 1, R);
	return std::max(leftMax, rightMax);
}

当调用 process(arr, L, R) 函数时，它会执行以下操作：

1. 首先，检查递归终止条件。如果 L 和 R 相等，表示递归到了数组的最小区间，只有一个元素。这时直接返回该元素 arr[L]。
2. 如果没有满足终止条件，说明需要继续进行递归。首先，计算中点 mid，将区间 [L, R] 平分为两个子区间 [L, mid] 和 [mid+1, R]。
3. 然后，递归调用 process(arr, L, mid)，处理左子区间。这一步会将当前函数压栈，进入一个新的递归层级。
4. 在新的递归层级中，再次执行步骤 1-3，直到满足终止条件，返回左子区间的最大值 leftMax。
5. 同理，递归调用 process(arr, mid+1, R)，处理右子区间。
6. 最后，将左右子区间的最大值 leftMax 和 rightMax 比较，取其中较大的值作为整个区间 [L, R] 的最大值，并将其作为结果返回。
7. 当递归返回到上一层时，将得到的最大值传递给上一层，直到返回到最初的调用点，得到整个数组的最大值。

递归的过程中，每一次递归调用都会创建一个新的函数栈帧，保存函数的局部变量和参数。当满足终止条件时，递归开始回溯，逐层返回最终结果，同时每层的局部变量和参数也被销毁，函数栈帧依次出栈。

依赖关系图

• 假设目标数组是[3, 2, 5, 6, 7, 4]，调用process(0,5)找最大值， 形参arr省略不写了
• 红色数字为process的执行流程，其中省略了std::max的比较并返回的过程
  

人话：要想得到数组的返回值，即第1步的返回值，首先要得到2的最大值，而它的最大值根据代码来看要先执行3，同样3又要先执行4，等二分到4这个步骤时，只有一个元素了 L==R，看代码 该元素即为当前(0,0)区间的最大值了，返回给3，3拿到leftMax后，还需要右边部分最大值，就执行5，拿到rightMax，最后对左右区间的最大值做比较，拿到(0,1)区间的最大值，又返回给2，2还需要6，6返回后，2比较后得到(0,2)的最大值，返回给1。然后执行右边的。。。。后面就省略了

2.1 递归算法时间复杂度（Master 公式）

在编程中，递归是非常常见的一种算法，由于代码简洁而应用广泛，但递归相比顺序执行或循环程序，时间复杂度难以计算，而master公式就是用于计算递归程序的时间复杂度

使用条件： 所有子问题的规模必须一致。说白了基本上就是二分、二叉树创建那种递归算法

公式：$T(N)=aT(N/b)+O(N^d)$

• $N$：母过程的数据规模是N
• $N/b$：子过程数据规模
• $a$：子过程的调用次数
• $O(N^d)$：除了子问题的调用之外，其他过程的时间复杂度

拿到abd后，根据下面的不同情况得到时间复杂度

• $lo{g}_{b}a>d$：时间复杂度为$O(N^{lo{g}_{b}a})$
• $lo{g}_{b}a=d$：时间复杂度为$O(N^d\cdot logN)$
• $lo{g}_{b}a<d$：时间复杂度为$O(N^d)$

比如上面提到的找最大值的例子就能用这个公式：

$N=2\cdot T(\frac{N}{2})+O(1)$。其中，a = 2; b = 2; d = 0

$lo{g}_{2}2=1>0$ 因此，时间复杂度为：$O(N)$