剑指offer+面试题11-查找和排序-旋转数组的最小数字(java解答)

题目

把一个数组最开始的若干元素搬到数组的末尾，即数组的旋转。输入一个递增排序数组的一个旋转，输出旋转数组的最小元素。

例如：数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。

思路

旋转后的数组实际可以划分为两个排序的子数组

1. 用两个指针分别指向数组的第一个元素和最后一个元素（图a）
2. 找到数组的中间元素，根据数组大小移动P1/P2到该位置-->保证第一个指针指向前面递增数组的元素，第二个指针指向后面递增数组的元素（图b）
3. 最终P1、P2指向两个相邻元素，第二个指针指向最小元素（图c）
4. 特例：把排序数组前0个搬到后面，第一个数组就是最小数字直接返回
5. 当P1、P2指向的数字和中间数字三者相同，无法判断中间数字属于前数组还是后数组（{1,0,1,1,1}和{1,1,1,0,1}），不得不采用顺序查找

import java.lang.IllegalArgumentException;

public class Solution /*extends VersionControl*/ {
public int Min(int[] numbers,int length) {
	if(numbers==null||length<=0)
		throw new IllegalArgumentException("Invalid parameters");
	int index1=0;
	int index2=length-1;
	int indexMid=index1;
	while(numbers[index1]>=numbers[index2])
	{
		//如果index1和index2指向两个相邻的数
		//则index1指向第一个递增子数组的最后一个数字
		//index2指向第二个递增子数组的第一个数字，即数组中最小数字
		if(index2-index1==1)
		{
			indexMid=index2;
			break;
		}
		//如果下标为index1、index2和indexMid指向的三个数字相等，
		//则只能顺序查找
		indexMid=index1+(index2-index1)/2;
		if (numbers[index1]==numbers[index2] && numbers[indexMid]==numbers[index2])
			return MinOrder(numbers,index1,index2);
		
		//缩小查找范围
		if(numbers[indexMid]>=numbers[index1])
			index1=indexMid;
		else if (numbers[indexMid]<=numbers[index2])
			index2=indexMid;
	}
	return numbers[indexMid];
}	
public int MinOrder(int[] numbers,int index1,int index2)
{
	int result=numbers[index1];
	for(int i=index1+1;i<=index2;++i)
	{
		if(result>numbers[i])
			result=numbers[i];
	}
	return result;
}

public void Test(int[] numbers,int length,int expected)
{
	int result=0;
	try
	{
		result=Min(numbers,length);
		for(int i=0;i<length;++i)
			System.out.print(numbers[i]+" ");
		if(result==expected)
			System.out.println("passed");
		else
			System.out.println("failed");
	}
	catch(Exception e)
	{
		if (numbers==null)
			System.out.println("Text passed.");
		else
			System.out.println("Text failed");
			
	}
}

public static void main(String[] args)
{
	Solution main=new Solution();
	//典型输入，单调升序的数组的一个旋转
	int array1[]= {3,4,5,1,2};
	main.Test(array1, array1.length, 1);
	
	//有重复数字，并且重复的数字刚好是最小数字
	int array2[]= {3,4,5,1,1,2};
	main.Test(array2, array2.length, 1);
	
	//有重复数字，并且重复的数字不是第一个数字和最后一个数字
	int array3[]= {3,4,5,1,2,2};
	main.Test(array3, array3.length, 1);	
	
	//有重复数字，并且重复的数字刚好是第一个数字和最后一个数字
	int array4[]= {1,0,1,1,1};
	main.Test(array4, array4.length, 0);	
	
	//单调升序数组，旋转0个元素，也就是单调升序数组本身
	int array5[]= {1,2,3,4,5};
	main.Test(array5, array5.length, 1);	
	
	//数组只有一个数字
	int array6[]= {2};
	main.Test(array6, array6.length, 2);
	
	//输入null
	main.Test(null, 0, 0);	
}
}