一、题目描述
把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转,输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1。 NOTE:给出的所有元素都大于0,若数组大小为0,请返回0。
1)从头到尾遍历数组一次,我们就能找出最小的元素。这种思路的时间复杂度显然是O(n)。但是这个思路没有利用输入的旋转数组的特性,肯定达不到面试官的要求。
我们注意到旋转之后的数组实际上可以划分为两个排序的子数组,而且前面的子数组的元素都大于或者等于后面子数组的元素。我们还注意到最小的元素刚好是这两个子数组的分界线。在排序的数组中我们可以用二分查找法实现O(logn)的查找。
二、解题思路
Step1.和二分查找法一样,我们用两个指针分别指向数组的第一个元素和最后一个元素。
Step2.接着我们可以找到数组中间的元素:
如果该中间元素位于前面的递增子数组,那么它应该大于或者等于第一个指针指向的元素。此时数组中最小的元素应该位于该中间元素的后面。我们可以把第一个指针指向该中间元素,这样可以缩小寻找的范围。移动之后的第一个指针仍然位于前面的递增子数组之中。如果中间元素位于后面的递增子数组,那么它应该小于或者等于第二个指针指向的元素。此时该数组中最小的元素应该位于该中间元素的前面。
Step3.接下来我们再用更新之后的两个指针,重复做新一轮的查找。
按照上述的思路,第一个指针总是指向前面递增数组的元素,而第二个指针总是指向后面递增数组的元素。最终第一个指针将指向前面子数组的最后一个元素,而第二个指针会指向后面子数组的第一个元素。也就是它们最终会指向两个相邻的元素,而第二个指针指向的刚好是最小的元素。这就是循环结束的条件。
下面代码可以不用看,可以参考:https://blog.csdn.net/nsjlive/article/details/89827039 即可。
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array==null){
return 0;
}
int low=0;
int high=array.length-1;
int indexMid=0;
// 把indexMid初始化为low的原因:
// 一旦发现数组中第一个数字小于最后一个数字,表明该数组是排序的
// 就可以直接返回第一个数字了
while(array[low]>=array[high]){
// 如果low和high指向相邻的两个数,
// 则low指向第一个递增子数组的最后一个数字,
// high指向第二个子数组的第一个数字,也就是数组中的最小数字
if(high-low==1){
indexMid= high;
break;
}
indexMid=low+(high+-low)/2;
// 特殊情况:如果下标为low、high和indexMid指向的三个数字相等,则只能顺序查找
if(array[low]==array[high]&& array[high]==array[indexMid]){
return GetMinInOrder(array,low,high);
}
// 缩小查找范围
//如果写成array[indexMid]>array[low],就无法编译通过
if(array[indexMid]>=array[low]){
low=indexMid;
}else if(array[indexMid]<=array[high]){
high=indexMid;
}
}return array[indexMid];
}
public int GetMinInOrder(int[] array, int low, int high){
int result = array[low];
for (int i = low + 1; i <= high; ++i)
{
if (result > array[i])
{
result = array[i];
}
}
return result;
}
}
注:上述代码过于复杂
indexMid=low+(high+-low)/2;
// 特殊情况:如果下标为low、high和indexMid指向的三个数字相等,则只能顺序查找
if(array[low]==array[high]&& array[high]==array[indexMid]){
return GetMinInOrder(array,low,high);
}
和
public int GetMinInOrder(int[] array, int low, int high){//
如果下标为low、high和indexMid指向的三个数字相等,则只能顺序查找
int result = array[low];
for (int i = low + 1; i <= high; ++i)
{
if (result > array[i])
{
result = array[i];
}
}return result;
}
都不是必须的,查找发现 array[low]==array[high] && array[high]==array[indexMid] ,则可以判断最小数字在mid之前,可以把high=indexMid,再进行查找;
另外,如果下标为low、high和indexMid指向的三个数字相等,则只能顺序查找
也不是必须的 ,依然可以用前面的方法查找。
所以代码可以简化为:
public int minNumberInRotateArray(int [] array) {
if(array==null){
return 0;
}
int low=0;
int high=array.length-1;
int indexMid=0;
while(array[low]>=array[high]){
if(high-low==1){
indexMid= high;
break;
}
indexMid=low+(high-low)/2;
if(array[indexMid]>array[low]){
low=indexMid;
}else {
high=indexMid;
}
}return array[indexMid];
补充:二分查找
二分查找又称折半查找,它是一种效率较高的查找方法。mid=min+(max-min)/2 ,可以有效防止各种溢出。
二分查找要求:线性表是有序表,即表中结点按关键字有序,并且要用向量作为表的存储结构。不妨设有序表是递增有序的。
/*折半查找 没有重复元素*/
public int binarySearch(int[] nums, int target) {
int low = 0, high = nums.length-1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (nums[mid] < target) { low = mid + 1; }
if (nums[mid] > target) { high = mid - 1; }
if (nums[mid] == target) { return mid; }
}
return low;
}
有重复元素的情况 :
//寻找元素第一次出现的位置。
public int firstOccurrence(int[] nums, int target) {
int low = 0, high = nums.length-1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (nums[mid] < target) { low = mid + 1; }
if (nums[mid] >= target) { high = mid - 1; }
}
return low;
}
递归版本:
//寻找元素第一次出现的位置
public int firstOccurrenceRecur(int[] nums, int target, int low, int high) {
if (low > high) { return low; }
int mid = low + (high - low) / 2;
if (nums[mid] < target) {
return firstOccurrenceRecur(nums,target,mid + 1,high);
} else {
return firstOccurrenceRecur(nums,target,low,mid-1);
}
}
参考:二分查找 https://www.zhihu.com/question/36132386
https://blog.csdn.net/my_learning_road/article/details/79524362