【算法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 题：在有序数组中查找特定元素

leetcode 704 简单

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

比如说数组个数为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 (arr[min] >= target) // 再往左找找有没有元素符合>=的要求
			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 (arr[mid] < target) {
            right = mid - 1;
        } else {	// target >= arr[mid]
            result = mid;
            left = mid + 1;
        }
    }

    return result;
}

---

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();

    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 n-1;
	
	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开头部分，属于归并排序的前置知识。这里也用到二分法。主要是理解执行过程

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

#include <vector>
#include <algorithm>
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);
}

依赖关系图

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

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

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

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