目录
33、Search in Rotated Sorted Array
153、Find Minimum in Rotated Sorted Array
一、原生二分查找及其变种
/**
* 二分查找，找到该值在数组中的下标，否则为-1
*/
static int binarySearch(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;
}
二、变种
2.1.总结
2.1.1.模板
// 这里必须是 <=
while (left <= right) {
int mid = (left + right) / 2;
if (array[mid] ? key) {
//... right = mid - 1;
}
else {
// ... left = mid + 1;
}
}
return xxx;2.1.2.首先判断出是返回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。
right和left只有一个值可以满足最后的结果，另一个肯定是和key有关系，因此不能是right指向第一个3，left指向第二个3.
2.1.3.判断比较符号
int mid = (left + right) / 2;
if (array[mid] ? key) {
//... right = xxx;
}
else {
// ... left = xxx;
}也就是这里的 if (array[mid] ? key) 中的判断符号，结合步骤1和给出的条件，如果是查找小于等于key的元素，则知道应该使用判断符号>=，因为是要返回left，所以如果array[mid]等于或者大于key，就应该使用>=，以下是完整代码
2.2.题
int[] array = {1,2,3,3,4,6};
int target = 3;
2.2.1.查找第一个相等的元素（结果是2）
最后应该是right下标为1，left下标为2.所以返回left
//因为在key左面，right需要走快点，因此判断范围放大一下，包含等于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;
}
2.2.2.查找最后一个相等的元素（结果是3）
最后应该是right下标为3，left下标为4.所以返回right
// 查找最后一个相等的元素
//因为在key右面，right需要走慢点
static int findLastEqual(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 (right >= 0 && array[right] == key) {
return right;
}
return -1;
}
2.2.3.查找最后一个小于key的元素 （结果是1）
最后应该是right下标为1，left下标为2.所以返回right
// 查找最后一个小于key的元素
//因为在key左面，right需要走快点，因此判断范围放大一下，包含等于key
static int findLastSmaller(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;
}
}
return right;
}
2.2.4.查找第一个大于key的元素（结果是4）
最后应该是right下标为3，left下标为4.所以返回left
// 查找第一个大于key的元素
//因为在key右面，right需要走慢点
static int findFirstLarger(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;
}
}
return left;
}
2.2.5.查找最后一个等于或者小于key的元素
// 查找最后一个等于或者小于key的元素
static int findLastEqualSmaller(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;
}
}
return right;
}
2.2.6.查找第一个等于或者大于key的元素
// 查找第一个等于或者大于key的元素
static int findFirstEqualLarger(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;
}
}
return left;
}二、旋转有序数组
33、Search in Rotated Sorted Array
0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2
整个数组不是有序了，还是应该按照二分查找的总思路，只不过在找des的存在位置时候麻烦了一下。
public class Solution {
public int search(int[] A, int target) {
int start=0;int end=A.length-1;int mid;
while(start<=end){
mid=(start+end)/2;
if(A[mid]==target) return mid;
if(isexit(start,mid,target,A)){
end=mid-1;
}
else start=mid+1;
}
return -1;
}
public static boolean isexit(int start,int end,int target,int[] A)
{
if(A[start]==target||A[end]==target) return true;
if(A[start]<A[end]) {
return A[start]<target&&A[end]>target;
}
else if(A[start]>A[end]){
return A[start]<target||A[end]>target;
}
else return false;
}
}
153、Find Minimum in Rotated Sorted Array
主要思想是二分查找，对于num[beg .. end]数组，命mid=(beg+end)/2,那么存在一下三种情况：
1)num[beg]<num[end]： 这时，整个数组是有序的，因此直接返回num[beg]即可；
除了第一种情况，现在已知：
end < begin，那么加上mid只有三种可能。
end< begin<mid 见下面3)
end <mid <begin 这种不成立：7 6 5 4 3 2 1
mid < end < begin 见下面1)
1)num[beg]>=num[end] && num[beg]>num[mid]：这时，num[mid..end]有序，那么最小值一定出现在num[beg..mid]之中，抛弃num[mid+1..end]；
3)num[mid]>=num[end] && num[mid]>=num[beg] : 这时,num[beg..mid]是有序的，所以最小值一点个出现在num[mid+1..end]中,因为至少num[end]是小于num[beg]的，抛弃num[beg..mid];
public class Solution {
public int findMin(int[] num){
int len = num.length;
int beg = 0;
int end = len-1;
while(beg<end){
if(num[end]>=num[beg]){
break;
}
int mid = (beg+end)/2;
if(num[mid]<num[beg]){
end = mid;
}
else{
beg = mid+1;
}
}
return num[beg];
}
} 三、其他相关
3.1.702. Search in a Sorted Array of Unknown Size - Medium
Given an integer array sorted in ascending order, write a function to search target in nums. If target exists, then return its index, otherwise return -1. However, the array size is unknown to you. You may only access the array using an ArrayReader interface, where ArrayReader.get(k) returns the element of the array at index k (0-indexed).
You may assume all integers in the array are less than 10000, and if you access the array out of bounds, ArrayReader.get will return 2147483647.
Example 1:
Input:array = [-1,0,3,5,9,12],target = 9Output: 4
Example 2:
Input:array = [-1,0,3,5,9,12],target = 2Output: -1 先向外binary search找到右边界right，再向内binary search
class Solution {
public int search(ArrayReader reader, int target) {
int left = 0, right = 1;
while(reader.get(right) != 2147483647) {
right *= 2;
}
while(left <= right) {
int mid = left + (right - left) / 2;
if(reader.get(mid) == target)
return mid;
else if(reader.get(mid) > target)
right = mid - 1;
else
left = mid + 1;
}
return -1;
}
}
269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
