Moving the first elements of an array to the end of an array is called array rotation. Input a rotation of a non decreasing sort array and output the smallest element of the rotated array. For example, if the array {3,4,5,1,2} is a rotation of {1,2,3,4,5}, the minimum value of the array is 1. NOTE: all elements given are greater than 0. If the array size is 0, please return 0.

Idea: it can be seen that the rotation array is composed of two parts of increasing sequence, and its minimum value is the edge of the two parts, that is, the number smaller than the previous incremental sequence.

1. A slight improvement of sequential search

# -*- coding:utf-8 -*-
class Solution:
   def minNumberInRotateArray(self, rotateArray):
       left = 0
       right = len(rotateArray)-1
       if not len(rotateArray):
           return 0
       
       minn = rotateArray[0]
       for i in range(1,len(rotateArray)):
           if minn > rotateArray[i]: #Encountered the first number of the following increasing sequence
                minn = rotateArray[i]
                break
       return minn

2. The application of binary search

  
class Solution:
    def minNumberInRotateArray(self, rotateArray):
#This question mainly tests the application of binary search
       left = 0
       right = len(rotateArray) - 1
       if not len(rotateArray):
            return 0
        #Guaranteed to be a rotated array
       while (rotateArray[left] >= rotateArray[right]):
           # If the left pointer is adjacent to the right pointer, the decimal is the number that the right pointer refers to
           if ((right - left) == 1):
               mid = right
               break
           mid = (right + left) / 2
#If the middle number of the array is the same as the left pointer and the right pointer, for example: [1,0,1,1,1]
#Then search in order
           if (rotateArray[mid] == rotateArray[left] and rotateArray[right]):
               return min(rotateArray)
            #If the number of left pointer is less than the number of intermediate elements of the array, it is proved that the number of intermediate elements of the array is in the previous incremental array. At this time, the left pointer points to the intermediate element
            #On the contrary, the number of intermediate elements is in the following incremental array, and the right pointer is used to point to the number of intermediate elements
            #At this point, we can see that the left element always points to the front incremental array, and the right element always points to the subsequent incremental array. When the left and right pointers are adjacent, the number of right pointers is the minimum
           if (rotateArray[left] < rotateArray[mid]):
                left = mid
           else:
                right = mid
       return rotateArray[mid]