Leetcode 第7章 查找 7.1 search for a range

最新推荐文章于 2025-05-19 13:00:54 发布
原创 最新推荐文章于 2025-05-19 13:00:54 发布 · 264 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了二分查找的基本原理及多种应用场景，包括查找指定值的位置、寻找首个或末个匹配项等。通过具体实例讲解不同变种的实现技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

7.1 Search for a Range

描述：

Given a sorted array of integers, find the starting and ending position of a given target value.
Your algorithm’s runtime complexity must be in the order of O(log n).
If the target is not found in the array, return [-1, -1].
For example, Given [5, 7, 7, 8, 8, 10] and target value 8, return [3, 4].

分析：

已经排好序了，用二分查找。

二分查找背景：http://blog.youkuaiyun.com/yefengzhichen/article/details/52372407  可看，他人总结

http://www.cnblogs.com/SeaSky0606/p/4736639.html  ---还不错

http://www.cnblogs.com/luoxn28/p/5767571.html    --最好，重点参考

二分查找是一个基础的算法，也是面试中常考的一个知识点。二分查找就是将查找的键和子数组的中间键作比较，如果被查找的键小于中间键，就在左子数组继续查找；如果大于中间键，就在右子数组中查找，否则中间键就是要找的元素。


/**
 * 二分查找，找到该值在数组中的下标，否则为-1
 */
static int binarySerach(int[] array, int key) {
    int left = 0;
    int right = array.length - 1;

    // 这里必须是 <=
    while (left <= right) {
        int mid = (left + right) / 2;
        if (array[mid] == key) {
            return mid;
        }
        else if (array[mid] < key) {
            left = mid + 1;
        }
        else {
            right = mid - 1;
        }
    }

    return -1;
}

每次移动left和right指针的时候，需要在mid的基础上+1或者-1， 防止出现死循环， 程序也就能够正确的运行。

　　注意：代码中的判断条件必须是while (left <= right)，否则的话判断条件不完整，比如：array[3] = {1, 3, 5};待查找的键为5，此时在(low < high)条件下就会找不到，因为low和high相等时，指向元素5，但是此时条件不成立，没有进入while()中。

2 二分查找的变种

　　关于二分查找，如果条件稍微变换一下，比如：数组之中的数据可能可以重复，要求返回匹配的数据的最小（或最大）的下标；更近一步， 需要找出数组中第一个大于key的元素（也就是最小的大于key的元素的）下标，等等。 这些，虽然只有一点点的变化，实现的时候确实要更加的细心。

　　二分查找的变种和二分查找原理一样，主要就是变换判断条件（也就是边界条件），如果想直接看如何记忆这些变种的窍门，请直接翻到本文最后。下面来看几种二分查找变种的代码：

2.1 查找第一个与key相等的元素

　　查找第一个相等的元素，也就是说等于查找key值的元素有好多个，返回这些元素最左边的元素下标。

// 查找第一个相等的元素
static int findFirstEqual(int[] array, int key) {
    int left = 0;
    int right = array.length - 1;

    // 这里必须是 <=
    while (left <= right) {
        int mid = (left + right) / 2;
        if (array[mid] >= key) {
            right = mid - 1;
        }
        else {
            left = mid + 1;
        }
    }
    if (left < array.length && array[left] == key) {
        return left;
    }
    
    return -1;
}


3 二分查找变种总结

复制代码
// 这里必须是 <=
while (left <= right) {
    int mid = (left + right) / 2;
    if (array[mid] ? key) {
        //... right = mid - 1;
    }
    else {
        // ... left = mid + 1;
    }
}
return xxx;

二分查找变种较多，不过它们的“套路”是一样的，以上代码就是其套路，如何快速写出二分查找的代码，只需按照以下步骤即可：

1 首先判断出是返回left，还是返回right

　　因为我们知道最后跳出while (left <= right)循环条件是right < left，且right = left - 1。最后right和left一定是卡在"边界值"的左右两边，如果是比较值为key，查找小于等于（或者是小于）key的元素，则边界值就是等于key的所有元素的最左边那个，其实应该返回left。

　　以数组{1, 2, 3, 3, 4, 5}为例，如果需要查找第一个等于或者小于3的元素下标，我们比较的key值是3，则最后left和right需要满足以下条件：

