C 语言二分查找法

二分查找定义

---

 二分查找法用于查找一个有序数组中某个目标值是否存在，或者接近目标值的元素;相比把
整个数组遍历一次的0(n)复杂度，二分查找可以把复杂度降低到0(logzn):

---

 原理讲解

---

原来中间的值mid = （left + right）/ 2，但是我们写成如下的形式：mid = left + (left + right) / 2
作用是防止在数据运算的过程中初出现数据溢出。这里我们的目标值是20就是一个升序的排序方式因此采用这种移动的方法，如果目标值不同则可能移动的是right指向的数组下标元素，根据求取目标值的不同使用不同的查找方式。

 

---

升序排序

注意：这三个的数据类型一定要是有符号的数据类型因为right的值可能是 -1 ，所以三个值需要时有符号整形变量，循环的结束条件是 left = right +1 也就是left向右边移动超过right的时候表示搜索的区间为空，循环结束。

这个代码对应的数数组的升序

 

---

 代码实现

#define _CRC_SECURE_NO_WARNINGS
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>


/*
		二分查找升序的代码
*/
int32_t BinarySearch(int32_t *arr,int32_t size,int32_t key)
{
	int left = 0;
	int32_t right = size - 1;
	int32_t mid;
	while (left <= right) 
	{
		mid = left + (right - left) / 2;
		if (key < arr[mid]) 
		{
			right = mid - 1;
		}
		else if (key > arr[mid]) 
		{
			left = mid + 1;
		}
		else 
		{
			return mid;
		}
		
	}
	return -1;
}


int main() 
{
	int32_t arr[5] = { 5,8,1,3,9 };
	int len = sizeof(arr) / sizeof(arr[0]);
	int32_t index;
	index = BinarySearch(arr, len, 9);
	printf("9 index = %d.\n", index);
	index = BinarySearch(arr, len, 3);
	printf("3 index = %d.\n", index);
	index = BinarySearch(arr, len, 0);
	printf("0 index = %d.\n", index);
}

 结果：

---

降序排序

代码实现

#define _CRC_SECURE_NO_WARNINGS
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>


/*
		二分查找升序的代码
*/
int32_t BinarySearch(int32_t *arr,int32_t size,int32_t key)
{
	int left = 0;
	int32_t right = size - 1;
	int32_t mid;
	while (left <= right) 
	{
		mid = left + (right - left) / 2;
		if (key < arr[mid]) 
		{
			right = mid - 1;
		}
		else if (key > arr[mid]) 
		{
			left = mid + 1;
		}
		else 
		{
			return mid;
		}
		
	}
	return -1;
}

/*
	二分查找降序
*/
int32_t DescBinarySearch(int32_t* arr, int32_t size, int32_t key) 
{
	int32_t left = 0;
	int32_t right = size - 1;
	int32_t mid;
	while (left <= right) 
	{
		mid = left + (right - left) / 2;
		if (key > arr[mid]) 
		{
			right = mid - 1;
		}
		else if (key < arr[mid]) 
		{
			left = mid + 1;
		}
		else 
		{
			return mid;
		}
	}
	return -1;
}

int main() 
{
	int32_t arr[5] = { 5,8,1,3,9 };
	int len = sizeof(arr) / sizeof(arr[0]);
	int32_t index;
#if 0
	index = BinarySearch(arr, len, 9);
	printf("9 index = %d.\n", index);
	index = BinarySearch(arr, len, 3);
	printf("3 index = %d.\n", index);
	index = BinarySearch(arr, len, 0);
	printf("0 index = %d.\n", index);
#endif
	int32_t arr2[6] = { 20,14,10,7,3,1 };
	index = DescBinarySearch(arr2, len, 20);
	printf("20 index = %d.\n", index);
	index = DescBinarySearch(arr2, len, 14);
	printf("14 index = %d.\n", index);
	index = DescBinarySearch(arr2, len, 0);
	printf("0 index = %d.\n", index);
}

结果：

---

使用场景：找到接近目标值的下标

升序查找接近值：

 思路解析：

使用二分查找法在有序数组中查找最接近目标值的元素，可以按照以下步骤进行：

给定数组 arr[] = {1, 3, 7, 10, 14, 20} 和目标值 target = 2。

步骤 1: 初始化指针

