代码随想录 数组-01-二分查找

704.二分查找

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

提示：

1. 你可以假设 nums 中的所有元素是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 的每个元素都将在 [-9999, 9999]之间。

左闭右闭区间

class Solution {
    public int search(int[] nums, int target) {
        int i = 0;                   // 左边界的初始位置
        int j = nums.length - 1;     // 右边界的初始位置

        // 二分查找循环
        while (i <= j) {
            int m = (i + j) >>> 1;   // 计算中间位置，使用无符号右移避免溢出

            if (target < nums[m]) {
                j = m - 1;            // 目标值在左侧，缩小搜索范围到左半边
            } else if (nums[m] < target) {
                i = m + 1;            // 目标值在右侧，缩小搜索范围到右半边
            } else {
                return m;             // 找到目标值，返回索引位置
            }
        }

        return -1;  // 未找到目标值，返回-1
    }
}

 35.搜索插入位置

35. 搜索插入位置

简单

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

提示:

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 为 无重复元素 的 升序 排列数组
• -104 <= target <= 104

class Solution {
    public int searchInsert(int[] nums, int target) {
        int i = 0;                   // 左边界的初始位置
        int j = nums.length - 1;     // 右边界的初始位置

        // 二分查找循环
        while (i <= j) {
            int m = (i + j) >>> 1;   // 计算中间位置，使用无符号右移避免溢出

            if (target < nums[m]) {
                j = m - 1;            // 目标值在左侧，缩小搜索范围到左半边
            } else if (nums[m] < target) {
                i = m + 1;            // 目标值在右侧，缩小搜索范围到右半边
            } else {
                return m;             // 找到目标值，返回索引位置
            }
        }

        return i;  // 未找到目标值，返回插入位置（即左边界 i）
    }
}

当未找到目标值时，返回的是插入位置（即左边界 i）。这是因为在二分查找过程中，如果目标值不存在于数组中，那么最终搜索区间 i 和 j 会相遇，并且 i 指向第一个大于目标值的元素位置，而 j 指向最后一个小于目标值的元素位置。因此，将 i 作为插入位置是合理的。

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

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 <= 105
• -109 <= nums[i] <= 109
• nums 是一个非递减数组
• -109 <= target <= 109

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int begin = getBeginOrEnd(nums, target, true);
        int end = getBeginOrEnd(nums, target, false);
        if (begin == -1) {
            return new int[]{-1, -1};  // 如果未找到目标值，返回{-1, -1}
        }
        return new int[]{begin, end};  // 返回目标值的起始和结束索引
    }

    /**
     * 获取目标值在数组中的起始或结束索引
     *
     * @param nums   给定的有序数组
     * @param target 目标值
     * @param choice true表示获取起始索引，false表示获取结束索引
     * @return 目标值在数组中的起始或结束索引
     */
    int getBeginOrEnd(int[] nums, int target, boolean choice) {
        int trueIndex = -1;      // 记录正确的值
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = (left + right) >>> 1;
            if (target < nums[mid]) {
                right = mid - 1;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                if (choice) {
                    trueIndex = mid;    // 求的是该元素在该数组中最左边的索引
                    right = mid - 1;
                } else {
                    trueIndex = mid;
                    left = mid + 1;     // 求的是该元素在该数组中最右边的索引
                }
            }
        }
        return trueIndex;
    }
}

 69.x的平方根

69. x 的平方根 

简单

提示

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

提示：

• 0 <= x <= 231 - 1

class Solution {
    public int mySqrt(int x) {
        int l = 0;         // 左边界的初始位置
        int r = x;         // 右边界的初始位置
        int ans = -1;      // 记录平方根的结果

        // 二分查找循环
        while (l <= r) {
            int mid = l + (r - l) / 2;   // 计算中间位置

            // 判断中间位置的平方是否小于等于x
            if ((long) mid * mid <= x) {
                ans = mid;               // 更新平方根的结果
                //我们想找到满足条件的最大整数k，使得k的平方不超过x，故小于的情况更新值
                l = mid + 1;             // 缩小搜索范围到右半边
            } else {
                r = mid - 1;             // 缩小搜索范围到左半边
            }
        }

        return ans;  // 返回平方根的结果
    }
}

 367.有效的完全平方数

367. 有效的完全平方数

