LeetCode的二分查找的练习部分总结

这两天由于工作的原因，一直没有写博客，但是却把LeetCode上面的题目做了不少——二分查找。上面这些题都是这两天写的。现在简单做一个总结。

首先二分查找的思想就是对一个有规律的元素（事情）进行不断的排除，最后找到符合自己想要的结果。这种排除的时间复杂度是log2（n）级别的,查询的速度非常快。

33. 搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个关键点上旋转。

（即 0 1 2 4 5 6 7 将变成 4 5 6 7 0 1 2）。

给你一个目标值来搜索，如果数组中存在这个数则返回它的索引，否则返回 -1。你可以假设数组中不存在重复。

思路：很简单的想法是直接一个循环遍历了，这样的时间复杂度是n。但是可以优化一下，这是一个旋转的序列，但是还是有两部分是有序的。

1、利用target数和数组第一个数比较大小，如果target比较小，就从后面往前遍历。

2、否则直接遍历。

代码：

class Solution:
    def search(self, nums, target):
        if len(nums)>0 and target <= nums[0]:
            if target == nums[0]:
                return 0
            for i in range(len(nums),-1,-1):
                if nums[i] == target:
                    return i
        else:
            for i in range(0,len(nums)):
                if nums[i] == target:
                    return i
        return -1

34. 搜索范围

给定一个已经升序排序的整形数组，找出给定目标值的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果在数组中找不到目标，返回 [-1, -1]。

例如:
给出 [5, 7, 7, 8, 8, 10] 和目标值 8，
返回 [3, 4]。

代码：

class Solution:
    def searchRange(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        lift = 0
        right = len(nums)-1

        while lift<=right:
            mid = (right + lift)//2
            if nums[right] == target:
                break
            if nums[mid] > target:
                right = mid - 1
            else:
                lift = mid + 1

        lift = 0
        while lift<=right:
            mid = (right + lift)//2
            if nums[lift]==target:
                break
            if nums[mid] >target:
                right = mid - 1
            else:
                lift = lift + 1
        if lift > right:
            return [-1,-1]
        else:
            return [lift,right]

35. 搜索插入位置

给定一个排序数组和一个目标值，如果在数组中找到目标值则返回索引。如果没有，返回到它将会被按顺序插入的位置。

你可以假设在数组中无重复元素。

案例 1:

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

案例 2:

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

案例 3:

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

案例 4:

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

class Solution:
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        for i in range(0,len(nums)):
            if nums[i] >= target:
                return i
        return len(nums)

50. Pow(x, n)

实现 pow(x, n)。

示例 1:

输入: 2.00000, 10
输出: 1024.00000

示例 2:

输入: 2.10000, 3
输出: 9.26100

class Solution:
    def myPow(self, x, n):
        i = n  #将n取绝对值的部分，如果n是负数，可以做在最后将结果取反。
        if n < 0:
            i = -n
        res = 1.0
        while i:#利用i控制循环的次数
            if i%2!=0:#如果i是一个奇数，将单独乘以一个x
                res = res * x
            x = x * x#x等于x的平方
            i = i // 2#对i取一半
        if n < 0:
            res = 1/res#对结果取反
        return res

69. x 的平方根

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根。

x 保证是一个非负整数。

案例 1:

输入: 4
输出: 2

案例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 由于我们想返回一个整数，小数部分将被舍去。

class Solution:
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        if x == 1:
            return 1
        right = x
        lift = 0
        while True:
            mid = lift +(right - lift)//2
            if lift*lift<=x and right*right>=x and (right - lift)<=1:
                return mid
            else:
                if mid*mid>x:
                    right = mid
                else:
                    lift = mid

74. 搜索二维矩阵

编写一个高效的算法来搜索 m x n 矩阵中的一个目标值。该矩阵具有以下特性：

每行中的整数从左到右排序。
每行的第一个整数大于前一行的最后一个整数。

例如，

以下矩阵：

[
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]

给定目标值= 3，返回 true。

class Solution:
    def searchMatrix(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """
        li = list()
        for i in matrix:
            li = li + i
        lift = 0
        right = len(li)-1
        while lift <= right:
            mid = lift + (right - lift)//2
            if li[mid] < target:
                lift = mid + 1
            elif li[mid] > target:
                right = mid - 1
            else:
                return True
        return False

81、153、154题，这三个题和33题类似，基本上是一样的。