• low 指向数组的第一个元素，即 low = 0。
• high 指向数组的最后一个元素，即 high = 5（数组下标从0开始）。
• mid 用于存储中间元素的下标。

步骤 2: 开始二分查找

进入循环，当 low <= high 时执行：

1. 计算 mid：mid = low + (height  - low) / 2

2. 注意：这里使用 (high - low) / 2 而不是 (low + high) / 2 避免了整数溢出的可能性。

3. 比较 arr[mid] 与 target：

   • 如果 arr[mid] == target，直接返回 arr[mid]。但在这个例子里，因为 target = 2 并不在数组中，我们不会遇到这种情况。
   • 如果 arr[mid] < target，更新 low = mid + 1。
   • 如果 arr[mid] > target，更新 high = mid - 1。

步骤 3: 计算最接近的元素

当退出循环时，low 和 high 之间的元素已经被排除在外。我们需要比较 arr[high] 和 arr[low] 中哪一个更接近 target。

1. 比较最接近的元素：
   • 如果 low 已经超出数组范围，返回 arr[high]。
   • 如果 high 已经低于0，返回 arr[low]。
   • 否则，比较 arr[low] 和 arr[high] 哪个离 target 更近。

让我们根据上述步骤具体计算一下：

1. 初始时，low = 0, high = 5。
2. 第一次循环，mid = (0 + 5) / 2 = 2，检查 arr[2] = 7，因为 7 > target，所以 high = mid - 1 = 1。
3. 第二次循环，mid = (0 + 1) / 2 = 0，检查 arr[0] = 1，因为 1 < target，所以 low = mid + 1 = 1。
4. 第三次循环，low = 1，high = 1，mid = 1，检查 arr[1] = 3，因为 3 > target，但是 low 和 high 相等，所以退出循环。

此时，low 和 high 都等于 1，arr[1] = 3。由于 low 不会超出数组范围，我们只需要检查 arr[1] 是否是最接近的。因为 target = 2，显然 arr[1] = 3 是最接近 target 的元素。

结论：

最接近目标值 2 的元素是 3。

---

代码实现

#define _CRC_SECURE_NO_WARNINGS
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int32_t AsecNear(int32_t* arr, int32_t size, int32_t key)
{
	int32_t left = 0;
	int32_t right = size - 1;
	int32_t mid;
	int32_t index = size - 1;
	while (left <= right)
	{
		mid = left + (right - left) / 2;
		if (key <= arr[mid])
		{
			right = mid - 1;
			index = mid;
		}
		else
		{
			left = mid + 1;
		}
	}
	return index;
}


int main() 
{
		int32_t arr[6] = { 1, 3, 7, 10, 14, 20 };
		int32_t index;
	//	index = AsecBinarySearch(arr, 6, 20);
		index = AsecNear(arr, 6, 20);
		printf("20 index = %d.\n", index);
		index = AsecNear(arr, 6, 11);
		printf("14 index = %d.\n", index);
		index = AsecNear(arr, 6, 21);
		printf("0 index = %d.\n", index);
		index = AsecNear(arr, 6, 0);
		printf("0 index = %d.\n", index);
		int32_t arr2[6] = { 20, 14, 10, 7, 3, 1 };
}

结果：

---

降序查找目标值

代码实现

#define _CRC_SECURE_NO_WARNINGS
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int32_t DescNear(int32_t* arr, int32_t size, int32_t key)
{
	int32_t left = 0;
	int32_t right = size - 1;
	int32_t mid;
	int32_t index = size - 1;
	while (left <= right)
	{
		mid = left + (right - left) / 2;
		if (key >= arr[mid])
		{
			right = mid - 1;
			index = mid;
		}
		else
		{
			left = mid + 1;
		}
	}
	return index;
}

int main() 
{
	int32_t arr[6] = { 1, 3, 7, 10, 14, 20 };
	int32_t index;
	int32_t arr2[6] = { 20, 14, 10, 7, 3, 1 };
	index = DescNear(arr2, 6, 20);
	printf("20 index = %d.\n", index);
	index = DescNear(arr2, 6, 11);
	printf("11 index = %d.\n", index);
	index = DescNear(arr2, 6, 21);
	printf("21 index = %d.\n", index);
	index = DescNear(arr2, 6, 0);
	printf("0 index = %d.\n", index);
}

结果：