简单

给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

完全平方数 是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。

不能使用任何内置的库函数，如  sqrt 。

示例 1：

输入：num = 16
输出：true
解释：返回 true ，因为 4 * 4 = 16 且 4 是一个整数。

示例 2：

输入：num = 14
输出：false
解释：返回 false ，因为 3.742 * 3.742 = 14 但 3.742 不是一个整数。

提示：

• 1 <= num <= 231 - 1

class Solution {
    public boolean isPerfectSquare(int num) {
        int left = 0;          // 左边界的初始位置
        int right = num;        // 右边界的初始位置

        // 二分查找循环
        while (left <= right) {
            int mid = (right - left) / 2 + left;   // 计算中间位置
            long square = (long) mid * mid;         // 计算中间位置的平方

            // 判断中间位置的平方与目标值的关系
            if (square < num) {
                left = mid + 1;                    // 缩小搜索范围到右半边
            } else if (square > num) {
                right = mid - 1;                   // 缩小搜索范围到左半边
            } else {
                return true;                       // 找到完全平方数，返回true
            }
        }

        return false;  // 未找到完全平方数，返回false
    }
}

74.搜索二维矩阵

74. 搜索二维矩阵

中等

给你一个满足下述两条属性的 m x n 整数矩阵：

• 每行中的整数从左到右按非严格递增顺序排列。
• 每行的第一个整数大于前一行的最后一个整数。

给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。

示例 1：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出：true

示例 2：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出：false

提示：

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 100
• -104 <= matrix[i][j], target <= 104

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        // 获取矩阵的行数 m 和列数 n
        int m = matrix.length, n = matrix[0].length;

        // 定义二分查找的左右边界
        int low = 0, high = m * n - 1;

        // 进行二分查找
        while (low <= high) {
            // 计算中间位置的索引
            int mid = (high - low) / 2 + low;

            // 将一维数组的索引转换为二维矩阵的行列索引
            int x = matrix[mid / n][mid % n];

            // 比较中间位置的元素与目标值
            if (x < target) {
                // 如果中间元素小于目标值，则调整左边界
                low = mid + 1;
            } else if (x > target) {
                // 如果中间元素大于目标值，则调整右边界
                high = mid - 1;
            } else {
                // 找到目标值，返回 true
                return true;
            }
        }

        // 如果遍历完没有找到目标值，返回 false
        return false;
    }
}

162.寻找峰值 

162. 寻找峰值

中等

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

给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞ 。

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

示例 1：

输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。

示例 2：

输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5 
解释：你的函数可以返回索引 1，其峰值元素为 2；
     或者返回索引 5， 其峰值元素为 6。

提示：

• 1 <= nums.length <= 1000
• -231 <= nums[i] <= 231 - 1
• 对于所有有效的 i 都有 nums[i] != nums[i + 1]

思路一是逐个遍历找出最大值即为峰值，时间复杂度为O（n）

思路二如下，通过二分查找遍历，如果遍历到的值不是峰值，则范围向值更大的那个范围收缩 

class Solution {
    public int findPeakElement(int[] nums) {
        int n = nums.length;
        // 初始化二分查找的左右边界
        int left = 0, right = n - 1, ans = -1;

        // 执行二分查找
        while (left <= right) {
            // 计算中间位置的索引
            int mid = (left + right) / 2;

            // 判断当前 mid 是否为峰值元素
            if (compare(nums, mid - 1, mid) < 0 && compare(nums, mid, mid + 1) > 0) {
                // 找到峰值元素，记录答案并跳出循环
                ans = mid;
                break;
            }

            // 如果 mid 右侧元素更大，则在右侧查找
            if (compare(nums, mid, mid + 1) < 0) {
                left = mid + 1;
            } else {
                // 否则在左侧查找
                right = mid - 1;
            }
        }

        // 返回找到的峰值元素的索引
        return ans;
    }

    // 比较函数，用于比较两个下标处的值
    public int compare(int[] nums, int idx1, int idx2) {
        // 如果 idx1 越界（小于 0），则认为左侧元素为负无穷，返回 -1
        if (idx1 < 0) {
            return -1;
        }

        // 如果 idx2 越界（大于等于数组长度），则认为右侧元素为正无穷，返回 1
        if (idx2 >= nums.length) {
            return 1;
        }

        // 如果 nums[idx1] 小于 nums[idx2]，返回 -1
        if (nums[idx1] < nums[idx2]) {
            return -1;
        } else {
            // 否则返回 1
            return 1;
        }
    }
}

