【算法专题】二分查找（入门）

前言

本文主要是二分查找（入门）的文章，如果有什么需要改进的地方还请大佬指出⛺️

作者简介：大家好，我是青衿
☁️博客首页：CSDN主页放风讲故事
每日一句：努力一点，优秀一点

目录

---

二分查找

1. 二分查找搜索

题目链接 -> Leetcode -704.二分查找

Leetcode -704.二分查找

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

思路：
1.数组为有序数组，同时题目还强调数组中无重复元素
2.定义 target 是在一个在左闭右闭的区间里，也就是[left, right]
3.终止条件为right < left;
Java代码如下：

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1; // 注意

        while(left <= right) {
            int mid = left + (right - left) / 2;
            if(nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1; // 注意
            else if (nums[mid] > target)
                right = mid - 1; // 注意
        }
        return -1;
    }
}

2. 在排序数组中查找元素的第一和最后一个位置

题目链接 -> Leetcode -34.在排序数组中查找元素的第一和最后一个位置

Leetcode -34.在排序数组中查找元素的第一和最后一个位置

题目：给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回[-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：
输入：nums = [5, 7, 7, 8, 8, 10], target = 8
输出：[3, 4]

示例 2：
输入：nums = [5, 7, 7, 8, 8, 10], target = 6
输出：[-1, -1]

示例 3：
输入：nums = [], target = 0
输出：[-1, -1]

提示：

• 0 <= nums.length <= 10^5
• 10^9 <= nums[i] <= 10^9
  nums 是一个非递减数组
• 10^9 <= target <= 10^9

思路：
1.数组为有序数组，且是一个升序数组
2.定义 target 是在一个在左闭右闭的区间里，也就是[left, right]
3.终止条件为right < left;
4.两个函数分别找左边界和右边界
5.getRightBorder函数下的右边界为right即left - 1；getLeftBorder函数下的左边界为left即right+1
可画图理解判断条件：

代码如下：

class Solution {
        public int[] searchRange(int[] nums, int target) {
       int leftborder = getLeftBorder(nums, target);
        int rightborder = getRightBorder(nums, target);
            if (leftborder == -2 || rightborder == -2) {
                return new int[]{-1,-1};
            }
            if (rightborder - leftborder > 1) {
                return new int[]{leftborder+1, rightborder - 1};
            }
            return new int[]{-1,-1};}
            int getLeftBorder(int[] nums, int target) {
                int left = 0;
                int right = nums.length - 1;
                 int leftborder = -2;
                while (left <= right) {
                    int mid = left + ((right - left ) >> 1);
                    if (nums[mid] >= target) {
                        right = mid-1;
                    }
                    else {
                        left = mid+1;
                    }
                    leftborder = right;
                }

                return leftborder;
            }
            int getRightBorder(int[] nums, int target) {
                int left = 0;
                int right = nums.length - 1;
                int rightborder = -2;
                while (left <= right) {
                    int mid = left + ((right - left ) >> 1);
                    if (nums[mid] <= target) {
                        left = mid+1;
                    }
                    else {
                        right = mid-1;
                    }
                    rightborder = left;
                }
                return rightborder;

            }
    }
    

文章末尾