【LeetCode】8. Binary Search·二分查找

有目标就不怕路远。年轻人.无论你现在身在何方.重要的是你将要向何处去。只有明确的目标才能助你成功。没有目标的航船.任何方向的风对他来说都是逆风。因此,再遥远的旅程,只要有目标.就不怕路远。没有目标,哪来的劲头?一车尔尼雷夫斯基

导读:本篇文章讲解 【LeetCode】8. Binary Search·二分查找,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com,来源:原文

题目描述

英文版描述

Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1. You must write an algorithm with O(log n) runtime complexity.

英文版地址

https://leetcode.com/problems/binary-search/

中文版描述

给定一个 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]之间。

中文版地址

https://leetcode.cn/problems/binary-search/

解题思路🤔

综合题目要求,考虑使用递归的方法。 具体步骤:

  1. 判断数组长度并获取中值下标(长度为奇数与长度为偶数取中值的方式不同)

  2. 将该下标的数组值与目标值进行比较(会有三种情况,分别进行处理)

    1. 相等:直接返回该下标,程序结束

    2. 该下标的数组值 > 目标值:取数组前半段的数据继续从步骤1开始比较

    3. 该下标的数组值 < 目标值:取数组后半段的数据继续从步骤1开始比较

  3. 比较到最后一定只剩一个值,相等则返回下标,不相等返回-1

解题方法

俺这版

【LeetCode】8. Binary Search·二分查找

class Solution {
   public int search(int[] nums, int target) {
        int start = 0;
        int end = nums.length-1;
        return getValue(start, end, target, nums);
    }

    public int getValue(int start, int end, int target, int[] nums) {
       // length表示长度 index表示下标
        int length = end - start + 1;
        int index = 0;
        if (length < 1) {
            return -1;
        } else {
            if (length % 2 != 0) {
                // 有中间数 3/2=1
                index = length / 2 + start;
            } else {
                // 无中间数,取后半段开头第一个
                index = length / 2 + start;
            }

            if (nums[index] == target) {
                return index;
            } else {
                if (nums[index] < target) {
                    start = index + 1;
                    if ((end - start) >= 0) {
                        return getValue(start, end, target, nums);
                    } else {
                        return -1;
                    }
                } else {
                    end = index - 1;
                    if ((end - start) >= 0) {
                        return getValue(start, end, target, nums);
                    } else {
                        return -1;
                    }
                }
            }
        }
    }
}

官方版

【LeetCode】8. Binary Search·二分查找

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = (right - left) / 2 + left;
            int num = nums[mid];
            if (num == target) {
                return mid;
            } else if (num > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
}

复杂度分析

  • 时间复杂度:O(logn) 其中n为数组长度

  • 空间复杂度:O(1)

总结

一般来讲,一开始的想法很可能是暴力枚举,但其实很多暴力枚举都有着大量的重复计算,我们的优化思路其实就是空间换时间,考虑能否将已经处理过的结果存在集合中,遍历到相同节点,可以直接查表获取。

官方版的代码精简好多,while循环确实是在不知道循环次数的情况下很好的选择(一定要记得设置出口),很明显,官方提供的方法用的是迭代法,我觉得我用的是递归的方法,这引发了我对于迭代和递归的区别是什么?这个问题产生了疑问,我的代码虽然是新建了一个函数,这个函数里有自己调用自己的情况,看起来确实是递归,但是我之前对于递归的理解就像是“套娃”递归函数解决的是最小的无法再分解的那个问题,但是我这里传递的数组其实都是最原始的那个数组,只是通过起始值与结束值的更新来不断缩小数组的范围,感觉更像是形式为递归的迭代(◎_◎;),然后我就有点蒙圈了。。。希望分得清的同学指点一二(抱拳.gif)

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由极客之音整理,本文链接:https://www.bmabk.com/index.php/post/135419.html

(0)
飞熊的头像飞熊bm

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!