Snap - rotate the smallest number of an array

​Title:

Move the first elements of an array to the end of the array, which we call the rotation of the array.

Given you an array numbers with possible duplicate element values, it turns out to be an array in ascending order, rotated once as above.Please return the smallest element of the rotated array.For example, the array [3,4,5,1,2] is one rotation of [1,2,3,4,5] and the minimum value of the array is 1.

Note that the result of one rotation of the array [a[0], a[1], a[2], ..., a[n-1]] is the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]] .

Example 1:

Enter:numbers = [3,4,5,1,2]Output:1

Example 2:

Input:numbers = [2,2,2,0,1]Output:0

Binary search
The title given in the question is a semi-ordered array. Although the traditional binary tells us that the binary can only be used in the ordered array, in fact, as long as it is a problem that can be reduced and cured, the binary can still be used.Thought.

Idea: The most special positions in the array are the left position left and the right position right, compare them with the value of the middle position mid, and then determine where the smallest number appears.

Is it possible to compare the values ​​of the left position left and the middle position mid?
For example: [3, 4, 5, 1, 2] and [1, 2, 3, 4, 5], at this time, the value in the middle position is larger than the left, but the minimum value is one at the back and the other at thefront, so this approach cannot be effectively reduced.

Is it possible to compare the values ​​of the right position right and the middle position mid?
Example: [1, 2, 3, 4, 5], [3, 4, 5, 1, 2], [2, 3, 4, 5 ,1], compare the elements at the right and middle positions, you can further narrow the scope of your search.

Additional note: When nums[mid] == nums[right], you can't rashly decide which side of the conclusion is the smallest number, but it is certain that discarding right will not affect the result.

​Code implementation:

class Solution {public int minArray(int[] numbers) {int low=0;int height=numbers.length-1;while(lownumbers[height]){low=mid+1;}else if(numbers[mid]==numbers[height]){height--;}else{height=mid;}}return numbers[low];}}

This question is to use the idea of ​​binary search to continuously narrow the scope, and finally find the minimum value.

Event address: CSDN 21-day Learning Challenge