力扣704-数组-二分查找

最新推荐文章于 2024-08-10 22:52:22 发布

养蛊第一人

最新推荐文章于 2024-08-10 22:52:22 发布

阅读量32

点赞数 11

分类专栏： LeetCode 文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/weixin_45764789/article/details/138358502

版权

LeetCode 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章介绍了在有序整数数组中使用单边查询、双边查询和二分法（包括左闭右闭、左闭右开、左开右闭）寻找目标值的方法，比较了它们的时间和内存效率，并指出在二分法中选择正确的区间和middle值的重要性，特别提到了可能导致死循环的问题和解决方案。

摘要由CSDN通过智能技术生成

题目

给定一个 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

方法一：单边查询

public class Solution {
    public int Search(int[] nums, int target) {
        int searchIndex=nums.Length;
        for(int i=0;i<searchIndex;i++)
        {
            if(nums[i]==target) return i;
        }
        return -1;
    }
}

非常简单的单边从左到右依次进行判断,时间击败48%，内存击败98%

方法二：双边查询

public class Solution {
    public int Search(int[] nums, int target) {
        int searchIndex=nums.Length;
        for(int i=0;i<searchIndex;i++)
        {
            if(nums[i]==target) return i;
            if(nums[searchIndex-i-1]==target) return searchIndex-i-1;
        }
        return -1;
    }
}

左右同时开始判断，时间击败89%，内存击败96%

方法三：二分法

双边查询，如果值在数列中间则很难查询到，利用二分法，先判断两端，再一直迭代判断中点

public class Solution {
    public int Search(int[] nums, int target) {
        int left=0;
        int right=nums.Length-1;
        int middle=0;
        if(nums[left]==target) return left;
        if(nums[right]==target) return right;
        if(left==right) return -1;
        while(right-left!=1){
            middle=(left+right)/2;
            if(nums[middle]==target) return middle;
            else if(nums[middle]<target) left=middle;
            else right=middle;
        }
        return -1;
    }
}

时间击败79%，内存击败84%，结果反而不如双边，总感觉代码很拖沓，且未通过长度为1的数列

方法四真正的二分法

简单看了一下视频，发现我的二分法中出现的区别，middle进行多次的判断，应当赋值middle+1或者-1,重新进行书写

学习代码的视频：手把手带你撕出正确的二分法 | 二分查找法 | 二分搜索法 | LeetCode：704. 二分查找_哔哩哔哩_bilibili

左闭右闭区间

public class Solution {
    public int Search(int[] nums, int target) {
        int left=0;
        int right=nums.Length-1;
        int middle=0;
        while(left<=right)
        {
            middle=(right+left)/2;
            if(nums[middle]==target) return middle;
            else if(nums[middle]<target) left=middle+1;
            else right=middle-1;
        }
        return -1;
    }

时间超过48%，内存超过60% 效率最高的居然还是双边，不知道是什么原因，等以后深入了解c#后再来回答

左闭右开

public class Solution {
    public int Search(int[] nums, int target) {
        int left=0;
        int right=nums.Length;
        int middle=0;
        while(left<right)
        {
            middle=(right+left)/2;
            if(nums[middle]==target) return middle;
            else if(nums[middle]<target) left=middle+1;
            else right=middle;
        }
        return -1;
    }
}

左开右闭

public class Solution {
    public int Search(int[] nums, int target) {
        int left=-1;
        int right=nums.Length-1;
        int middle=0;
        while(left<right)
        {
            middle=left+(right-left)/2+1;
            if(nums[middle]==target) return middle;
            else if(nums[middle]<target) left=middle;
            else right=middle-1;
        }
        return -1;
    }
}