　　我们比较的key值是3，所以此时我们需要返回left。

2 判断出比较符号
复制代码
int mid = (left + right) / 2;
if (array[mid] ? key) {
    //... right = xxx;
}
else {
    // ... left = xxx;
}
复制代码

　　也就是这里的 if (array[mid] ? key) 中的判断符号，结合步骤1和给出的条件，如果是查找小于等于key的元素，则知道应该使用判断符号>=，因为是要返回left，所以如果array[mid]等于或者大于key，就应该使用>=，以下是完整代码

复制代码
// 查找小于等于key的元素
int mid = (left + right) / 2;
if (array[mid] >= key) {
    right = mid - 1;
}
else {
    left = mid + 1;
}

秘诀：记住1 2 3 3 4 5这个例子

如果是查找小于等于key的元素，则知道应该使用判断符号>=，返回

小于 返回right


大于等于，则用<=

方法一：使用STL中的Lowbound和Upperbound、 distance、 prev

迭代器是STL中重要的一支，prev和distance是其基本方法。distance方法十分简单，就不在此赘述，现主要对prev方法以及其相关方法——advance方法作简要介绍与使用说明，并在文末附上代码示例。

advance迭代器就是将迭代器it，移动n位。如果it是随机访问迭代器，那么函数进行1次运算符计算操作，否则函数将对迭代器进行n次迭代计算操作。

【Prev 方法】

如果是随机访问迭代器，就只执行一次运算符操作（+或-），否则，执行n次持续的递减或递增操作。

prev在VC6.0之中不能实现，在VS2010之中可以实现。实际实现的操作是将迭代器递减一个单位长度而已，并未见所谓的递增操作或者根据是否作为随机迭代器时的一次或者n次操作！


实际操作：

传统二分法

插播：优快云中如何插入源代码：http://blog.youkuaiyun.com/yixueming/article/details/20851815

#include <iostream>
#include <vector>
using namespace std;

class Solution{
public:
	int binarySearch(vector<int>& nums, int key) {   //形参是vector的一个引用
		int left = 0;
		int right = nums.size() - 1;
		while (left <= right) {
					 	//int mid = (left + right) / 2;
						int mid = (left + right) >> 1;  //左移一位，相当于除以2，更快
						if (nums[mid] == key) {
							return mid;
						}
						else if (nums[mid]<key) {
							left = mid + 1;
						}
						else {
							right = mid - 1;
						}
					}
					return -1;
				}
};

int main() {
	int a[] = { 0, 1, 3, 4, 5, 8 };
	vector<int> arr(a, a+6); //原始数组的元素指针可以作为迭代器来使用
	cout << arr.size() << endl;
	for (int i = 0; i < arr.size(); i++) {
		cout << arr[i];
	}
	Solution mysolution ;
	cout << mysolution.binarySearch(arr, 5)<<endl;
}


传统二分法的变种，比如查找 第一个大于或等于 或者 最后一个小于或等于 在有重复的情况下

#include <iostream>
#include <vector>
using namespace std;

class solution {
public:
	int firstEqualOrLarger(vector<int>& nums, int key) {   //第一个等于或大于
		int left = 0;
		int right = nums.size()-1;  //这个-1要注意，是个数减去1为索引
		while (left <= right) {
			int mid = (left + right) >> 1;  // 左移一位相当于/2
			//找最左边的值，往左边走,所以要取>号，而且是right动，然后返回的左边的left
			if (nums[mid] >= key) {
				right = mid - 1;
			}
			else {
				left = mid + 1;
			}
		}
		//返回的是left
		return left;		
	}

	int lastEqualOrSmaller(vector<int>& nums, int key) {
		int left = 0;
		int right = nums.size() - 1;
		//找最右边的值，往右边走,所以要取<号，而且是left动，然后返回的左边的right
		while (left <= right) {
			int mid = (left + right) >> 1;
			//往右边走
			if (nums[mid] <= key) {
				left = mid + 1;
			}
			else {
				right = mid - 1;
			}
		}
		return right;
	}

};

