java数据结构与算法刷题-----LeetCode4：寻找两个正序数组的中位数

关注

原创最新推荐文章于 2026-04-23 09:32:50 发布 270 阅读 AI 写同款· GEO 优化 ›

Leetcode 寻找两个正序数组的中位数 条件说明该怎么调nums1左边太多（或太大）i要往左缩，（else 情况）nums1左边太少（或太小）i要往右扩，满足找到了合法划分直接 return 中位数。阅读详情

java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：`https://blog.youkuaiyun.com/grd_java/article/details/123063846`

思路分析

双指针遍历法，先得到中位数的下标
比如数组[1,2]和[3,4]，合起来是[1,2,3,4]那么中位数的下标就是2和3
然后用双指针，依次遍历数组，如果数组1的值比数组2的值小，那么记录这个值，然后数组1的下标后移
反之，数组2的下标后移。直到找到中位数
需要考虑数组长度不一样的问题，比如[1,2]和[1,2,3]，这样的情况，需要遍历完数组1后，只遍历数组2
最终，找到中位数对应的下标

代码

class Solution {
    //双指针遍历法，先得到中位数的下标
    //  比如数组[1,2]和[3,4]，合起来是[1,2,3,4]那么中位数的下标就是2和3
    //然后用双指针，依次遍历数组，如果数组1的值比数组2的值小，那么记录这个值，然后数组1的下标后移
    //反之，数组2的下标后移。直到找到中位数
    //需要考虑数组长度不一样的问题，比如[1,2]和[1,2,3]，这样的情况，需要遍历完数组1后，只遍历数组2
    //最终，找到中位数对应的下标
    //时间复杂度O(min(m,n)) ===>> O((m+n)/2) 空间复杂度O(1)
    public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length;
        int n = nums2.length;
        int mid1 = (m+n)/2;//中位数的位置
        int mid2 = mid1-1;//如果一共偶数个元素的中位数位置有两个
        double chu = 2.0;//最终的除数，如果最终元素个数是偶数需要除2
        if((m+n)%2!=0){//如果是奇数个元素，只有一个中位数，除数是1
            mid2 = -1;//标志不用考虑第二个中位数
            chu = 1;
        }
        int midnum1 = 0;//第一个中位数
        int midnum2 = 0;//第二个中位数，没有就是0
        int nums1Index = 0,nums2Index = 0;//第一个数组和第二个数组的下标
        int num = 0;//辅助变量，记录当前遍历的元素
        for(int i = 0;i<=mid1;i++){//遍历中位数(m+n)/2次
            if(nums2Index>=n || (nums1Index < m && nums1[nums1Index]<=nums2[nums2Index])) {
                num = nums1[nums1Index++];
            }
            else if(nums2Index<n){
                num = nums2[nums2Index++];
            }
            if(i==mid1) midnum1 = num;//如果是中位数就赋值
            if(mid2!=-1 &&i==mid2) midnum2 = num;//如果需要第二个中位数也赋值
        }
        return (midnum1+midnum2)/chu;
    }
    //时间复杂度O(min(m,n))空间复杂度O(1)
    // public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    //     if (nums1.length > nums2.length) {
    //         return findMedianSortedArrays(nums2, nums1);
    //     }

    //     int m = nums1.length;
    //     int n = nums2.length;
    //     int left = 0, right = m;
    //     // median1：前一部分的最大值
    //     // median2：后一部分的最小值
    //     int median1 = 0, median2 = 0;

    //     while (left <= right) {
    //         // 前一部分包含 nums1[0 .. i-1] 和 nums2[0 .. j-1]
    //         // 后一部分包含 nums1[i .. m-1] 和 nums2[j .. n-1]
    //         int i = (left + right) / 2;
    //         int j = (m + n + 1) / 2 - i;

    //         // nums_im1, nums_i, nums_jm1, nums_j 分别表示 nums1[i-1], nums1[i], nums2[j-1], nums2[j]
    //         int nums_im1 = (i == 0 ? Integer.MIN_VALUE : nums1[i - 1]);
    //         int nums_i = (i == m ? Integer.MAX_VALUE : nums1[i]);
    //         int nums_jm1 = (j == 0 ? Integer.MIN_VALUE : nums2[j - 1]);
    //         int nums_j = (j == n ? Integer.MAX_VALUE : nums2[j]);

    //         if (nums_im1 <= nums_j) {
    //             median1 = Math.max(nums_im1, nums_jm1);
    //             median2 = Math.min(nums_i, nums_j);
    //             left = i + 1;
    //         } else {
    //             right = i - 1;
    //         }
    //     }

    //     return (m + n) % 2 == 0 ? (median1 + median2) / 2.0 : median1;
    // }

    //时间复杂度O(max(m,n))，空间复杂度O(m+n)
    // public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
    //     int m = nums1.length;
    //     int n = nums2.length;
    //     int[] resultArr = new int[m+n];
    //     if(m == 0 || n==0)
    //         mergeTheExcess(resultArr,nums1,nums2,0,0, 0);
    //     else
    //         merge(resultArr,nums1,nums2,0,0,0);
    //     int len = resultArr.length;
    //     if(len%2==0){
    //         int i = resultArr[len/2-1];
    //         int j = resultArr[len/2];
    //         return (i+j)/2.0;
    //     }else{
    //         return resultArr[len/2];
    //     }
    // }

    // private static void merge(int[] resultArr,int[] nums1,int[] nums2,int i,int j,int resultArrIndex){
    //     if(i==nums1.length || j==nums2.length) return;
    //     if(nums1[i]<=nums2[j]){
    //         resultArr[resultArrIndex++] = nums1[i++];
    //         merge(resultArr,nums1,nums2,i,j, resultArrIndex);
    //     }else{
    //         resultArr[resultArrIndex++] = nums2[j++];
    //         merge(resultArr,nums1,nums2,i,j, resultArrIndex);
    //     }
    //     mergeTheExcess(resultArr,nums1,nums2,i,j, resultArrIndex);
    // }
    // private static void mergeTheExcess(int[] resultArr,int[] nums1,int[] nums2,int i,int j,int resultArrIndex){
    //     if(i==nums1.length){
    //         while(j<nums2.length){
    //             resultArr[resultArrIndex++] = nums2[j++];
    //         }
    //     }
    //     if(j==nums2.length){
    //         while(i<nums1.length){
    //             resultArr[resultArrIndex++] = nums1[i++];
    //         }
    //     }
    // }

    //时间复杂度O(log(m+n))，空间复杂度O(1)
    // 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) {
    //     /* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
    //      * 这里的 "/" 表示整除
    //      * nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
    //      * nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
    //      * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
    //      * 这样 pivot 本身最大也只能是第 k-1 小的元素
    //      * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
    //      * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
    //      * 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 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;
    //         }
    //     }
    // }
}

