5.【入门】二分搜索-优快云博客

本文链接：https://blog.youkuaiyun.com/XY_StarField/article/details/146771658

本文的网课内容学习自B站左程云老师的算法详解课程，旨在对其中的知识进行整理和分享~

网课链接：算法讲解006【入门】二分搜索_哔哩哔哩_bilibili

一.二分查找

动图演示

算法原理

二分查找（Binary Search），也称为折半查找，是一种用于在有序数组中查找特定元素的算法。它的基本思想是将数组分成两部分，然后根据目标元素与中间元素的大小关系，决定在左半部分还是右半部分继续搜索，直到找到目标元素或者确定目标元素不存在为止。

算法步骤

初始化两个指针，left = 0 和 right = array.length - 1，分别指向数组的第一个元素和最后一个元素。
进入循环，条件为 left <= right。
计算中间元素的索引 mid = left + (right - left) / 2。
比较目标元素 target 与中间元素 array[mid] 的大小：
- 如果 target == array[mid]，则找到目标元素，返回 mid。
- 如果 target < array[mid]，则目标元素在左半部分，更新 right = mid - 1。
- 如果 target > array[mid]，则目标元素在右半部分，更新 left = mid + 1。
如果循环结束后仍未找到目标元素，则返回 -1，表示目标元素不存在于数组中。

代码实现

package binarysearch;

public class BinarySearch {
    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 (target == nums[mid]) {
                return mid;
            } else if (target < nums[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] testArray = {1, 3, 5, 7, 9, 11, 13};
        int target = 7;
        int result = search(testArray, target);
        if (result!= -1) {
            System.out.println("目标元素 " + target + " 在数组中的索引为: " + result);
        } else {
            System.out.println("目标元素 " + target + " 不在数组中");
        }
    }
}

二.在有序数组中找>=num的最左位置

算法原理

采用二分查找的思想。
- 当array[mid] >= num时，说明可能找到了符合要求的最左位置，将result记录当前的mid，然后继续在左半部分查找（因为要找最左位置），即right = mid - 1。
- 当array[mid] < num时，说明符合要求的位置在右半部分，所以left = mid + 1。

复杂度分析

时间复杂度
- 由于每次迭代都将搜索区间缩小一半，所以时间复杂度为 𝑂 ( 𝑙𝑜𝑔 𝑛 ) ，其中n是数组的长度。
空间复杂度
- 整个算法只使用了几个额外的变量（left、right、mid、result，所以空间复杂度为𝑂 ( 1 ) 。

代码实现

package binarysearch;

//保证数组有序才能用这个方法
public class LeftMostSearch {
    public static int leftMostSearch(int[] array, int num) {
        int left = 0;
        int right = array.length - 1;
        int result = -1;
        while (left <= right) {
            //int mid = left + (right - left) / 2;
            int mid = left + ((right - left) >> 1);
            if (array[mid] >= num) {
                result = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] testArray = {1, 3, 5, 7, 9, 11, 13};
        int num = 7;
        int index = leftMostSearch(testArray, num);
        if (index!= -1) {
            System.out.println("大于等于 " + num + " 的最左位置索引为: " + index);
        } else {
            System.out.println("数组中不存在大于等于 " + num + " 的元素");
        }
    }
}

三.在有序数组中找<=num的最右位置

算法原理

二分查找思路
- 同样基于二分查找的框架。在每次循环中，计算中间位置mid。
判断与更新
- 当array[mid] <= num时，说明可能找到了符合要求的最右位置，先将result更新为mid，然后在右半部分继续查找（因为要找最右位置），即left = mid + 1。
- 当array[mid] > num时，说明符合要求的位置在左半部分，所以right = mid - 1。

复杂度分析

时间复杂度
- 由于每次迭代都将搜索区间缩小一半，所以时间复杂度为 𝑂 ( 𝑙𝑜𝑔 𝑛 ) ，其中n是数组的长度。
空间复杂度
- 整个算法只使用了几个额外的变量（left、right、mid、result），所以空间复杂度为 𝑂 ( 1 ) 。

代码实现

public class RightMostSearch {
    public static int rightMostSearch(int[] array, int num) {
        int left = 0;
        int right = array.length - 1;
        int result = -1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (array[mid] <= num) {
                result = mid;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] testArray = {1, 3, 5, 7, 9, 11, 13};
        int num = 7;
        int index = rightMostSearch(testArray, num);
        if (index!= -1) {
            System.out.println("小于等于 " + num + " 的最右位置索引为: " + index);
        } else {
            System.out.println("数组中不存在小于等于 " + num + " 的元素");
        }
    }
}

四.寻找峰值问题（二分搜索不一定发生在有序数组上）

题目

峰值元素是指其严格大于左右相邻值的元素，

给你一个整数数组nums，已知任何两个相邻的值都不相等，找到峰值元素并返回其索引，

数组可能包含多个峰值，在这种情况下，返回任意一个峰值所在的位置即可。

你可以假设nums[-1] = nums[n] = 无穷小，

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

算法原理

首先，单独判断数组的第一个元素（索引为0）和最后一个元素（索引为nums.length - 1）是否为峰值元素。
如果不是，再利用二分查找来寻找峰值元素。
- 对于数组中的一个中间元素nums[mid]：
  - 如果nums[mid] > nums[mid - 1]且nums[mid] > nums[mid + 1]，那么nums[mid]就是一个峰值元素。
  - 如果nums[mid] < num[mid + 1]，则在mid的右半部分一定存在一个峰值元素，因为数组是先上升后下降的趋势，所以可以将搜索区间缩小到[mid + 1, right]。
  - 如果nums[mid] < nums[mid - 1]，则在mid的左半部分一定存在一个峰值元素，将搜索区间缩小到[left, mid - 1]。

代码实现

package binarysearch;

public class findPeakElement {
    public int findPeakElement(int[] nums) {
        int n = nums.length;
        if (n == 1) {
            return 0;
        }
        // 数组长度 >= 2
        // 单独验证0位置，是不是峰值点
        if (nums[0] > nums[1]) {
            return 0;
        }
        // 单独验证n - 1位置，是不是峰值点
        if (nums[n - 1] > nums[n - 2]) {
            return n - 1;
        }
        // 1 ~ n - 2一定有峰值点
        int left = 1;
        int right = n - 2;
        int answer = -1;
        while (left <= right) {
            int mid = left+(right - left)/2;
            // mid + 1 ~ right一定有峰值点
            if (nums[mid] < nums[mid + 1]) {
                left = mid + 1;
            }
            // left ~ mid - 1一定有峰值点
            else if (nums[mid] < nums[mid - 1]) {
                right = mid - 1;
            } else {
                answer = mid;
                break;
            }
        }
        return answer;
    }

    public static void main(String[] args) {
        findPeakElement fpe = new findPeakElement();
        int[] nums = {1, 2, 3, 1};
        int peakIndex = fpe.findPeakElement(nums);
        System.out.println("峰值元素的索引为: " + peakIndex);
    }
}