int main() {
	int a[] = {1,2,3,3,4,5};
	int b[] = {1,2,3,4,6,7};
	vector<int> c(a, a + 6); //原始数组的元素指针可以作为迭代器来使用,6表示指向最后一个元素的后一个地址。
	vector<int> d(b, b + 6);
	solution mysolution;
	//cout << 5 << endl;
	cout << mysolution.firstEqualOrLarger(c,3)<<endl;
	cout << mysolution.lastEqualOrSmaller(c, 3) << endl;
	cout << mysolution.firstEqualOrLarger(d, 5)<< endl;
	cout << mysolution.lastEqualOrSmaller(d, 5)<< endl;
}




思路可参考：http://www.cnblogs.com/luoxn28/p/5767571.html


做LEETCODE的这个题目---成功搞定！

#include <iostream>
#include <vector>
using namespace std;

class solution {
public:
	vector<int> findStartEnd(vector<int> &nums, int target) {
		//首先是看存不存在，存在几个
		int count = 0;
		for (int i = 0; i < nums.size(); i++) {
			if (nums[i] == target)
				count++;
		}
		if (count == 0)
			return vector<int> {-1,-1};  //用大括号
		else {
			//找第一个等于或大于，调用另外一个函数
			int left = firstEqualOrLarger(nums, target);
			//还要找最后一个等于或小于，调用另外一个函数
			int right = lastEqualOrSmaller(nums, target);
			return vector<int> {left, right};
		}
	}

	int firstEqualOrLarger(vector<int>& nums,int target) {
		int left = 0;
		int right = nums.size() - 1;
		while (left <= right) {
			int mid = (left + right)>>1;
			//在左边，往左边移动，所以要>，返回left
			if (nums[mid] >= target) {
				right = mid -1;
			}
			else {
				left = mid + 1;
			}
		}
		return left;
	}
	

	int lastEqualOrSmaller(vector<int>& nums, int target) {
		int left = 0;
		int right = nums.size() - 1;
		while (left <= right) {
			int mid = (left + right) / 2;
			if (nums[mid] <= target) {
				left = mid + 1;
			}
			else {
				right = mid - 1;
			}
		}
		return right;
	}

};

int main() {
	solution mysolution;
	int a[] = { 5,7,7,8,8,10 };
	vector<int> b(a, a + 6);
	vector<int> result = mysolution.findStartEnd(b, 8);
	//cout << mysolution.firstEqualOrLarger(b,7);
	cout << result.size() << endl;
	for (int i = 0; i < result.size(); i++) {
		cout << result[i] << " ";
	}
}






LeetCode - Google 校招100题 第2天 树(Tree) (20题)
AGI
05-28 1212
树(Tree) 是一种非线性数据结构，由 节点(TreeNode) 组成，每个节点包含一个数据元素和指向其子节点的指针集合。树的 根节点(Root) 位于顶部，没有父节点，而叶子节点位于底部，没有子节点。二叉树结构中的每个节点最多有两个子节点，分别称为 左子节点(LeftNode) 和 右子节点(RightNode)。
LeetCode - Google 校招100题 第1天 链表(List) (15题)
AGI
05-27 781
链表(List) 是一种基础的数据结构，由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针，允许高效的插入和删除操作，只需要改变节点之间的指针，而不需要像 数组(Array) 那样移动大量元素。链表可以是单向的，也可以是双向的，其中双向链表的每个节点都有两个指针，分别指向前一个和后一个节点。
leetcode(7) | 查找 && 暴力枚举法
向着星辰大海
03-05 673
目录 一、查找 Find First and Last Position of Element in Sorted Array Search Insert Position（easy） Search in Rotated Sorted Array(mid) Search in Rotated Sorted Array II(mid) Find Minimum in Rotated S...
unique去重函数，lower_bound，upper_bound二分查找函数，sort函数，全排列
qq_42817826的博客
10-19 299
  unique去重函数 作用是去除相邻的重复元素，只保留一个,它每次把重复的元素依次往后放，并没有真正的删除。 去重之后的数组长度为unique((a,a+n)-a); lower_bound lower_bound(start,end,value),在区间[start,end)中的非递减序列进行二分查找，返回大于等于value的第一个元素的位置，如果所有元素都小于value，则返回e...
