一.题目描述
统计一个数字在排序数组中出现的次数。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: 0
限制:
0 <= 数组长度 <= 50000
二.解题思路
1.暴力法
public int search(int[] nums, int target) {
/*时间复杂度O(n),空间复杂度O(1)
* */
if(nums == null || nums.length == 0){
return 0;
}
int count = 0;
for (int i = 0; i < nums.length; i++) {
if(nums[i] == target){
count++;
}
}
return count;
}
2.暴力法,可以提前终止循环
public int search1(int[] nums, int target) {
/*时间复杂度O(n),空间复杂度O(1)
* */
if(nums == null || nums.length == 0){
return 0;
}
int count = 0;
boolean find = false;
for (int i = 0; i < nums.length; i++) {
if(nums[i] == target){
find = true;
count++;
}
if(find == true && nums[i] != target){
break;
}
}
return count;
}
3.因为是排序数组,考虑采用二分法
public int search2(int[] nums, int target) {
/*二分法
时间复杂度O(n),空间复杂度O(1)
* */
if(nums == null || nums.length == 0){
return 0;
}
int pre = 0;
int last = nums.length - 1;
int mid = (pre + last) / 2;
int count = 0;
//注意这里包含等号的情况,最后指向的一个元素也可能是target
while (pre <= last){
if(nums[mid] < target){
pre = mid + 1;
mid = (pre + last) / 2;
continue;
}
if(nums[mid] > target){
last = mid - 1;
mid = (pre + last) / 2;
continue;
}
//找到了,mid左右两边可能还有元素值等于target,所以顺序扫描,
//最坏的情况是扫描n次,此时复杂度是O(n)
int p1 = mid - 1;
int p2 = mid + 1;
while (p1 >= 0 && nums[p1] == target){
count++;
p1--;
}
while (p2 <= nums.length - 1 && nums[p2] == target){
count++;
p2++;
}
return count + 1;
}
return count;
}
这个时间复杂度还是O(n),和暴力法无太大差别,通过分析发现时间主要消耗在了确定target出现的第一个位置和最后一个位置上面
所以3的二分法还可以优化一下
4.二分法用来查找target出现的第一个位置和最后一个位置,而非一个“不确定”的位置
public int search3(int[] nums, int target) {
/*二分查找确定target的第一个位置和最后一个位置(递归法实现)
因为searchFirst和searchLast时间复杂度都是O(logn)
所以总的时间复杂度O(logn),空间复杂度O(1)
**/
if(nums == null || nums.length == 0){
return 0;
}
int initialRes = 0;
int firstIndex = searchFirst(nums, nums.length, target, 0, nums.length - 1);
int lastIndex = searchLast(nums,nums.length,target,0,nums.length-1);
//考虑如果不存在这个数字的话,不能直接return lastIndex - firstIndex + 1;
if(firstIndex > -1 && lastIndex > -1){
return lastIndex - firstIndex + 1;
}
return initialRes;
}
private int searchFirst(int[] nums, int length, int target, int start, int end) {
/*寻找target出现的第一个位置*/
if(nums == null || nums.length == 0){
return 0;
}
int index = 0;
int mid = (start + end) / 2;
if(start <= end){
//缩小一半范围,在后半段找即可
if(nums[mid] < target){
return searchFirst(nums,length,target,mid+1,end);
}
//缩小一半范围,在前半段找即可
if(nums[mid] > target){
return searchFirst(nums,length,target,start,mid-1);
}
if(nums[mid] == target){
//因为要找的是第一个出现的位置,当找到了后就判断前面一个
if(((mid - 1 > -1) && nums[mid - 1] != target) || (mid - 1 == -1)){
return mid;
}
if((mid - 1 > -1) && nums[mid - 1] == target){
return searchFirst(nums,length,target,start,mid-1);
}
}
}
return -1;
}
private int searchLast(int[] nums, int length, int target, int start, int end) {
/*寻找target出现的最后一个位置*/
if(nums == null || nums.length == 0){
return 0;
}
int index = 0;
int mid = (start + end) / 2;
if(start <= end){
//缩小一半范围,在后半段找即可
if(nums[mid] < target){
return searchLast(nums,length,target,mid+1,end);
}
//缩小一半范围,在前半段找即可
if(nums[mid] > target){
return searchLast(nums,length,target,start,mid-1);
}
//因为要找的是最后一个出现的位置,当找到了后就判断其后面一个元素
if(nums[mid] == target){
if(((mid + 1 <= end) && nums[mid + 1] != target) || (mid + 1 == end + 1)){
return mid;
}
if((mid + 1 <= end) && nums[mid + 1] == target){
return searchLast(nums,length,target,mid+1,end);
}
}
}
return -1;
}
5.4的循环法实现
public int search3(int[] nums, int target) {
/*二分查找确定target的第一个位置和最后一个位置(递归法实现)
因为searchFirst和searchLast时间复杂度都是O(logn)
所以总的时间复杂度O(logn),空间复杂度O(1)
**/
if(nums == null || nums.length == 0){
return 0;
}
int initialRes = 0;
int firstIndex = searchFirst(nums, nums.length, target, 0, nums.length - 1);
int lastIndex = searchLast(nums,nums.length,target,0,nums.length-1);
//考虑如果不存在这个数字的话,不能直接return lastIndex - firstIndex + 1;
if(firstIndex > -1 && lastIndex > -1){
return lastIndex - firstIndex + 1;
}
return initialRes;
}
private int searchFirst(int[] nums, int length, int target, int start, int end) {
/*寻找target出现的第一个位置*/
if(nums == null || nums.length == 0){
return 0;
}
int index = 0;
int mid = (start + end) / 2;
while(start <= end){
mid = (start + end) / 2;
//缩小一半范围,在后半段找即可
if(nums[mid] < target){
start = mid + 1;
}
//缩小一半范围,在前半段找即可
if(nums[mid] > target){
end = mid - 1;
}
if(nums[mid] == target){
//因为要找的是第一个出现的位置,当找到了后就判断前面一个
if(((mid - 1 > -1) && nums[mid - 1] != target) || (mid - 1 == -1)){
return mid;
}
if((mid - 1 > -1) && nums[mid - 1] == target){
end = mid - 1;
}
}
}
return -1;
}
private int searchLast(int[] nums, int length, int target, int start, int end) {
/*寻找target出现的最后一个位置*/
if(nums == null || nums.length == 0){
return 0;
}
int index = 0;
int mid = (start + end) / 2;
while(start <= end){
mid = (start + end) / 2;
//缩小一半范围,在后半段找即可
if(nums[mid] < target){
start = mid + 1;
}
//缩小一半范围,在前半段找即可
if(nums[mid] > target){
end = mid - 1;
}
//因为要找的是最后一个出现的位置,当找到了后就判断其后面一个元素
if(nums[mid] == target){
if(((mid + 1 <= end) && nums[mid + 1] != target) || (mid + 1 == end + 1)){
return mid;
}
if((mid + 1 <= end) && nums[mid + 1] == target){
start = mid + 1;
}
}
}
return -1;
}