刷题一定要坚持，总结套路，不单单要把题做出来，要举一反三，也要参考别人的思路，学习别人解题的优点，找出你觉得可以优化的点。

单链表解题思路：双指针、快慢指针、反转链表、预先指针

双指针：对于单链表而言，可以方便的让我们遍历结点，并做一些额外的事
快慢指针：常用于找链表中点，找循环链表的循环点，一般快指针每次移动两个结点，慢指针每次移动一个结点。
反转链表：通常有些题，将链表反转后会更好做，一般选用三指针迭代法，递归的空间复杂度有点高
预先指针：常用于找结点，比如找倒数第3个结点，那么定义两个指针，第一个指针先移动3个结点，然后两个指针一起遍历，当第一个指针遍历完成，第二个指针指向的结点就是要找的结点

数组解题思路：双指针、三指针，下标标记

双指针：多用于减少时间复杂度，快速遍历数组
三指针：多用于二分查找，分为中间指针，左和右指针
下标标记：常用于在数组范围内找东西，而不想使用额外的空间的情况，比如找数组长度为n，元素取值范围为[1,n]的数组中没有出现的数字，遍历每个元素，然后将对应下标位置的元素变为负数或者超出[1,n]范围的正数，最后没有发生变化的元素，就是缺少的值。

栈解题思路：倒着入栈，双栈

倒着入栈：适用于出栈时想让输出是正序的情况。比如字符串’abc’，如果倒着入栈，那么栈中元素是（c,b,a）。栈是先进后出，此时出栈，结果为abc。
双栈：适用于实现队列的先入先出效果。一个栈负责输入，另一个栈负责输出。