LeetCode 704. 二分查找

最新推荐文章于 2024-03-02 20:05:48 发布

. . . . .

最新推荐文章于 2024-03-02 20:05:48 发布

阅读量195

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode

本文链接：https://blog.youkuaiyun.com/yexudengzhidao/article/details/99686239

LeetCode 专栏收录该内容

56 篇文章

订阅专栏

题目链接：https://leetcode-cn.com/problems/binary-search/submissions/

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

说明：

二分查找的前提是数组或列表有序，下面以升序列表为例，key为要查找的关键字，left 和 right 相当于左右指针，在数组或列表中就是左右下标，表示在数组或列表的 [left, right] 范围内查找，查找过程中不断缩小 [left, right] 覆盖的范围，直到查找成功返回下标，不成功返回None，给出循环和递归实现。

在循环实现中，是可以不需要 left 和 right 参数的，但在递归中一定需要。

时间复杂度：

最优时间复杂度：O(1)
最坏时间复杂度：O(logn)

python3代码实现（非递归）：

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """

        start, end = 0, len(nums)-1
        while start <= end:
            mid = (start+end)//2
            if nums[mid] == target:
                return mid
            elif target > nums[mid]:
                start = mid+1
            else:
                end = mid-1
        return -1
nums = [-1, 0, 3, 5, 9, 12]
target = 9

s = Solution()
rs = s.search(nums, target)
print(rs)

python3代码实现（递归）

def HalfSearch(OrderedList, key, left , right):
    if left > right:
        return None
    mid = (left + right) // 2
    if key == OrderedList[mid]:
        return mid
    elif key > OrderedList[mid]:
        return HalfSearch(OrderedList, key, mid + 1, right)
    else:
        return HalfSearch(OrderedList, key, left, mid - 1)

注：
如果参数里没有left，right，则只能通过二分查找判断当前元素在没在序列里，而不能找到对应的索引。

def binary_chop(alist, data):
    """
    递归解决二分查找
    :param alist:
    :return:
    """
    n = len(alist)
    if n < 1:
        return False
    mid = n // 2
    if alist[mid] > data:
        return binary_chop(alist[0:mid], data)
    elif alist[mid] < data:
        return binary_chop(alist[mid+1:], data)
    else:
        return True

JavaScript代码实现：

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    let [i,j] = [0, nums.length-1]
    let mid = parseInt((i+j)/2)
    while(i<=j) {
        if (target === nums[mid]){
            return mid
        } else {
            if (target < nums[mid]) {
                j = mid-1
                mid = parseInt((i+j)/2)
            } else {
                i = mid+1
                mid = parseInt((i+j)/2)
            }
        }
    }
    
    return -1
};