C 语言二分查找法

二分查找定义


二分查找法用于查找一个有序数组中某个目标值是否存在,或者接近目标值的元素;相比把

整个数组遍历一次的0(n)复杂度,二分查找可以把复杂度降低到0(logzn):


原理讲解


原来中间的值mid = (left + right)/ 2,但是我们写成如下的形式:mid = left + (left + right) / 2

作用是防止在数据运算的过程中初出现数据溢出。这里我们的目标值是20就是一个升序的排序方式因此采用这种移动的方法,如果目标值不同则可能移动的是right指向的数组下标元素,根据求取目标值的不同使用不同的查找方式。


升序排序

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

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


代码实现

cpp 复制代码
#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);
}

结果:


降序排序

代码实现

cpp 复制代码
#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: 计算最接近的元素

当退出循环时,lowhigh 之间的元素已经被排除在外。我们需要比较 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 = 1high = 1mid = 1,检查 arr[1] = 3,因为 3 > target,但是 lowhigh 相等,所以退出循环。

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

结论:

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


代码实现

cpp 复制代码
#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 };
}

结果:


降序查找目标值

代码实现

cpp 复制代码
#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);
}

结果:

相关推荐
励志成为嵌入式工程师2 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
捕鲸叉2 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer2 小时前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
Peter_chq2 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
wheeldown3 小时前
【数据结构】选择排序
数据结构·算法·排序算法
hikktn4 小时前
如何在 Rust 中实现内存安全:与 C/C++ 的对比分析
c语言·安全·rust
观音山保我别报错4 小时前
C语言扫雷小游戏
c语言·开发语言·算法
TangKenny5 小时前
计算网络信号
java·算法·华为
景鹤5 小时前
【算法】递归+深搜:814.二叉树剪枝
算法
iiFrankie5 小时前
SCNU习题 总结与复习
算法