33.搜索旋转排序数组

33. 搜索旋转排序数组

中等

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

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

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

示例 3：

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

提示：

• 1 <= nums.length <= 5000
• -104 <= nums[i] <= 104
• nums 中的每个值都 独一无二
• 题目数据保证 nums 在预先未知的某个下标上进行了旋转
• -104 <= target <= 104

在进行二分查找的过程中，一共可能出现两种情况，一个是搜索范围整体是有序的，此时按照正常的二分查找进行。第二种情况是中间位置左右两侧一侧是有序的，另一侧是无序的，此时判断出哪侧是有序的，判断target是否在这侧，如果在范围中的话，缩小范围。如果不在，则去另一侧搜索。

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length;

        // 如果数组为空，直接返回 -1
        if (n == 0) {
            return -1;
        }

        // 初始化二分查找的左右边界
        int l = 0, r = n - 1;

        // 二分查找
        while (l <= r) {
            // 计算中间位置的索引
            int mid = (l + r) / 2;

            // 如果中间元素就是目标值，返回其索引
            if (nums[mid] == target) {
                return mid;
            }

            // 如果数组当前范围是有序的（未被旋转）
            if (nums[l] < nums[r]) {
                // 如果目标值小于中间值，说明在左侧，调整右边界
                if (target < nums[mid]) {
                    r = mid - 1;
                } else {
                    // 否则，目标值在右侧，调整左边界
                    l = mid + 1;
                }
            }
            // 判断左半部分是否是有序的
            else if (nums[l] <= nums[mid]) {
                // 如果目标值在左半部分范围内，则缩小右边界
                if (nums[l] <= target && target < nums[mid]) {
                    r = mid - 1;
                } else {
                    // 否则，目标值可能在右半部分，缩小左边界
                    l = mid + 1;
                }
            } else {
                // 如果右半部分是有序的
                // 如果目标值在右半部分范围内，则缩小左边界
                if (nums[mid] < target && target <= nums[r]) {
                    l = mid + 1;
                } else {
                    // 否则，目标值可能在左半部分，缩小右边界
                    r = mid - 1;
                }
            }
        }

        // 如果找不到目标值，返回 -1
        return -1;
    }
}

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

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

中等

提示

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

• 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
• 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

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

示例 1：

输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 3 次得到输入数组。

示例 3：

输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

• n == nums.length
• 1 <= n <= 5000
• -5000 <= nums[i] <= 5000
• nums 中的所有整数 互不相同
• nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

第一种情况是 nums[pivot]<nums[high]。如下图所示，这说明 nums[pivot] 是最小值右侧的元素，因此我们可以忽略二分查找区间的右半部分。

第二种情况是 nums[pivot]>nums[high]。如下图所示，这说明 nums[pivot] 是最小值左侧的元素，因此我们可以忽略二分查找区间的左半部分。

由于数组不包含重复元素，并且只要当前的区间长度不为 1，pivot 就不会与 high 重合；而如果当前的区间长度为 1，这说明我们已经可以结束二分查找了。因此不会存在 nums[pivot]=nums[high] 的情况。

当二分查找结束时，我们就得到了最小值所在的位置。

class Solution {
    public int findMin(int[] nums) {
        int low = 0;  // 初始化左边界为数组的第一个元素
        int high = nums.length - 1;  // 初始化右边界为数组的最后一个元素

        // 当左边界小于右边界时，继续进行二分查找
        while (low < high) {
            int pivot = low + (high - low) / 2;  // 计算中间位置的索引，避免直接 (low + high) / 2 可能的整数溢出

            // 如果中间元素小于右边界元素，说明最小值在左半部分（包括 mid 位置）
            if (nums[pivot] < nums[high]) {
                high = pivot;  // 缩小搜索范围到左半部分
            } else {
                // 如果中间元素大于或等于右边界元素，说明最小值在右半部分
                low = pivot + 1;  // 缩小搜索范围到右半部分
            }
        }

        // 当 low 和 high 相等时，指向数组中的最小值
        return nums[low];
    }
}