LeetCode004 Median of Two Sorted Arrays

最新推荐文章于 2024-07-20 22:34:59 发布
最新推荐文章于 2024-07-20 22:34:59 发布
阅读量287 收藏
点赞数
分类专栏： leetcode 文章标签： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxwtry/article/details/65969817
版权

详细见：leetcode.com/problems/median-of-two-sorted-arrays/

说明： 同时找两个，情况太多。精简成找一个就好了。


Java Solution: github

package leetcode;

/*

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

Example 1:
nums1 = [1, 3]
nums2 = [2]

The median is 2.0
Example 2:
nums1 = [1, 2]
nums2 = [3, 4]
The median is (2 + 3)/2 = 2.5

 */
public class P004_MedianofTwoSortedArrays {
	public static void main(String[] args) {
//		System.out.println(new Solution1().findMedianSortedArrays(new int[] {1, 1, 3, 3}, new int[] {1, 1, 3, 3}));
//		int k = -1;
//		while (true) {
//			k ++;
//			int[] arr1, arr2;
//			System.out.print("k: " + k + "  ");
			System.out.println(new Solution2().findKth_zxwtry(arr1 = new int[] { 0, 2, 4, 6, 8}, 0, arr1.length - 1, arr2 = new int[] {1, 3, 5, 7, 9}, 0, arr2.length - 1, k));
			System.out.println(new Solution2().findKth_zxwtry(arr1 = new int[] { 0, 1, 2, 3, 4}, 0, arr1.length - 1, arr2 = new int[] {5, 6, 7, 8, 9}, 0, arr2.length - 1, k));
			System.out.println(new Solution2().findKth_zxwtry(arr1 = new int[] { 0 }, 0, arr1.length - 1, arr2 = new int[] {5, 6, 7, 8, 9}, 0, arr2.length - 1, k));
//			System.out.println(new Solution2().findMedianSortedArrays(arr1 = new int[]{0, 1, 2, 3, 4}, arr2 = new int[] {5, 6, 7, 8, 9}));
//			if (k == arr1.length + arr2.length - 1) {
//				break;
//			}
//		}
//		System.out.println(new Solution2().findMedianSortedArrays(new int[]{8}, new int[] {5, 6, 7, 8, 9}));
		System.out.println(new Solution2().findMedianSortedArrays(new int[]{}, new int[] {5, 6}));
	}
	/*
	 *  9.33%
	 *  7ms
	 *  也真是够慢的。
	 *  但确实是O(log(M+N))
	 */
	static class Solution1 {
	    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
	        if (nums1 == null || nums2 == null) {
	        	int[] nullArr = nums1;
	        	if (nullArr == null)
	        		nullArr = nums2;
	        	if (nullArr == null)
	        		return 0;
	        	if ((nullArr.length & 0x1) == 1)
	        		return nullArr[nullArr.length >>> 1];
	        	else
	        		return ((double)nullArr[nullArr.length >>> 1] + nullArr[(nullArr.length >>> 1) - 1]) / 2;
	        }
	        if (nums1.length == 0) {
	        	return findMedianSortedArrays(null, nums2);
	        } else if (nums2.length == 0) {
	        	return findMedianSortedArrays(nums1, null);
	        }
	        if (((nums1.length+nums2.length) & 0x1) == 1) {
	        	return findMedianSortedArraysOdd(nums1, 0, nums1.length-1, nums2, 0, nums2.length-1);
	        } else {
	        	return findMedianSortedArraysEven(nums1, 0, nums1.length-1, nums2, 0, nums2.length-1);
	        }
	    }
	    /*
	     * 	总共偶数个
	     * 	返回两个数的平均
	     */
		double findMedianSortedArraysEven(int[] nums1, int l1, int r1, int[] nums2, int l2, int r2) {
			int d1 = r1 - l1, d2 = r2 - l2, dd = d1 - d2, offset = Math.abs(dd) >>> 1;
			if (d1 > d2)
				return findMedianSortedArraysEven(nums2, l2, r2, nums1, l1, r1);
			if (nums1[r1] <= nums2[l2]) {
				if (dd == 0) {
					return ((double)nums1[r1] + nums2[l2]) / 2;
				} else {
					return ((double)nums2[l2 + offset] + nums2[l2 + offset - 1]) / 2;
				}
			} else if (nums2[r2] <= nums1[l1]) {
				if (dd == 0) {
					return ((double)nums1[l1] + nums2[r2]) / 2;
				} else {
					return ((double)nums2[r2 - offset] + nums2[r2 - offset + 1]) / 2;
				}
			}
			int m1 = (l1 + r1) >>> 1, m2 = (l2 + r2) >>> 1;
			if (r1 == m1) {
				if (nums2[m2] > nums1[m1]) {
					return nums2[m2 - 1] < nums1[m1] ? ((double)nums2[m2] + nums1[m1]) / 2 : ((double)nums2[m2] + nums2[m2 - 1]) / 2;
				} else {
					return nums2[m2 + 1] > nums1[m1] ? ((double)nums2[m2] + nums1[m1]) / 2 : ((double)nums2[m2] + nums2[m2 + 1]) / 2;
				}
			} 
			if (l2 == m2)
				return ((double) Math.max(nums1[l1], nums2[m2]) + Math.min(nums1[r1], nums2[m2+1])) / 2;
			if (l1 == m1) {
				if (nums1[r1] < nums2[m2 - 1])
					return ((double)nums2[m2 - 1] + nums2[m2]) / 2;
				else if (nums1[l1] > nums2[m2 + 1])
					return ((double)nums2[m2 + 1] + Math.min(nums2[m2 + 2], nums1[l1])) / 2;
				else 
					return ((double) Math.min(nums1[r1], nums2[m2 +1]) + Math.max(nums1[l1], nums2[m2])) / 2;
			}
			if (nums1[m1] <= nums2[m2]) {
				int cut = Math.min(m1 - l1, r2 - m2);
				nums1[m1 + 1] = Math.min(nums1[m1 + 1], nums2[m2 + 1]);
				return findMedianSortedArraysEven(nums1, l1 + cut, r1, nums2, l2, r2 - cut);
			} else {
				int cut = Math.min(r1 - m1, m2 - l2);
				nums2[m2 + 1] = Math.min(nums1[m1 + 1], nums2[m2 + 1]);
				return findMedianSortedArraysEven(nums1, l1, r1 - cut, nums2, l2 + cut, r2);
			}
		}
	    /*
	     * 	总共奇数个
	     * 	返回位于中间位置的数
	     */
		double findMedianSortedArraysOdd(int[] nums1, int l1, int r1, int[] nums2, int l2, int r2) {
			int d1 = r1 - l1, d2 = r2 - l2, offset = Math.abs(d2 - d1) >>> 1;
			if (d1 > d2)
				return findMedianSortedArraysOdd(nums2, l2, r2, nums1, l1, r1);
			if (nums1[r1] <= nums2[l2]) {
				return nums2[l2 + offset];
			} else if (nums2[r2] <= nums1[l1]) {
				return nums2[r2 - offset];
			}
			int m1 = (l1 + r1) >>> 1, m2 = (l2 + r2) >>> 1;
			if (r1 == m1) {
				if (nums1[m1] < nums2[m2])
					return nums2[m2];
				else if (nums1[m1] > nums2[m2 + 1])
					return nums2[m2 + 1];
				else
					return nums1[m1];
			}
			if (nums1[m1] <= nums2[m2]) {
				int cut = Math.min(m1 - l1 + 1, r2 - m2);
				return findMedianSortedArraysOdd(nums1, l1 + cut, r1, nums2, l2, r2 - cut);
			} else {
				int cut = Math.min(r1 - m1, m2 - l2 + 1);
				return findMedianSortedArraysOdd(nums1, l1, r1 - cut, nums2, l2 + cut, r2);
			}
		}
	}
	/*
	 * 	第一份代码的最重要缺陷是代码实在是太长了。
	 * 	第二份代码应该会非常短，只要短代码就好
	 * 	6ms
	 * 	14.77%
	 * 	还更快。。。
	 */
	static class Solution2 {
		/*
		 * 	这里k从0开始计数
		 */
		int findKth_zxwtry(int[] nums1, int l1, int r1, int[] nums2, int l2, int r2, int k) {
			int d1 = r1 - l1, d2 = r2 - l2;
			if (d1 > d2)
				return findKth_zxwtry(nums2, l2, r2, nums1, l1, r1, k);
			if (d1 < 0)
				return nums2[l2 + k];
			if (k == 0)
				return Math.min(nums1[l1], nums2[l2]);
			int p1 = Math.min((k + 1) / 2 - 1, d1), p2 = k - p1 - 1;
			if (p1 < 0 || p2 < 0)
				return nums2[l2 + k];
			if (nums1[l1 + p1] < nums2[l2 + p2]) {
				return findKth_zxwtry(nums1, l1 + p1 + 1, r1, nums2, l2, r2, k - p1 - 1);
			} else if (nums1[l1 + p1] > nums2[l2 + p2]){
				return findKth_zxwtry(nums1, l1, r1, nums2, l2 + p2 + 1, r2, k - p2 - 1);
			} else {
				return nums1[l1 + p1];
			}
		}
		public double findMedianSortedArrays(int[] nums1, int[] nums2) {
			if (nums1 == null || nums2 == null) {
				int[] not_null_arr = nums1;
				if (not_null_arr == null)
					not_null_arr = nums2;
				if (not_null_arr == null)
					return 0;
				if (not_null_arr.length == 0)
					return 0;
				if ( (not_null_arr.length &0x1) == 1 )
					return not_null_arr[not_null_arr.length >>> 1];
				else
					return ((double) not_null_arr[not_null_arr.length >>> 1] + not_null_arr[(not_null_arr.length >>> 1) - 1]) / 2;
			}
			if (nums1.length > nums2.length)
				return findMedianSortedArrays(nums2, nums1);
			if (nums1.length == 0)
				return findMedianSortedArrays(null, nums2);
			if ( ( (nums1.length + nums2.length) & 0x1 ) == 1) 
				return findKth_zxwtry(nums1, 0, nums1.length - 1, nums2, 0, nums2.length - 1, (nums1.length + nums2.length) >>> 1 );
			else
				return ((double) findKth_zxwtry(nums1, 0, nums1.length - 1, nums2, 0, nums2.length - 1, (nums1.length + nums2.length) >>> 1 )  + 
						findKth_zxwtry(nums1, 0, nums1.length - 1, nums2, 0, nums2.length - 1, ( (nums1.length + nums2.length) >>> 1 )  - 1)) / 2;
		}
	}
}


