update: 4 & 53 & 169 & 215 & 340 & 395

Author: hijiangtao

README.md

@@ -11,6 +11,7 @@ This is the solutions collection of my LeetCode submissions, most of them are pr
 |1|[Two Sum](https://leetcode.com/problems/two-sum/) | [JavaScript](./src/two-sum/res.js)|Easy|
 |2|[Add Two Numbers](https://leetcode.com/problems/add-two-numbers/) | [JavaScript](./src/add-two-numbers/res.js)|Medium|
 |3|[Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/) | [JavaScript](./src/longest-substring-without-repeating-characters/res.js) |Medium|
+|4|[Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays/) | [JavaScript](./src/median-of-two-sorted-arrays/res.js) |Hard|
 |5|[Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring/) | [JavaScript](./src/longest-palindromic-substring/res.js) |Medium|
 |6|[ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion/) | [JavaScript](./src/zigzag-conversion/res.js) |Medium|
 |7|[Reverse Integer](https://leetcode.com/problems/reverse-integer/) | [JavaScript](./src/reverse-integer/res.js)|Easy|
@@ -70,6 +71,7 @@ This is the solutions collection of my LeetCode submissions, most of them are pr
 |162|[Find Peak Element](https://leetcode.com/problems/find-peak-element/) | [JavaScript](./src/find-peak-element/res.js)|Medium|
 |164|[Maximum Gap](https://leetcode.com/problems/maximum-gap/) | [JavaScript](./src/maximum-gap/res.js)|Hard|
 |165|[Compare Version Numbers](https://leetcode.com/problems/compare-version-numbers/) | [JavaScript](./src/compare-version-numbers/res.js)|Medium|
+|169|[Majority Element](https://leetcode.com/problems/majority-element/) | [JavaScript](./src/majority-element/res.js)|Easy|
 |175|[Combine Two Tables](https://leetcode.com/problems/combine-two-tables/)| [SQL](./src/combine-two-tables/res.txt)|Easy|
 |176|[Second Highest Salary](https://leetcode.com/problems/second-highest-salary/)| [SQL](./src/second-highest-salary/res.txt)|Easy|
 |177|[Nth Highest Salary](https://leetcode.com/problems/nth-highest-salary/)| [SQL](./src/nth-highest-salary/res.txt)|Medium|
@@ -86,6 +88,7 @@ This is the solutions collection of my LeetCode submissions, most of them are pr
 |207|[Course Schedule](https://leetcode.com/problems/course-schedule/) | [JavaScript](./src/course-schedule/res.js)|Medium|
 |209|[Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum/) | [JavaScript](./src/minimum-size-subarray-sum/res.js)|Medium|
 |210|[Course Schedule II](https://leetcode.com/problems/course-schedule-ii/) | [JavaScript](./src/course-schedule-ii/res.js)|Medium|
+|215|[Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/) | [JavaScript](./src/kth-largest-element-in-an-array/res.js)|Medium|
 |217|[Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) | [JavaScript](./src/contains-duplicate/res.js)|Easy|
 |219|[Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/) | [JavaScript](./src/contains-duplicate-ii/res.js)|Easy|
 |220|[Contains Duplicate III](https://leetcode.com/problems/contains-duplicate-iii/) | [JavaScript](./src/contains-duplicate-iii/res.js)|Medium|
@@ -108,6 +111,7 @@ This is the solutions collection of my LeetCode submissions, most of them are pr
 |315|[Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/) <sup>*</sup> | [JavaScript](./src/count-of-smaller-numbers-after-self/res.js)|Hard|
 |327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/) | [JavaScript](./src/count-of-range-sum/res.js)|Hard|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/) | [JavaScript](./src/increasing-triplet-subsequence/res.js)|Medium|
+|340|[Longest Substring with At Most K Distinct Characters](https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/) | [JavaScript](./src/longest-substring-with-at-most-k-distinct-characters/res.js)|Hard|
 |342|[Power of Four](https://leetcode.com/problems/power-of-four/) | [JavaScript](./src/power-of-four/res.js)|Easy|
 |344|[Reverse String](https://leetcode.com/problems/reverse-string/) | [JavaScript](./src/reverse-string/res.js)|Easy|
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | [JavaScript](./src/intersection-of-two-arrays/res.js)|Easy|
@@ -116,9 +120,11 @@ This is the solutions collection of my LeetCode submissions, most of them are pr
 |374|[Guess Number Higher or Lower](https://leetcode.com/problems/guess-number-higher-or-lower/) | [JavaScript](./src/guess-number-higher-or-lower/res.py)|Easy|
 |376|[Wiggle Subsequence](https://leetcode.com/problems/wiggle-subsequence/) | [JavaScript](./src/wiggle-subsequence/res.js)|Medium|
 |384|[Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/) | [JavaScript](./src/shuffle-an-array/res.js)|Medium|
+|395|[Longest Substring with At Least K Repeating Characters](https://leetcode.com/problems/longest-substring-with-at-least-k-repeating-characters/) | [JavaScript](./src/longest-substring-with-at-least-k-repeating-characters/res.js)|Medium|
 |404|[Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | [JavaScript](./src/sum-of-left-leaves/res.js)|Easy|
 |413|[Arithmetic Slices](https://leetcode.com/problems/arithmetic-slices/) | [JavaScript](./src/arithmetic-slices/res.js)|Medium|
 |416|[Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum/) | [JavaScript](./src/partition-equal-subset-sum/res.js)|Medium|
+|424|[Longest Repeating Character Replacement](https://leetcode.com/problems/longest-repeating-character-replacement/) | [JavaScript](./src/longest-repeating-character-replacement/res.js)|Medium|
 |434|[Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/) | [JavaScript](./src/number-of-segments-in-a-string/res.js)|Easy|
 |486|[Predict the Winner](https://leetcode.com/problems/predict-the-winner/) | [JavaScript](./src/predict-the-winner/res.js)|Medium|
 |494|[Target Sum](https://leetcode.com/problems/target-sum/) | [JavaScript](./src/target-sum/res.js)|Medium|

src/kth-largest-element-in-an-array/res.js

@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var findKthLargest = function(nums, k) {
+  const len = nums.length;
+  const target = len - k;
+  let left = 0, right = len-1;
+
+  const swap = (a, b) => {
+    const temp = nums[a];
+    nums[a] = nums[b];
+    nums[b] = temp;
+  }
+
+  const partition = (start, end) => {
+    const pivot = nums[left];
+    let lindex = left;
+
+    for (let i = left+1; i <= end; i++) {
+      const element = nums[i];
+      if (element < pivot) {
+        swap(++lindex, i);
+      }
+    }
+
+    swap(lindex, left);
+    return lindex;
+  }
+
+  while(true) {
+    let index = partition(left, right);
+    if (index === target) {
+      return nums[index];
+    } else if (index < target) {
+      left = index+1;
+    } else {
+      right = index-1;
+    }
+  }
+};

src/longest-repeating-character-replacement/res.js

@@ -0,0 +1,43 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var characterReplacement = function(s, k) {
+  const len = s.length;
+  let max = 0;
+  let strdict = {};
+  let left = 0, right = 0;
+
+  for ( ; right < len; right++) {
+    const e = s[right];
+    
+    if(strdict[e] !== undefined) {
+      strdict[e] += 1;
+    } else {
+      strdict[e] = 1;
+    }
+
+    let curMaxStr = '';
+    Object.keys(strdict).map(ele => {
+      if (strdict[ele] > (strdict[curMaxStr] || 0)) {
+        curMaxStr = ele;
+      }
+    });
+
+    while(right-left+1-strdict[curMaxStr] > k) {
+      strdict[s[left]] -= 1;
+      left += 1;
+
+      Object.keys(strdict).map(ele => {
+        if (strdict[ele] > strdict[curMaxStr]) {
+          curMaxStr = ele;
+        }
+      });
+    }
+
+    max = Math.max(max, right-left+1);
+  }
+
+  return max;
+};

src/longest-substring-with-at-least-k-repeating-characters/res.js

@@ -0,0 +1,51 @@
+/**
+ * 超时 - 分治方法
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var longestSubstring = function(s, k) {
+  const len = s.length;
+  if (len<k) return 0;
+
+  const count = (start, end) => {
+    if (end-start+1 < k) return 0;
+
+    const strdict = {};
+    let numOfLessThanK = 0;
+    for (let i = start; i <= end; i++) {
+      const e = s[i];
+      if (strdict[e] === undefined) {
+        strdict[e] = 1;
+        numOfLessThanK += 1;
+      } else {
+        strdict[e] += 1;
+        if (strdict[e] === k) {
+          numOfLessThanK -= 1;
+        }
+      };
+    }
+
+    if (!numOfLessThanK) return end-start+1;
+    while(end-start+1 < k && strdict[start] < k) {
+      start++;
+    }
+    while(end-start+1 < k && strdict[end] < k) {
+      end--;
+    }
+    if (end-start+1 < k) return 0;
+
+    for (let i = start; i <= end; i++) {
+      const e = s[i];
+      if (strdict[e] < k) {
+        let next = i+1;
+        while(strdict[next] < k && next < end) next++;
+        return Math.max(count(start, i-1),count(next, end));
+      }
+    }
+
+    return end-start+1;
+  }
+
+  return count(0, len-1);
+};

src/longest-substring-with-at-most-k-distinct-characters/res.js

@@ -0,0 +1,29 @@
+const lengthOfLongestSubstringTwoDistinct = (s, k) => {
+  const len = s.length;
+  let start = 0, max = 0, strdict = {};
+
+  for (let i = 0; i < len; i++) {
+    const e = s[i];
+    
+    if (strdict[e] !== undefined) {
+      strdict[e].push(i);
+    } else {
+      strdict[e] = [i];
+    }
+
+    while(Object.keys(strdict).length > k) {
+      let delElement = strdict[e[start]];
+
+      if (delElement.length === 1) {
+        delete strdict[e[start]];
+      } else {
+        strdict[e[start]].shift();
+      }
+      start += 1;
+    }
+
+    max = Math.max(max, i-start+1);
+  }
+
+  return max;
+}

src/longest-substring-without-repeating-characters/res.js

@@ -67,4 +67,29 @@ let lengthOfLongestSubstring = function(s) {
    }
 
    return maxLen;
-};
+};
+
+/**
+ * 滑动窗口
+ * @param {*} s 
+ */
+let lengthOfLongestSubstring_2 = function(s) {
+    let strlen = s.length;
+    let start = 0;
+    let strdict = {};
+    let max = 0;
+
+    for (let i = 0; i < strlen; i++) {
+        const e = s[i];
+        
+        if (strdict[e] !== undefined && strdict[e] >= start) {
+            start = strdict[e] + 1;
+        } else {
+            const curLen = i-start+1;
+            max = Math.max(curLen, max);
+        }
+        
+        strdict[e] = i;
+    }
+    return max;
+}

src/majority-element/res.js

@@ -0,0 +1,35 @@
+/**
+ * 求众数
+ * @param {number[]} nums
+ * @return {number}
+ */
+var majorityElement = function(nums) {
+  const len  = nums.length;
+  if (len === 1) return nums[0];
+
+  const getCount = (m, left, right) => {
+    let count = 0;
+    for (let i = left; i <= right; i++) {
+      if (nums[i] === m) count += 1;
+    }
+
+    return count;
+  }
+
+  const getMajority = (left, right) => {
+    if (left === right) return nums[left];
+    const mid = (left + right) >> 1;
+
+    const leftMajority = getMajority(left, mid);
+    const rightMajority = getMajority(mid+1, right);
+
+    if (leftMajority === rightMajority) return leftMajority;
+
+    const lmCount = getCount(leftMajority, left, right);
+    const rmCount = getCount(rightMajority, left, right);
+
+    return lmCount > rmCount ? leftMajority : rightMajority;
+  }
+
+  return getMajority(0, len-1);
+};

src/maximum-subarray/res.js

@@ -19,4 +19,4 @@ var maxSubArray = function(nums) {
   }
 
   return ans;
-};
+};

src/maximum-subarray/res.py

@@ -0,0 +1,33 @@
+
+# 论坛解法 - 分治法
+# https://leetcode-cn.com/problems/maximum-subarray/solution/bao-li-qiu-jie-by-pandawakaka/
+
+class Solution:
+    def maxSubArray(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        n = len(nums)
+        #递归终止条件
+        if n == 1:
+            return nums[0]
+        else:
+            #递归计算左半边最大子序和
+            max_left = self.maxSubArray(nums[0:len(nums) // 2])
+            #递归计算右半边最大子序和
+            max_right = self.maxSubArray(nums[len(nums) // 2:len(nums)])
+        
+        #计算中间的最大子序和，从右到左计算左边的最大子序和，从左到右计算右边的最大子序和，再相加
+        max_l = nums[len(nums) // 2 - 1]
+        tmp = 0
+        for i in range(len(nums) // 2 - 1, -1, -1):
+            tmp += nums[i]
+            max_l = max(tmp, max_l)
+        max_r = nums[len(nums) // 2]
+        tmp = 0
+        for i in range(len(nums) // 2, len(nums)):
+            tmp += nums[i]
+            max_r = max(tmp, max_r)
+        #返回三个中的最大值
+        return max(max_right,max_left,max_l+max_r)

src/median-of-two-sorted-arrays/res.js

@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var findMedianSortedArrays = function(nums1, nums2) {
+  const len1 = nums1.length;
+  const len2 = nums2.length;
+
+  let left = (len1 + len2 + 1) >> 1;
+  let right = (len1 + len2 + 2) >> 1;
+
+  const getMedian = (n1, s1, e1, n2, s2, e2, k) => {
+    const l1 = e1-s1+1;
+    const l2 = e2-s2+1;
+
+    if (l1 > l2) return getMedian(n2, s2, e2, n1, s1, e1, k);
+    if (l1 === 0) return n2[s2+k-1];
+
+    if (k == 1) return Math.min(n1[s1], n2[s2]);
+
+    let i = s1 + Math.min(l1, k >> 1) - 1;
+    let j = s2 + Math.min(l2, k >> 1) - 1;
+
+    if (n1[i] > n2[j]) {
+      return getMedian(n1, s1, e1, n2, j+1, e2, k - (j-s2+1));
+    } else {
+      return getMedian(n1, i+1, e1, n2, s2, e2, k - (i-s1+1));      
+    }
+  }
+
+  return (getMedian(nums1, 0, len1-1, nums2, 0, len2-1, left) + getMedian(nums1, 0, len1-1, nums2, 0, len2-1, right)) / 2;
+};