LeetCode - Medium - 33

这样的话我们可以直接地用二分查找，间接找出target。

Submission

---

public class SearchInRotatedSortedArray {

// 方法一：

public int search1(int[] nums, int target) {

// 找出原第一元素

int startIndex = searchStartIndex(nums);

if (nums[0] <= target && startIndex - 1 >= 0 && target <= nums[startIndex - 1]) {

return binarySearch(nums, 0, startIndex - 1, target);

}

if (nums[startIndex] <= target && target <= nums[nums.length - 1]) {

return binarySearch(nums, startIndex, nums.length - 1, target);

}

return -1;

}

private int binarySearch(int[] nums, int left, int right, int target) {

while (left <= right) {

int mid = left + (right - left) / 2;

if (target < nums[mid]) {

right = mid - 1;

} else if (target > nums[mid]) {

left = mid + 1;

} else {

return mid;

}

}

return -1;

}

// 找出原第一元素

private int searchStartIndex(int[] nums) {

int left = 0, right = nums.length - 1;

while (left <= right) {

int mid = left + (right - left) / 2;

if (0 <= mid - 1 && nums[mid - 1] > nums[mid])

return mid;

if (mid + 1 <= nums.length - 1 && nums[mid] > nums[mid + 1])

return mid + 1;

if (nums[0] < nums[mid]) {

left = mid + 1;

} else {

right = mid - 1;

}

}

return 0;

}

// 方法二：

public int search2(int[] nums, int target) {

if (nums == null || nums.length == 0) {

return -1;

}

/* . */

int left = 0, right = nums.length - 1;

// when we use the condition “left <= right”, we do not need to determine if

// nums[left] == target

// in outside of loop, because the jumping condition is left > right, we will

// have the determination

// condition if(target == nums[mid]) inside of loop

while (left <= right) {

// left bias

int mid = left + (right - left) / 2;

if (target == nums[mid]) {

return mid;

}

// if left part is continuously monotonically increasing, or the pivot point is

// on the right part

if (nums[left] <= nums[mid]) {

// must use “<=” at here since we need to make sure target is in the left part,

// then safely drop the right part

if (nums[left] <= target && target < nums[mid]) {

right = mid - 1;

} else {

// right bias

left = mid + 1;

}

} // if right part is continuously monotonically increasing, or the pivot point is

// on the left part

else {

// must use “<=” at here since we need to make sure target is in the right part,

// then safely drop the left part

if (nums[mid] < target && target <= nums[right]) {

left = mid + 1;

} else {

right = mid - 1;

}

}

}

return -1;

}

// 方法三：

public int search3(int[] nums, int target) {

int left = 0, right = nums.length - 1;

while (left <= right) {

int mid = left + (right - left) / 2;

int midNum = nums[mid];

// If nums[mid] and target are “on the same side” of nums[0], we just take

// nums[mid].

boolean midNumAndTargetOnTheSameSide = (nums[mid] > nums[0]) == (target > nums[0]);

if (!midNumAndTargetOnTheSameSide) {

midNum = target < nums[0] ? Integer.MIN_VALUE : Integer.MAX_VALUE;

}

if (midNum < target)

left = mid + 1;

else if (midNum > target)

right = mid - 1;

else

return mid;

}

return -1;

}

// 方法四；

public int search4(int[] nums, int target) {

int left = 0, right = nums.length - 1;

// find the index of the smallest value using binary search.

// Loop will terminate since mid < right, and left or right will shrink by at

// least 1.

// Proof by contradiction that mid < right: if midright, then leftright and

// loop would

// have been terminated.

while (left < right) {

int mid = left + (right - left) / 2;

if (nums[mid] > nums[right])

left = mid + 1;

else

right = mid;

}

// left==right is the index of the smallest value and also the number of places

// rotated.

int rot = left;

left = 0;

right = nums.length - 1;

// The usual binary search and accounting for rotation.

while (left <= right) {

int mid = left + (right - left) / 2;

int rotMid = (mid + rot) % nums.length;

if (nums[rotMid] == target)

return rotMid;

if (nums[rotMid] < target)

left = mid + 1;

else

right = mid - 1;

}

return -1;

}

}

Test

---

import static org.junit.Assert.*;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import org.junit.Test;

public class SearchInRotatedSortedArrayTest {

@Test
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

Kafka进阶篇知识点

Kafka高级篇知识点

44个Kafka知识点（基础+进阶+高级）解析如下

由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

Kafka进阶篇知识点

[外链图片转存中…(img-EGY3cxK1-1711789717351)]

Kafka高级篇知识点

[外链图片转存中…(img-2Kiy0d3b-1711789717351)]

44个Kafka知识点（基础+进阶+高级）解析如下

[外链图片转存中…(img-6ReEi1Ta-1711789717352)]

由于篇幅有限，小编已将上面介绍的**《Kafka源码解析与实战》、Kafka面试专题解析、复习学习必备44个Kafka知识点（基础+进阶+高级）都整理成册，全部都是PDF文档**

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！