STL: prev,upper_bound,binary_search
weixin_30654419的博客
03-31 105
还是来自大神的题解：https://github.com/soulmachine/leetcode class Solution { public: vector<vector<int>> threeSum(vector<int>& num) { vector<vector<int>> resu...
LeetCode刷题记录7-从数组中找出指定条件的3个数字
柠檬柠檬C的博客
12-17 1083
题目给定一个数组nums的n个整数，a,b,c在nums中，并且a + b + c = 0。在数组中找到所有唯一的三个数字，它们的总和为零。(并且每一组由3个数字组成并每一组不存在完全相同的情况) 如下：For example, given array nums = [-1, 0, 1, 2, -1, -4],A solution set is: [ [-1, 0, 1], [-1, -1
【leetcode】二分查找专题
m0_46676283的博客
03-01 403
题目链接。
LeetCode刷题经验分享：数据结构与算法核心
最新发布
AI天才研究院
05-19 1022
本文旨在为LeetCode刷题者提供系统化的知识框架与实战经验，覆盖数据结构（数组、链表、树、图等）和算法（排序、搜索、动态规划、贪心等）的核心内容。通过深度解析典型题目，阐述如何将理论知识转化为解题策略，重点提升代码实现能力与算法优化思维。本文采用“概念解析→算法原理→实战应用→工具资源”的逻辑结构，通过理论结合代码的方式，逐步拆解LeetCode高频题型的解题思路。核心章节包括数据结构底层原理、算法复杂度分析、典型题目代码实现、实战项目案例等，帮助读者建立从问题建模到代码优化的完整思维链路。数据结构。
数据结构与算法，在LeetCode中展现风采
AI天才研究院
05-16 584
LeetCode作为全球最大的算法训练平台，收录了超过3000道编程题目，覆盖数据结构与算法的所有核心领域。数据结构的底层原理与适用场景（如数组vs链表的选择逻辑）经典算法的数学模型与代码实现（如动态规划的状态转移方程推导）LeetCode解题的标准化流程（从问题分析到代码优化的全链路）技术面试高频考点的深度解析（如二叉树遍历、字符串匹配、贪心策略）
程序员的LeetCode刷题秘籍：快速提升算法思维
AI天才研究院
05-19 1052
在技术招聘市场中，算法能力已成为程序员竞争力的核心指标。LeetCode作为全球最大的算法练习平台，收录超3000道题目，覆盖数据结构、算法设计、系统设计等多个领域。如何避免盲目刷题，建立系统化的算法思维？怎样从暴力解法进阶到最优解，掌握复杂度优化技巧？面对陌生题目时，如何快速定位解题思路？本文适用于所有希望通过LeetCode提升算法能力的开发者，从初级程序员到资深工程师均可从中获取进阶策略。基础建设：建立算法思维的核心概念（数据结构、复杂度分析）核心技术。
c++2017-6-22结构、联合与枚举
qq_28088259的博客
06-22 905
#include using namespace std; struct Address{  const char* name;  int number;  const char* street;  const char* town;  char state[2];  const char* zip; }; //不同的结构体布局，会影响结构体的内存容量 struct Rea
C++字符串处理--2017-7-17
qq_28088259的博客
07-17 632
字符串处理是我们编程时使用频率最高的，C++里有C风格的字符串库，比如strcmp、strcpy、strstr、strchr等函数，也有更为方便和智能的字符串类，如string、wstring等，看看API，练习一下就可以掌握。 C++11为了更方便字符串处理，提供了正则表达式类库，比如regex类，regex_match、regex_search、regex_replace等方法，以及re
C++容器类库-2017-7-18
qq_28088259的博客
07-18 446
是
2017.7.6C++--------类
qq_28088259的博客
07-15 406
了解class的概念，了解继承、虚函数、重载、重写、多态、纯虚函数、多重继承等概念，它们是面向对象编程在语言层面的基础。 面向对象更重要的是思想，很多C系程序员一直都在用类来写过程式程序。 class: C++中使用关键字 class 来定义类, 其基本形式如下: class 类名 { public: //行为或属性  protected: //行为或属性 privat
C++基础（2）2016.6.13
qq_28088259的博客
06-13 279
Sales_item.h #ifndef SALESITEM_H #define SALESITEM_H #include #include class Sales_item { public:  Sales_item(const std::string &book) :isbn(book), units_sold(0), revenue(0.0){}  Sales_it
C++基础2017.6.20------指针与引用
qq_28088259的博客
06-21 279
是
c++2017-6-22语句
qq_28088259的博客
07-04 265
s
2017.6.19c++
qq_28088259的博客
06-21 251
s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值