C Solution: github

/*
    url: leetcode.com/problems/median-of-two-sorted-arrays/
    46ms 38.77%
*/

#include <stdlib.h>
#include <stdio.h>

int _min(int a, int b) {
    return a < b ? a : b;
}

//binary find  [sorted array of (a1 + a2) k index]
int find_kth_from_two_sorted_array(int* a1, int n1, int* a2, int n2, int k) {
    int cut = 0;
    if (n1 > n2) return find_kth_from_two_sorted_array(a2, n2, a1, n1, k);
    if (n1 == 0) return *(a2 + k);
    if (k == 0) return _min(*a1, *a2);
    cut = _min((k + 1) / 2, n1);
    if (*(a1 + cut - 1) < *(a2 + cut - 1)) {
        return find_kth_from_two_sorted_array(a1 + cut, n1 - cut, a2, n2, k - cut);
    } else {
        return find_kth_from_two_sorted_array(a1, n1, a2 + cut, n2 - cut, k - cut);
    }
}

//assume all inputs are valid
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    if (nums1Size > nums2Size) {
        return findMedianSortedArrays(nums2, nums2Size, nums1, nums1Size);
    }
    if ((nums1Size + nums2Size) % 2 == 0) {
        return (find_kth_from_two_sorted_array(nums1, nums1Size, nums2, nums2Size, (nums1Size + nums2Size) / 2) +
            find_kth_from_two_sorted_array(nums1, nums1Size, nums2, nums2Size, (nums1Size + nums2Size) / 2 - 1)) / 2.0;
    } else {
        return find_kth_from_two_sorted_array(nums1, nums1Size, nums2, nums2Size, (nums1Size + nums2Size) / 2);
    }
}

