feat(js-solution): add js-solution for problem 4 (azl397985856#337)

Author: feikerwu

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

@@ -35,12 +35,12 @@ The median is (2 + 3)/2 = 2.5
 #### 解法一 - 暴力 （Brute Force）
 暴力解主要是要merge两个排序的数组`（A，B）`成一个排序的数组。
 
-用两个`pointer（i，j）`，`i` 从数组`A`起始位置开始，即`i=0`开始，`j` 从数组`B`起始位置， 即`j=0`开始. 
-一一比较 `A[i] 和 B[j]`, 
+用两个`pointer（i，j）`，`i` 从数组`A`起始位置开始，即`i=0`开始，`j` 从数组`B`起始位置， 即`j=0`开始.
+一一比较 `A[i] 和 B[j]`,
 1. 如果`A[i] <= B[j]`, 则把`A[i]` 放入新的数组中，i往后移一位，即 `i+1`.
 2. 如果`A[i] > B[j]`, 则把`B[j]` 放入新的数组中，j往后移一位，即 `j+1`.
 3. 重复步骤#1 和 #2，直到`i`移到`A`最后，或者`j`移到`B`最后。
-4. 如果`j`移动到`B`数组最后，那么直接把剩下的所有`A`依次放入新的数组中. 
+4. 如果`j`移动到`B`数组最后，那么直接把剩下的所有`A`依次放入新的数组中.
 5. 如果`i`移动到`A`数组最后，那么直接把剩下的所有`B`依次放入新的数组中.
 
 Merge的过程如下图。
@@ -76,7 +76,7 @@ Merge的过程如下图。
 1. 暴力求解，在线性时间内merge两个排好序的数组成一个数组。
 2. 二分查找，关键点在于
   - 要partition两个排好序的数组成左右两等份，partition需要满足`len(Aleft)+len(Bleft)=(m+n+1)/2 - m是数组A的长度， n是数组B的长度`
- 
+
   - 并且partition后 A左边最大(`maxLeftA`), A右边最小（`minRightA`), B左边最大（`maxLeftB`), B右边最小（`minRightB`) 满足
 `(maxLeftA <= minRightB && maxLeftB <= minRightA)`
 
@@ -127,7 +127,7 @@ class MedianTwoSortedArrayBruteForce {
     }
 }
 ```
-*解法二 - 二分查找（Binary Search*
+*解法二 - 二分查找（Binary Search)*
 ```java
 class MedianSortedTwoArrayBinarySearch {
   public static double findMedianSortedArraysBinarySearch(int[] nums1, int[] nums2) {
@@ -144,13 +144,13 @@ class MedianSortedTwoArrayBinarySearch {
         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) {
@@ -171,3 +171,76 @@ class MedianSortedTwoArrayBinarySearch {
     }
 }
 ```
+
+## 代码 (javascript code)
+*解法一 - 暴力解法（Brute force）*
+```js
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var findMedianSortedArrays = function(nums1, nums2) {
+  // 归并排序
+  const merged = []
+  let i = 0
+  let j = 0
+  while(i < nums1.length && j < nums2.length) {
+    if (nums1[i] < nums2[j]) {
+      merged.push(nums1[i++])
+    } else {
+      merged.push(nums2[j++])
+    }
+  }
+  while(i < nums1.length) {
+    merged.push(nums1[i++])
+  }
+  while(j < nums2.length) {
+    merged.push(nums2[j++])
+  }
+
+  const { length } = merged
+  return length % 2 === 1
+    ? merged[Math.floor(length / 2)]
+    : (merged[length / 2] + merged[length / 2 - 1]) / 2
+};
+```
+
+*解法二 - 二分查找（Binary Search)*
+```js
+/**
+ * 二分解法
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var findMedianSortedArrays = function(nums1, nums2) {
+  // make sure to do binary search for shorten array
+  if (nums1.length > nums2.length) {
+    [nums1, nums2] = [nums2, nums1]
+  }
+  const m = nums1.length
+  const n = nums2.length
+  let low = 0
+  let high = m
+  while(low <= high) {
+    const i = low + Math.floor((high - low) / 2)
+    const j = Math.floor((m + n + 1) / 2) - i
+
+    const maxLeftA = i === 0 ? -Infinity : nums1[i-1]
+    const minRightA = i === m ? Infinity : nums1[i]
+    const maxLeftB = j === 0 ? -Infinity : nums2[j-1]
+    const minRightB = j === n ? Infinity : nums2[j]
+
+    if (maxLeftA <= minRightB && minRightA >= maxLeftB) {
+      return (m + n) % 2 === 1
+        ? Math.max(maxLeftA, maxLeftB)
+        : (Math.max(maxLeftA, maxLeftB) + Math.min(minRightA, minRightB)) / 2
+    } else if (maxLeftA > minRightB) {
+      high = i - 1
+    } else {
+      low = low + 1
+    }
+  }
+};
+```