LeetCode 解题思路 34（Hot 100）

解题思路：

1. 旋转数组特性： 旋转后的数组由两个递增子数组组成，且前一部分的所有元素均大于后一部分。
2. 二分查找策略：

• 若中间元素大于右边界元素，说明最小值位于中间元素的右侧。
• 若中间元素小于右边界元素，说明最小值位于中间元素或其左侧。

4. ​​终止条件： 当左右指针重合时，即为最小元素的位置。

Java代码：

class Solution {
    public int findMin(int[] nums) {
        int left = 0, right = nums.length - 1;

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

        return nums[left];
    }
}

复杂度分析：

• 时间复杂度： O(log n)。每次迭代将搜索范围缩小一半，故时间为对数级别。
• 空间复杂度： O(1)。只使用了常数级别的额外空间。

解题思路：

1. 中位转换： 中位数等价于找第 k 小的元素。总长度为奇数时取中间元素，偶数时取中间两元素均值。
2. 快速排除： 在 nums1 中寻找分割点 i，使得 nums1 和 nums2 的左半部分元素总数等于右半部分。

• 每次比较两数组中第 k/2 位置的元素（pivot1 和 pivot2）。
• 若pivot1 ≤ pivot2，说明数组 1 的前 k/2 个元素不可能是第 k 小，直接舍弃这部分。
• 否则舍弃数组 2 的前 k/2 个元素。
• 每轮排除后，更新剩余 k 值。

3. 终止条件：

• 当某一数组遍历完时，直接从另一数组取剩余元素。
• k = 1 时，当前两指针位置的较小值即为结果。

Java代码：

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int length1 = nums1.length, length2 = nums2.length;
        int totalLength = length1 + length2;
        if (totalLength % 2 == 1) {
            int midIndex = totalLength / 2;
            double median = getKthElement(nums1, nums2, midIndex + 1);
            return median;
        } else {
            int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
            double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
            return median;
        }
    }

    public int getKthElement(int[] nums1, int[] nums2, int k) {
        int length1 = nums1.length, length2 = nums2.length;
        int index1 = 0, index2 = 0;
        int kthElement = 0;

        while (true) {
            if (index1 == length1) return nums2[index2 + k - 1];
            if (index2 == length2) return nums1[index1 + k - 1];
            if (k == 1) return Math.min(nums1[index1], nums2[index2]);
            
            int half = k / 2;
            int newIndex1 = Math.min(index1 + half, length1) - 1;
            int newIndex2 = Math.min(index2 + half, length2) - 1;
            int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
            if (pivot1 <= pivot2) {
                k -= (newIndex1 - index1 + 1);
                index1 = newIndex1 + 1;
            } else {
                k -= (newIndex2 - index2 + 1);
                index2 = newIndex2 + 1;
            }
        }
    }
}

复杂度分析：

• 时间复杂度： O(log(m+n))。
• 空间复杂度： O(1)。