[leetCode]33. 搜索旋转排序数组

最新推荐文章于 2024-09-27 15:23:05 发布

消灭猕猴桃

最新推荐文章于 2024-09-27 15:23:05 发布

阅读量87

点赞数

分类专栏： LeetCode # 二分查找

本文链接：https://blog.csdn.net/renweiyi1487/article/details/112857033

版权

LeetCode 同时被 2 个专栏收录

356 篇文章 5 订阅

订阅专栏

二分查找

24 篇文章 0 订阅

订阅专栏

这篇博客探讨了如何使用二分查找算法解决LeetCode上的‘搜索旋转排序数组’问题。文章提供了两种实现方式，分别是递归和迭代，通过判断数组中段的有序性来缩小搜索范围。在每种方法中，都详细解释了如何根据中间元素与边界元素的关系来决定下一步的搜索方向。这些解决方案展示了二分查找在处理复杂情况时的有效性。

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

题目

https://leetcode-cn.com/problems/search-in-rotated-sorted-array/

在这里插入图片描述

二分查找

二分查找的最终目的是要减半搜索，这题通过判断左右端点的值可以判断哪一部分是有序的。如果target在有序部分则在有序部分查找，否则在无序部分查找。

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

    private int searchHelper(int[] nums, int target, int left, int right) {
        if (left > right)
            return -1;
        int mid = left + (right - left) / 2;
        int lv = nums[left];
        int mv = nums[mid];
        int rv = nums[right];
        if (target == lv) return left;
        if (target == mv) return mid;
        if (target == rv) return right;
        if (lv < mv) {
            if (target < mv && target > lv) {
                return searchHelper(nums, target, left, mid - 1);
            } else {
                return searchHelper(nums, target, mid + 1, right);
            }
        } else {
            if (target > mv && target < rv) {
                return searchHelper(nums, target, mid + 1, right);
            } else {
                return searchHelper(nums, target, left, mid - 1);
            }
        }
    }
    
}

迭代写法:

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length;
        if (n == 0) return -1;
        if (n == 1) return target == nums[0] ? 0 : -1;
        int lo = 0, hi = n - 1;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            if (target == nums[mid])
                return mid;
            if (nums[0] <= nums[mid]) {// 可以通过nums[mid]与首位比较来判断落在那一边
                if (target < nums[mid] && target >= nums[0]) {
                    hi = mid - 1;
                } else {
                    lo = mid + 1;
                }
            } else {
                if (target > nums[mid] && target <= nums[n-1]) {
                    lo = mid + 1;
                } else {
                    hi = mid - 1;
                }
            }
        }
        return -1;
    }
}

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