本文详细介绍了三种基于数组的编程题目，包括查找重复数字、寻找缺失数字和统计目标数字出现次数。每道题目均采用二分查找算法进行高效解决，详细分析了思路、复杂度并提供了优化后的代码实现。通过实例展示了二分查找在处理有序数组问题时的强大之处。
目录
前言
// 初始化哈希集合
Set<Integer> set = new HashSet<Integer>();
//函数1：添加元素，返回True或false
set.add(x)
一、题1 数组中重复的数字
1 题目
找出数组中重复的数字。
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
示例 1：
输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3
2 分析（官方题解）
①思路分析
由于只需要找出数组中任意一个重复的数字，因此遍历数组，遇到重复的数字即返回。为了判断一个数字是否重复遇到，使用集合存储已经遇到的数字，如果遇到的一个数字已经在集合中，则当前的数字是重复数字。
- 初始化集合为空集合，重复的数字 repeat = -1
- 遍历数组中的每个元素：
- 将该元素加入集合中，判断是否添加成功
- 如果添加失败，说明该元素已经在集合中，因此该元素是重复元素，将该元素的值赋给 repeat，并结束遍历
- 将该元素加入集合中，判断是否添加成功
- 返回 repeat
②复杂性分析
- 时间复杂度：O(n)。遍历数组一遍。使用哈希集合（HashSet），添加元素的时间复杂度为 O(1)，故总的时间复杂度是O(n)。
- 空间复杂度：O(n)。不重复的每个元素都可能存入集合，因此占用 O(n) 额外空间。
3 代码
class Solution {
public int findRepeatNumber(int[] nums) {
Set<Integer> set = new HashSet<Integer>();
int repeat = -1;
for (int num : nums) {
if (!set.add(num)) {
repeat = num;
break;
}
}
return repeat;
}
}
4 注意事项
- 数组获取长度不用加括号，如 int num = nums.length；
- 定义一个要返回的int类型变量要初始化；
- for循环：for（int num:nums）{}
- 自己用了一个双层循环，速度巨慢
class Solution {
// 时间：2248ms 巨慢 我的方法 but官方方法贼快 仅4ms
public int findRepeatNumber(int[] nums)
{
int num = nums.length;
for(int i=0; i<num; i++)
{
for(int j=i+1; j<num; j++)
{
if(nums[i]==nums[j])
{
return nums[i];
break；//可有可无对本题
}
}
}
return -1;
}
}
- 理清思路：
初始化一个hashset哈希集合，且定义int类型repeat变量为-1，
遍历数组中每一个元素，使用for循环for(int num:nums)，
如果该元素不能添加进哈希数组中，则该元素和集合中元素重复，则放到repeat中，并返回，break结束。这是因为哈希数组具有唯一性。
二、题： 0～n-1 中缺失的数字 （二分法）
1 题目
一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。
示例 1:
输入: [0,1,3]
输出: 2
示例 2:
输入: [0,1,2,3,4,5,6,7,9]
输出: 8
2 分析（官方题解）
①思路分析
- 排序数组中的搜索问题，首先想到 二分法 解决。
- 根据题意，数组可以按照以下规则划分为两部分。
- 左子数组： nums[i] = i ；
- 右子数组： nums[i] ≠ i ；
- 缺失的数字等于 “右子数组的首位元素” 对应的索引；因此考虑使用二分法查找 “右子数组的首位元素” 。
算法解析：
- 初始化： 左边界 i=0 ，右边界 j=len(nums)−1 ；代表闭区间 [i,j]
- 循环二分： 当 i≤j 时循环 （即当闭区间 [i,j] 为空时跳出）
- 计算中点 m=(i+j)//2 ，其中 “/” 为向下取整除法；
- 若 nums[m]=m ，则 “右子数组的首位元素” 一定在闭区间 [m+1,j] 中，因此执行 i=m+1；
- 若 nums[m] ≠ m ，则 “左子数组的末位元素” 一定在闭区间[i,m−1] 中，因此执行 j=m−1；
- 返回值： 跳出时，变量 i 和 j 分别指向 “右子数组的首位元素” 和 “左子数组的末位元素” 。因此返回 i 即可。
②复杂性分析
- 时间复杂度 O(logN)： 二分法为对数级别复杂度。
- 空间复杂度 O(1)： 几个变量使用常数大小的额外空间。
3 代码
class Solution {
public int missingNumber(int[] nums) {
// i代表右子数组首位，j代表左子数组末尾，返回i
int i=0,j=nums.length-1;
while(i<=j)
{
int m=(i+j)/2;
if(nums[m]==m) i=m+1;
else j=m-1;
}
return i;
}
}
4 注意事项
- 排序数组中的搜索问题，首先想到二分法解决。
- 向下取整：9/2=4，在图中表示，一列数字左边的数字比右边的数字少1
- 理思路：
- 看到是有有序数组，首先想到二分法。
- 定义i=0，j=nums.length-1，m=(i+j)/2; （i为该元素的位置）
- （同时，将数组分为左子数组和右子数组，左子数组是它的元素值与下标一一对应，右子数组是它的元素值与下标不相等。）
- 进入循环，进循环条件为i<=j；
- 然后比较nums[m]与m是否相等，如果相等则说明要找的目标元素在m右侧，则i=m+1;如果不相等，则说明要找的元素可能在m左侧或者m处，则j=m-1；
- 直到j<i跳出循环，返回i，即要找的元素的位置。
三、题3 在排序数组中查找数字 （二分法）
1 题目
统计一个数字在排序数组中出现的次数。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: 0
2 分析（官方题解）
①思路分析
排序数组 nums 中的所有数字 target 形成一个窗口，记窗口的 左 / 右边界 索引分别为 left 和 right ，分别对应窗口左边 / 右边的首个元素。
本题要求统计数字 target 的出现次数，可转化为：使用二分法分别找到 左边界 left 和 右边界 right ，易得数字 target 的数量为 right−left−1 。
算法解析：
- 初始化： 左边界 i=0 ，右边界 j=len(nums)−1 。
- 循环二分： 当闭区间 [i,j] 无元素时跳出；
- 计算中点 m=(i+j)/2 （向下取整）；
- 若 nums[m]<target ，则 target 在闭区间 [m+1,j]中，因此执行 i=m+1；
- 若 nums[m]>target ，则 target 在闭区间 [i,m−1] 中，因此执行 j=m−1；
若 nums[m]=target ，则右边界 right 在闭区间 [m+1,j] 中；左边界 left 在闭区间 [i,m−1]中。因此分为以下两种情况：
若查找 右边界 right ，则执行 i=m+1 ；（跳出时 i 指向右边界）
若查找 左边界 left ，则执行 j=m−1 ；（跳出时 j 指向左边界）
- 返回值： 应用两次二分，分别查找 right 和 left ，最终返回 right−left−1 即可。
效率优化：
以下优化基于：查找完右边界 right=i 后，则 nums[j] 指向最右边的 target （若存在）。
- 查找完右边界后，可用 nums[j]=j 判断数组中是否包含 target ，若不包含则直接提前返回 0 ，无需后续查找左边界。
- 查找完右边界后，左边界 left 一定在闭区间 [0,j] 中，因此直接从此区间开始二分查找即可。
②复杂度分析
- 时间复杂度 O(logN) ： 二分法为对数级别复杂度。
- 空间复杂度 O(1) ： 几个变量使用常数大小的额外空间。
3 代码
class Solution {
public int search(int[] nums, int target) {
// 搜索右边界 right
int i = 0, j = nums.length - 1;
while(i <= j) {
int m = (i + j) / 2;
if(nums[m] <= target) i = m + 1;
else j = m - 1;
}
int right = i;
// 若数组中无 target ，则提前返回
if(j >= 0 && nums[j] != target) return 0;
// 搜索左边界 right
i = 0; j = nums.length - 1;
while(i <= j) {
int m = (i + j) / 2;
if(nums[m] < target) i = m + 1;
else j = m - 1;
}
int left = j;
return right - left - 1;
}
}
以上代码显得比较臃肿（两轮二分查找代码冗余）。
为简化代码，可将二分查找右边界 right 的代码 封装至函数 helper() 。
如上图所示，由于数组 numsnums 中元素都为整数，
因此可以分别二分查找 target 和 target−1 的右边界，将两结果相减并返回即可。
本质上看， helper() 函数旨在查找数字 tartar 在数组 numsnums 中的 插入点 ，且若数组中存在值相同的元素，则插入到这些元素的右边。
改进之后的代码：
class Solution {
public int search(int[] nums, int target) {
return helper(nums, target) - helper(nums, target - 1);
}
int helper(int[] nums, int tar) {
int i = 0, j = nums.length - 1;
while(i <= j) {
int m = (i + j) / 2;
if(nums[m] <= tar) i = m + 1;
else j = m - 1;
}
return i;
}
}
4 注意事项
- 排序数组中的搜索问题，首先想到 二分法 解决。
- 理思路(改进的方法）：
- 有序数组，采用二分法；
- 定义i=0，j=nums.length-1，m=(i+j)/2；
- 定义一个找到大于目标数的的第一个位置的函数，比如target为8，返回大于8的第一个数的下标位置。
- 该函数：与上一题二分法类似，进条件为i<=j的循环，比较nums[m]与target大小，如果nums[m]<=target，则i=m+1，否则j=m-1；直到i>j，跳出循环，返回i。
- 然后进入函数(，target)得到right位置的下标，函数(，target-1)得到left位置的下标，相减为出现次数。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
