【Java算法专场】二分查找(下）

小猪同学hy

已于 2024-08-07 00:06:02 修改

阅读量963

点赞数 13

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

于 2024-07-27 17:56:15 首次发布

本文链接：https://blog.csdn.net/zhyhgx/article/details/140735554

版权

算法专场专栏收录该内容

10 篇文章 2 订阅

订阅专栏

山脉数组的峰顶索引

算法分析

本道题是要在一个先升后降的数组查找拐点，如果我们采用暴力搜索的话，时间复杂度为O(n),但题目要求我们设计时间复杂度为O(logn)的算法，我们不难看出这道题也是具有二段性的，那么我们就可以采用二分查找。

算法步骤

初始化：设置双指针left和right，初始化left为1，right为nums.length-2.(由于要找峰顶，那么数组的第一个数和倒数第一个数必然不是，那么我们可以从第二个数出发）。
比较查找：定义mid，mid=left+(right-left+1)/2(为什么要+1，是为了避免整数溢出）,通过与前一个值比较，判断当前位置是处于上坡还是下坡。当nums[mid]>mid[mid-1]，说明此时mid处于上坡，让left=mid，当nums[mid]<=nums[mid-1]说明此时在下坡，让right=mid-1.循环条件为：left<right（当left==right时，说明找到了峰顶）。
返回结果：当循环结束之后，此时返回left即可。

算法代码


    /**
     * 在山形数组中找到峰值的索引。
     * 山形数组是指一个数组，其中存在一个元素，它大于其前后的所有元素（即峰值），
     * 且该元素前后的元素递增或递减。
     *
     * @param arr 山形数组，不为空且长度至少为3。
     * @return 返回数组中峰值的索引。如果有多个峰值，返回任意一个即可。
     */
    public int peakIndexInMountainArray(int[] arr) {
        /* 初始化左右指针 */
        int left = 1, right = arr.length - 2;
        /* 使用二分查找法寻找峰值 */
        while (left < right) {
            /* 计算中间索引，避免整数溢出，并确保mid大于left */
            int mid = left + (right - left + 1) / 2;
            /* 如果中间元素大于其前一个元素，则峰值在mid或其右侧 */
            if (arr[mid] > arr[mid - 1]) {
                left = mid;
            } else {
                /* 否则，峰值在mid或其左侧 */
                right = mid - 1;
            }
        }
        /* 当左右指针相遇时，即找到峰值 */
        return left;
    }

时间复杂度为O(logn),n为数组的长度，每次循环都会干掉一半的数据。

空间复杂度为O(1),只用了常数个变量。

算法示例

以arr = [0,10,5,2]为例

第一步：初始化

left=1，right=2

第二步：查找峰顶

mid=left+(right-left+1)/2=1+(2-1+1)/2=2,arr[mid]=5<arr[mid-1]=10,让right=mid-1=1.此时left=right=1，说明找到了峰顶。

第三步：返回结果

此时left=1，将left返回即可。

寻找峰值

算法分析

本道题与前面的题目类似，在数组中存在多个峰值，只需要找到其中一个峰值即可。若使用暴力解法，时间复杂度为O(n),我们可以使用二分查找，来降低复杂度，通过二分，能让时间复杂度达到O(logn).

算法步骤

初始化：定义双指针left和right，并初始化left为0，right为nums.length-1。
查找峰值：在eft和right之间进行循环。定义mid，mid=left+(right-left)/2，通过与后一个值比较，判断当前所处位置。当nums[mid]>nums[mid+1],说明此时在[left,mid]之间必然存在一个峰值，为什么能这样说？题目给我们说明了两边都是负无穷开始的，所以在[left,mid]中一定有峰值，让right=mid；当nums[mid]<=nums[mid+1]时，让left=mid+1即可,说明此时在[mid,left]中存在着峰值。循环条件为：left<right(当left和right相遇时，说明找到了峰值）
返回结果：将left返回即可。

算法代码

/**
     * 寻找峰值元素的索引。
     * 峰值元素被定义为大于其邻居的元素。
     * 
     * @param nums 整数数组，其中存在至少一个峰值元素
     * @return 返回峰值元素的索引
     */
    public int findPeakElement(int[] nums) {
        /* 初始化左右指针 */
        int left = 0;
        int right = nums.length - 1;
        
        /* 使用二分查找法寻找峰值 */
        while (left < right) {
            /* 计算中间索引，避免整数溢出 */
            int mid = left + (right - left) / 2;
            
            /* 如果中间元素大于其右侧元素，则峰值在左侧或就是中间元素 */
            if (nums[mid] > nums[mid + 1]) {
                right = mid;
            } else {
                /* 否则，峰值在右侧 */
                left = mid + 1;
            }
        }
        
        /* 当左右指针相遇时，即找到峰值 */
        return left;
    }

时间复杂度为O(logn),n为数组长度，在循环的过程中，每次都能排除掉一半的数据量。

空间复杂度为O(1),只用了常数个变量。

算法示例

以nums=[1,2,1,3,5,6,4]

第一步：初始化

让left=0，right=6

第二步：查找峰值

mid=left+(right-left)/2=0+(6-0)/2=3, nums[mid]=3<nums[mid+1]=5,此时说明峰值可能在右区间，让left=mid+1=4

2.mid=4+(6-4)/2=5,nums[mid]=6>nums[mid+1]=4,说明此时峰值在左区间，让right=mid。

3.mid=4+(5-4)/2=4,nums[mid]=5<nums[mid+1]=6，此时让left=mid+1，同时left和right相遇，说明此时找到了峰值.

第三步：返回结果

此时left=5，返回即可。

寻找旋转排序数组中的最小值

算法分析

本道题是要在一个被旋转后的数组中找到最小的元素，采用暴力遍历的算法，时间复杂度能达到O(n),但题目要求我们设计O(logn)的算法，我们可以看得出本道题也是具有二段性的，可以看成两段升序的数组。

算法步骤

初始化：设置双指针left和right，初始化left=0，right=nums.length-1。
预处理：如果数组在旋转之后还是原来的顺序，那么我们可以直接返回第一个元素，所以可以判断一下数组末尾的元素是否大于数组起始位置的元素，若大于则直接返回，反之则继续进行下续操作。
查找最小值：定义mid,mid=left+(right-left)/2,我们可以与数组两边的数进行比较，这里采用数组最右侧的数。当nums[mid]>mid[right],说明此时最小值在右区间[mid,right]中，让left=mid+1,当nums[mid]<=nums[right]时，说明此时最小值在左区间[left,mid]，让right=mid，为什么不是right=mid-1,因为mid此时的位置有可能是最小值。循环条件为：left<right（当left和right相遇时，说明找到了最小值）
返回结果：返回nums[left]或nums[right]即可。

算法代码

/**
 * 在旋转后的有序数组中查找最小值。
 * 旋转有序数组是指原数组为非递减数组，将数组从某个位置分割成两部分，然后将两部分的顺序调换后形成的数组。
 * 例如，原数组[0,1,2,4,5,6,7]在数字4处旋转后变为[4,5,6,7,0,1,2]。
 * 此函数旨在在这种旋转后的数组中找到最小的数字。
 *
 * @param nums 旋转后的有序数组
 * @return 数组中的最小值
 */
public int findMin(int[] nums) {
    int left = 0, right = nums.length - 1;
    // 如果数组的第一个元素小于最后一个元素，说明数组未旋转或旋转后的最小值就是第一个元素
    if (nums[left] < nums[right]) {
        return nums[left];
    }
    // 使用二分查找法寻找最小值
    while (left < right) {
        int mid = left + (right - left) / 2;
        // 如果中间位置的元素大于最右边的元素，说明最小值在mid右侧
        if (nums[mid] > nums[right]) {
            left = mid + 1;
        } else {
            // 否则，最小值在mid或其左侧
            right = mid;
        }
    }
    // 最终right指向最小值的位置
    return nums[right];
}

时间复杂度为O(logn)

空间复杂度为O(1)

算法示例

以nums = [4,5,6,7,0,1,2]为例

第一步：初始化

left=0,right=6

第二步：预处理

此时nums[left]=4>nums[right]=7,继续进行下续操作

第三步：找最小值

mid=left+(right-left)/2=0+(6-0)/2=3,nums[mid]=7>nums[right]=2,此时让left=mid+1=4

2.mid=4+(6-4)/2=5,nums[mid]=1<nums[right]=2,让right=mid=5

3.mid=4+(5-1)/2=4,nums[mid]=0<nums[right]=1,此时让right=mid，同时left和right相遇，结束循环。

第四步：返回结果

此时返回nums[left]=0即可。

点名

算法分析

本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。

算法步骤

初始化：设置双指针left和right，初始化left=0，right=nums.length-1
查找缺失数：定义mid，mid=left+(right-left)/2,当records[mid]==mid,说明此时在[left,mid]内的数是没有缺失的，让left=mid+1,当records[mid]！=mid,说明此时缺失值在[left,mid]中。循环条件为：left<right（当left和right相遇，说明可能找到了缺失值的位置）
返回结果：在返回left下标前，我们需要判断一下records[left]==left,若是相等，说明此时不缺值，返回left+1，反之，返回left即可。

算法代码

/**
 * 记录出席情况的函数。
 * 通过数组记录每个人的出席情况，其中数组的索引代表人的编号，数组的值代表该人实际的出席编号。
 * 函数的目的是找到第一个未出席的人的编号。
 *
 * @param records 出席记录数组，数组的第i个元素表示第i个人的出席编号。
 * @return 返回第一个未出席的人的编号。如果所有人都出席了，则返回下一个应该出席的编号。
 */
public int takeAttendance(int[] records) {
    /* 初始化左右指针 */
    int left = 0, right = records.length - 1;
    /* 使用二分查找法来寻找第一个未出席的人 */
    while (left < right) {
        /* 计算中间位置，避免整数溢出 */
        int mid = left + (right - left) / 2;
        /* 如果中间位置的人的出席编号等于其位置，则说明左边的人都出席了，调整左指针 */
        if (records[mid] == mid) {
            left = mid + 1;
        } else {
            /* 否则，说明中间位置的人未出席或者出席编号在左边，调整右指针 */
            right = mid;
        }
    }
    /* 检查最后一个人是否出席，如果出席则返回下一个出席编号，否则返回当前出席的最后一个编号 */
    return left == records[left] ? left + 1 : left;
}

时间复杂度为O(logn),

空间复杂度为O(1)

算法示例

records = [0,1,2,3,5]

第一步：初始化

left=0,right=4

第二步：查找缺失值

mid=left+(right-left)/2=0+(4-0)/2=2,records[mid]=2=mid,让left=mid+1

2.mid=3+(4-3)/2=3,records[mid]=3=mid，让left=mid+1，此时left=right，结束循环。

第三步：返回结果

此时判断records[left]是否等于left，但通过判断不是，所以这里直接返回left=4即可。

二分查找的算法专题就先到这里了~

若有不足，欢迎指正~

小猪同学hy

关注

13
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
2
评论
【Java算法专场】二分查找(下）

本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
复制链接

扫一扫