Update 4.median-of-two-sorted-array.md

Author: azl397985856

problems/4.median-of-two-sorted-array.md

@@ -1,33 +1,37 @@
-## 题目地址
+## 题目地址(4. 寻找两个正序数组的中位数)
 https://leetcode.com/problems/median-of-two-sorted-arrays/
 
 ## 题目描述
 ```
-There are two sorted arrays nums1 and nums2 of size m and n respectively.
+给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。
 
-Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
+请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
 
-You may assume nums1 and nums2 cannot be both empty.
+你可以假设 nums1 和 nums2 不会同时为空。
 
-Example 1:
+ 
+
+示例 1:
 
 nums1 = [1, 3]
 nums2 = [2]
 
-The median is 2.0
-Example 2:
+则中位数是 2.0
+示例 2:
 
 nums1 = [1, 2]
 nums2 = [3, 4]
 
-The median is (2 + 3)/2 = 2.5
+则中位数是 (2 + 3)/2 = 2.5
+
 ```
 
 ## 思路
 首先了解一下Median的概念，一个数组中median就是把数组分成左右等分的中位数。
 
 如下图：
-![median](../assets/problems/4.median-of-two-sorted-array-1.jpg)
+![image.png](https://pic.leetcode-cn.com/100b34b378d0667969e7a4ca537c74e5103ce302731796740b3fa62b8bc55629-image.png)
+
 
 这道题，很容易想到暴力解法，时间复杂度和空间复杂度都是`O(m+n)`, 不符合题中给出`O(log(m+n))`时间复杂度的要求。
 我们可以从简单的解法入手，试了一下，暴力解法也是可以被Leetcode Accept的. 分析中会给出两种解法，暴力求解和二分解法。
@@ -44,7 +48,8 @@ The median is (2 + 3)/2 = 2.5
 5. 如果`i`移动到`A`数组最后，那么直接把剩下的所有`B`依次放入新的数组中.
 
 Merge的过程如下图。
-![merge two sorted array](../assets/problems/4.median-of-two-sorted-array-2.jpg)
+![image.png](https://pic.leetcode-cn.com/966c9a0fea7a5f433b82d660f82c5d8184a2ac73b8362d7be435aa0f63377a4c-image.png)
+
 
 
 *时间复杂度： `O(m+n) - m is length of A, n is length of B`*
@@ -60,13 +65,14 @@ Merge的过程如下图。
 对数组A的做partition的位置是区间`[0,m]`
 
 如图：
-![partition A,B](../assets/problems/4.median-of-two-sorted-array-3.png)
+![image.png](https://pic.leetcode-cn.com/816717da264c9e6970bfe0d696d9076febfe04b819f80a224cf2c73845d0f161-image.png)
 
 下图给出几种不同情况的例子（注意但左边或者右边没有元素的时候，左边用`INF_MIN`，右边用`INF_MAX`表示左右的元素：
-![median examples](../assets/problems/4.median-of-two-sorted-array-5.png)
+![image.png](https://pic.leetcode-cn.com/fe03bdcf4db4d74a0bebaa2907df3038c080e5915932fd581d06d4eb930b3035-image.png)
 
 下图给出具体做的partition 解题的例子步骤，
-![median partition example](../assets/problems/4.median-of-two-sorted-array-4.png)
+![image.png](https://pic.leetcode-cn.com/1c2093328c4edf06e416d0f43a94ed42b5a46ecc9f7ed72004b40b9fb47e12a4-image.png)
+
 
 *时间复杂度： `O(log(min(m, n)) - m is length of A, n is length of B`*
 
@@ -88,9 +94,17 @@ median = max(maxLeftA, maxLeftB)
 median = (max(maxLeftA, maxLeftB) + min(minRightA, minRightB)) / 2
 ```
 
-## 代码（Java code）
+## 代码
+
+
+代码支持： Java，JS：
+
+
+Java Code：
+
 *解法一 - 暴力解法（Brute force）*
-```java
+
+```java []
 class MedianTwoSortedArrayBruteForce {
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
       int[] newArr = mergeTwoSortedArray(nums1, nums2);
@@ -127,54 +141,7 @@ class MedianTwoSortedArrayBruteForce {
     }
 }
 ```
-*解法二 - 二分查找（Binary Search)*
-```java
-class MedianSortedTwoArrayBinarySearch {
-  public static double findMedianSortedArraysBinarySearch(int[] nums1, int[] nums2) {
-     // do binary search for shorter length array, make sure time complexity log(min(m,n)).
-     if (nums1.length > nums2.length) {
-        return findMedianSortedArraysBinarySearch(nums2, nums1);
-      }
-      int m = nums1.length;
-      int n = nums2.length;
-      int lo = 0;
-      int hi = m;
-      while (lo <= hi) {
-        // partition A position i
-        int i = lo + (hi - lo) / 2;
-        // partition B position j
-        int j = (m + n + 1) / 2 - i;
-
-        int maxLeftA = i == 0 ? Integer.MIN_VALUE : nums1[i - 1];
-        int minRightA = i == m ? Integer.MAX_VALUE : nums1[i];
-
-        int maxLeftB = j == 0 ? Integer.MIN_VALUE : nums2[j - 1];
-        int minRightB = j == n ? Integer.MAX_VALUE : nums2[j];
-
-        if (maxLeftA <= minRightB && maxLeftB <= minRightA) {
-          // total length is even
-          if ((m + n) % 2 == 0) {
-            return (double) (Math.max(maxLeftA, maxLeftB) + Math.min(minRightA, minRightB)) / 2;
-          } else {
-            // total length is odd
-            return (double) Math.max(maxLeftA, maxLeftB);
-          }
-        } else if (maxLeftA > minRightB) {
-          // binary search left half
-          hi = i - 1;
-        } else {
-          // binary search right half
-          lo = i + 1;
-        }
-      }
-      return 0.0;
-    }
-}
-```
-
-## 代码 (javascript code)
-*解法一 - 暴力解法（Brute force）*
-```js
+```javascript []
 /**
  * @param {number[]} nums1
  * @param {number[]} nums2
@@ -206,8 +173,12 @@ var findMedianSortedArrays = function(nums1, nums2) {
 };
 ```
 
+***复杂度分析***
+- 时间复杂度：$O(max(m, n))$
+- 空间复杂度：$O(m + n)$
+
 *解法二 - 二分查找（Binary Search)*
-```js
+```js []
 /**
  * 二分解法
  * @param {number[]} nums1
@@ -243,4 +214,57 @@ var findMedianSortedArrays = function(nums1, nums2) {
     }
   }
 };
-```
+```
+```java []
+class MedianSortedTwoArrayBinarySearch {
+  public static double findMedianSortedArraysBinarySearch(int[] nums1, int[] nums2) {
+     // do binary search for shorter length array, make sure time complexity log(min(m,n)).
+     if (nums1.length > nums2.length) {
+        return findMedianSortedArraysBinarySearch(nums2, nums1);
+      }
+      int m = nums1.length;
+      int n = nums2.length;
+      int lo = 0;
+      int hi = m;
+      while (lo <= hi) {
+        // partition A position i
+        int i = lo + (hi - lo) / 2;
+        // partition B position j
+        int j = (m + n + 1) / 2 - i;
+
+        int maxLeftA = i == 0 ? Integer.MIN_VALUE : nums1[i - 1];
+        int minRightA = i == m ? Integer.MAX_VALUE : nums1[i];
+
+        int maxLeftB = j == 0 ? Integer.MIN_VALUE : nums2[j - 1];
+        int minRightB = j == n ? Integer.MAX_VALUE : nums2[j];
+
+        if (maxLeftA <= minRightB && maxLeftB <= minRightA) {
+          // total length is even
+          if ((m + n) % 2 == 0) {
+            return (double) (Math.max(maxLeftA, maxLeftB) + Math.min(minRightA, minRightB)) / 2;
+          } else {
+            // total length is odd
+            return (double) Math.max(maxLeftA, maxLeftB);
+          }
+        } else if (maxLeftA > minRightB) {
+          // binary search left half
+          hi = i - 1;
+        } else {
+          // binary search right half
+          lo = i + 1;
+        }
+      }
+      return 0.0;
+    }
+}
+```
+***复杂度分析***
+- 时间复杂度：$O(log(min(m, n)))$
+- 空间复杂度：$O(log(min(m, n)))$
+
+
+更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode  。 目前已经30K star啦。
+
+大家也可以关注我的公众号《脑洞前端》获取更多更新鲜的LeetCode题解
+
+![](https://pic.leetcode-cn.com/89ef69abbf02a2957838499a96ce3fbb26830aae52e3ab90392e328c2670cddc-file_1581478989502)