二分查找：

#有序数组中查找元素x
def binarySearch(nums,x):
    l = 0
    r = len(nums) - 1

    while l <= r:
        mid = l + (r-l)/2
        if nums[mid] == x :
            return mid
        elif nums[mid] < x :
            l = mid + 1
        else:
            r = mid -1
    return -1

算法复杂度：
总共有n个元素，
渐渐跟下去就是n,n/2,n/4,….n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数
由于你n/2^k取整后>=1即令n/2^k=1可得k=log2n,（是以2为底，n的对数）所以时间复杂度可以表示O(h)=O(log2n)

题目：
33. 搜索旋转排序数组
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        if len(nums) == 0 or target not in nums:
            return -1

        l=0 
        r=len(nums)-1
        while l<r:
            mid = (l + r)/2
            if nums[mid] > nums[r]:
                l = mid+1
            else:
                r = mid
        rot = l
        l = 0
        r=len(nums)-1
        while(l<=r):
            mid = (r+l)/2
            realmid = (mid + rot)%len(nums)
            print realmid
            if nums[realmid] ==target:
                return realmid
            if nums[realmid] < target:
                l = mid+1
            else:
                r = mid-1

题目：81. 搜索旋转排序数组 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
示例 1:

输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true

示例 2:

输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false

进阶:
这是 搜索旋转排序数组 的延伸题目，本题中的 nums 可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: bool
        """
        if target in nums:
            return True
        else:
            return False

上面的解法对其他语言而言相当赖皮了，下面给出复杂度O(log)的解法。

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: bool
        """
        if len(nums) == 0:
            return False      
        l = 0 
        r = len(nums)-1

        while l < r:
            mid = (l + r)/2
            if nums[mid] == target:
                return True
            if nums[mid] > nums[r]:
                if nums[mid] > target and nums[l] <= target:
                    r = mid
                else:
                    l = mid+1
            elif nums[mid] < nums[r]:
                if nums[mid] < target and nums[r]>=target:
                    l = mid+1
                else:
                    r = mid
            else:
                r = r -1
        if nums[l] == target:
            return True
        else:
            return False

题目：153. 寻找旋转排序数组中的最小值
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2]）。
找到其中最小的元素。
你可以假设数组中不存在重复元素。
示例 1:

输入: [3,4,5,1,2],
输出: 1

示例 2:

输入: [4,5,6,7,0,1,2]
输出: 0

class Solution(object):
    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        l = 0
        r = len(nums)-1
        while l < r:
            mid = (l + r)/ 2
            if nums[mid] > nums[r]:
                l = mid + 1
            else:
                r = mid 
        return nums[r]

题目：154. 寻找旋转排序数组中的最小值 II
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2]）。
找到其中最小的元素。
注意数组中可能存在重复的元素。
示例 1:

输入: [1,3,5],
输出: 1

示例 2:

输入: [2,2,2,0,1],
输出: 0

说明:
这道题是 “寻找旋转排序数组中的最小值”的延伸题目。
允许重复会影响算法的时间复杂度吗？会如何影响，为什么？

class Solution(object):
    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        l = 0
        r = len(nums)-1
        while l < r:
            mid = l + (r-l)/2           
            if nums[mid] > nums[r]:
                l = mid +1
            elif nums[mid] < nums[l]:
                r = mid
            else:
                r = r-1
        return nums[l]