int main() {
    int nums1[4] = {3, 4};
    int nums2[4] = {1, 2, 5, 6};
    //printf("answer is %d\r\n", find_kth_from_two_sorted_array(nums1, 2, nums2, 4, 5));
    printf("answer is %f\r\n", findMedianSortedArrays(nums1, 2, nums2, 4));
    return 0;
}


Python Solution: github

#coding=utf-8

'''
    url: leetcode.com/problems/median-of-two-sorted-arrays/haracters/
    sorted-array找两个情况太多，采用先找一个的方法
    @author:     zxwtry
    @email:      zxwtry@qq.com
    @date:       2017年3月25日
    @details:    Solution: AC 105ms 73.21%
'''

class Solution(object):
    def findKth(self, nums1, l1, r1, nums2, l2, r2, k):
        if r1-l1 > r2-l2: 
            return self.findKth(nums2, l2, r2, nums1, l1, r1, k)
        if l1 >= r1: 
            return nums2[l2 + k]
        if k == 0: 
            return min(nums1[l1], nums2[l2])
        k_2 = min((k + 1) // 2, r1-l1)
        if nums1[l1 + k_2 - 1] < nums2[l2 + k_2 - 1]:
            return self.findKth(nums1, l1 + k_2, r1, nums2, l2, r2, k - k_2)
        else:
            return self.findKth(nums1, l1, r1, nums2, l2 + k_2, r2, k - k_2)
        
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        l1, l2 = len(nums1), len(nums2)
        if (l1+l2) % 2 == 0: 
            return (self.findKth(nums1, 0, l1, nums2, 0, l2, (l1 + l2) // 2) + 
                    self.findKth(nums1, 0, l1, nums2, 0, l2, (l1 + l2) // 2 - 1)) / 2.0
        else: 
            return self.findKth(nums1, 0, l1, nums2, 0, l2, (l1 + l2) // 2)

if __name__ == "__main__":
    nums1 = [1, 2]
    nums2 = [3, 4]
    s = Solution()
    print(s.findMedianSortedArrays(nums1, nums2))









zxwtry
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
递归和非递归实现归并排序
ruiruihahaha的博客
04-26 393
1、递归实现归并排序 递归排序其实也是利用了完全二叉树的结构形式，所以时间复杂度和logN挂钩的。具体递归版的归并排序呢，看下面的代码： public class MS { public static void main(String[] args) { int[] s = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7
用插入排序和归并排序算法对数组＜3，1，4，1，5，9，6，5＞进行从小到大排序，则分别需要进行______次数组元素之间的比较。...
weixin_30822451的博客
06-08 3354
用插入排序和归并排序算法对数组＜3，1，4，1，5，9，6，5＞进行从小到大排序，则分别需要进行______次数组元素之间的比较。A．12，14B．10，14C．12，16 D．10，16 正确答案是A。答案解析：插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。插入排序最基本的应用就是 平时打扑克牌的时候 一张张拿牌的过程。...
基础的排序C++实现
u011707827的专栏
03-02 414
好久没做算法，先练习一些基础的排序作为练手。 首先是插入排序（Insertion sort）的实现 #include using namespace std; int main() { //插入排序Insertion sort,目标输入6个数字，实现正序插入排序 int n;//数组大小 cout << "输入数组大小" << endl; cin >> n; int *a;
排序篇（6）--归并排序
Runner的博客
03-03 396
经典排序算法--归并排序，递归实现
归并排序
keep_moving_cqu的专栏
08-23 991
#include using namespace std; void sort(int a[],int first,int mid,int last,int temp[]) { int i=first; int j=mid; int count=0; while(1) { if(a[i]<a[j]) { temp[count++]=a[i++]
LeetCode 004 Median of Two Sorted Arrays
Tech in Pieces
11-08 105
Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays. Input: nums1 = [1,3], nums2 = [2] Output: 2.00000 Explanation: merged array = [1,2,3] and median is 2. Requirements: The overall run time comp
Leetcode 004 Median of Two Sorted Arrays
Gongzq5的博客
07-26 181
Leetcode 004 Median of Two Sorted Arrays 题目 My Solution (O(n) not O(logn)) 分析 Leetcode 004 Median of Two Sorted Arrays 写出给定的两个数组中所有数字的中位数 题目 There are two sorted arrays nums1 and nums2 ...
LeetCode4 Median of Two Sorted Arrays
01-09
There are two sorted arrays nums1 and nums2 of size m and n respectively. ...Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)). Java AC版本
leetcode无法登录-MedianOfTwoSortedArrays:双排序数组的中位数
07-01
leetcode 无法登录两个有序数组的中位数 问题 有两个大小分别为 m 和 n 的排序数组 nums1 和 nums2。求两个排序数组的中位数。 整体运行时间复杂度应该是 O(log (m+n))。 您可以假设 nums1 和 nums2 不能都为空。 ...
leetcode4median-leetcode4-median-:leetcode4-中位数-
07-06
在LeetCode上，题目4（Median of Two Sorted Arrays）是一个经典的算法问题，旨在寻找两个已排序数组的中位数。中位数是将一组数值从小到大排列后处于中间位置的数，在奇数个数的情况下是中间的那个数，而在偶数个数...
程序员面试宝典LeetCode刷题手册
05-18
4. Median of Two Sorted Arrays 7. Reverse Integer 9. Palindrome Number 11. Container With Most Water 13. Roman to Integer 15. 3Sum 16. 3Sum Closest 17. Letter Combinations of a Phone Number 18. 4Sum ...
LeetCode 刷题汇总1
08-03
* 两个排序数组的中位数（Median of Two Sorted Arrays）：计算两个排序数组的中位数。 * 整数到罗马（Integer to Roman）：将整数转换为罗马数字。 * 罗马到整数（Roman to Integer）：将罗马数字转换为整数。 4...
leetcode hot100 （面试复习用）
大厂小码农的博客
07-20 489
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]// 继续向左查找} else {// 查找目标值在数组中的结束位置// 继续向右查找} else {
【LeetCode】分隔链表
最新发布
qq_26521261的博客
07-20 226
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 239
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
1. LeetCode-数组和字符串
weixin_43149506的博客
07-18 902
数组和字符串介绍以及相关例题
LeetCode --- 2138. Divide a String Into Groups of Size k 解题报告
杨鑫newlife的专栏
07-16 3247
A string can be partitioned into groups of size using the following procedure:Note that the partition is done so that after removing the character from the last group (if it exists) and concatenating all the groups in order, the resultant string should
Leetcode热题100 Day2
KGthe3的博客
07-19 97
但是即使这样我在写的时候还是花了很多时间，一个是边界条件的处理（尤其是连续有相同值的处理）以及我发现了leetcode的编译器和本地的编译器不一样：本地没有进行越界检查，但是leetcode是开启了的。首先需要对原先的区间进行排序，排序的原则是先按照左端从小到大，左端相同则看右端。这样的话，用两个指针表示当前的已合并区间的左端和右端，不断判断这个右端是否大于下一个区间的左端，如果大于，则合并。窗口的特性是窗口内所有字母的出现次数，因为是异位值，所以只要出现次数相同即可，并不需要考虑出现的顺序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值