diff --git a/Array/KthLargestElementInAnArray.js b/Array/KthLargestElementInAnArray.js
new file mode 100644
index 0000000..fa679dd
--- /dev/null
+++ b/Array/KthLargestElementInAnArray.js
@@ -0,0 +1,95 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+
+// 写了个快排和归并。
+ function sort(arr) {
+    // 快排
+    if (arr.length === 0) {
+        return arr
+    }
+
+    // 选种
+    let bean = Math.floor((arr.length-1) / 2)
+    let base = arr[bean]
+    let bigger = []
+    let smaller = []
+
+    for (let [index, item] of arr.entries()) {
+        if (index === bean) {
+            continue
+        }
+
+        if (item >= base) {
+            bigger.push(item)
+        } else {
+            smaller.push(item)
+        }
+    }
+
+    return [...sort(smaller), base, ...sort(bigger)]
+
+}
+
+// 归并
+function split(arr) {
+    let bean = Math.floor((arr.length-1) / 2)
+    let left = arr.slice(0, bean)
+    let right = arr.slice(bean)
+
+    return [left, right]
+}
+
+function merge(arr, arr2) {
+    let result = []
+
+    let index1 = 0
+    let index2 = 0
+
+    while (index1 <= arr.length - 1 && index2 <= arr2.length - 1) {
+        if (arr[index1] < arr2[index2]) {
+            result.push(arr[index1])
+            index1 += 1
+        } else if (arr[index1] > arr2[index2]) {
+            result.push(arr2[index2])
+            index2 += 1
+        } else {
+            result.push(arr[index1], arr2[index2])
+            index1 += 1
+            index2 += 1
+        }
+    }
+    // 如果第一个arr
+    if (index1 <= arr.length - 1) {
+        result.push(...arr.slice(index1))
+    }
+
+    if (index2 <= arr2.length - 1) {
+        result.push(...arr2.slice(index2))
+    }
+
+    return result
+}
+
+function sort2(arr) {
+    if (arr.length <= 8) {
+        return sort(arr)
+    }
+    let sp = split(arr)
+    // return sp.reduce((a,b) => merge(a,b))
+    return merge(sort2(sp[0]), sort2(sp[1]))
+}
+ 
+
+
+var findKthLargest = function(nums, k) {
+    // nums = nums.sort((a,b) => b-a)
+    // nums = sort(nums)
+    // nums = split(nums)
+    // nums = merge(nums[0], nums[1])
+    nums = sort2(nums)
+    // console.log(nums)
+    return nums[nums.length-k]
+};
\ No newline at end of file
diff --git a/Array/LinkedListCycle.js b/Array/LinkedListCycle.js
new file mode 100644
index 0000000..fdbea30
--- /dev/null
+++ b/Array/LinkedListCycle.js
@@ -0,0 +1,42 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} head
+ * @return {boolean}
+ */
+
+// 两个指针，一个一次走一步，一个一次走两步，如果有环会在某处相遇。
+ var hasCycle = function(head) {
+    if (!head) {
+        return false
+    }
+    let oneIndex = head
+    let twoIndex = head.next
+
+    if (!twoIndex) {
+        return false
+    }
+
+    while (oneIndex && twoIndex) {
+        if (oneIndex === twoIndex) {
+            return true
+        }
+
+        oneIndex = oneIndex.next
+        twoIndex = twoIndex.next
+
+        if (!twoIndex || !twoIndex.next) {
+            return false
+        }
+
+        twoIndex = twoIndex.next
+    }
+
+    return false
+};
\ No newline at end of file
diff --git a/Array/ReverseLinkedList.js b/Array/ReverseLinkedList.js
new file mode 100644
index 0000000..b12e048
--- /dev/null
+++ b/Array/ReverseLinkedList.js
@@ -0,0 +1,59 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+
+// 翻转链表的思路
+// 把head取出来，把head.next取出来，head.next.next也取出来。
+// head.next = head
+// 新的(head.next和head)与head.next.next进行新一轮交换。
+// 直至空。
+// PS，链表操作好麻烦。
+ var reverseList = function(head) {
+
+    let newHead = null
+
+    // 先不判断进行一次交换
+    let nHead = head
+    if (!nHead) {
+        return null
+    }
+    let next = nHead.next
+    if (!next) {
+        return nHead
+    }
+    let lNext = next.next
+
+    next.next = nHead
+    nHead.next = null
+
+    newHead = next
+
+    while (nHead && next && next.next) {
+        nHead = lNext
+        if (!nHead) {
+            return newHead
+        }
+
+        next = nHead.next
+
+        if (!next) {
+            nHead.next = newHead
+            return nHead
+        }
+        lNext = next.next
+
+        next.next = nHead
+        nHead.next = newHead
+
+        newHead = next
+
+    }
+};
\ No newline at end of file
diff --git a/Array/ReverseNodesInk-Group.js b/Array/ReverseNodesInk-Group.js
new file mode 100644
index 0000000..67ae198
--- /dev/null
+++ b/Array/ReverseNodesInk-Group.js
@@ -0,0 +1,99 @@
+// 这个有图，直接看链接吧。
+// https://leetcode-cn.com/problems/reverse-nodes-in-k-group/
+// hard
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+
+// 思路就是获取k个节点，然后翻转。
+// 循环这个操作。
+// 思路不难，个人感觉难点在于ListNode是在不好操作。
+var reverseKGroup = function(head, k) {
+    function getKNodes(head) {
+        let nodes = []
+        let newHead = head
+        
+        // 
+        while (nodes.length < k && newHead) {
+            nodes.push(newHead)
+            newHead = newHead.next
+        }
+
+        return nodes
+    }
+
+    function reverse(nodes) {
+        // 将nodes里的ListNode关系翻转
+        if (!nodes.length) {
+            return null
+        }
+
+        if (nodes.length === 1) {
+            return [nodes[0],null,null]
+        }
+
+        // 新开始的节点应为最后一个节点的下一个
+        let newStartNode = nodes[nodes.length - 1].next
+        // 最后一个节点是翻转前的第一个节点
+        let lastNode = nodes[0]
+
+        let rNodes = nodes.reverse()
+        // 翻转后的头节点是翻转后的最后一个节点。
+        let first = rNodes[0]
+        let indexF = first
+        for (let i of rNodes.slice(1)) {
+            i.next = null
+            indexF.next = i
+            indexF = i
+        }
+        // 返回新的头
+        // 和下次迭代应该开始新头，为原nodes[-1]的next
+        return [first, newStartNode, lastNode]
+
+    }
+
+    let first = getKNodes(head)
+
+    if (!first.length) {
+        return null
+    }
+
+    if (first.length < k) {
+        return head
+    }
+
+    let [newHead, newStartNode, lastNode] = reverse(first)
+    let indexNewHead = lastNode
+    
+    // 循环翻转
+    // newHead为新的head，返回用，newStartNode是下一次取K个node开始的节点。
+    // lastNode为当前节点的最后一个节点，用来将新的节点的head接到最后一个节点上。
+    while (1) {
+        if (!newStartNode) {
+            return newHead
+        }
+        let kNodes = getKNodes(newStartNode)
+        if (kNodes.length < k) {
+            if (indexNewHead) {
+                indexNewHead.next = kNodes[0]
+            }
+            return newHead
+        }
+        
+        let [n, ns, l] = reverse(kNodes)
+        indexNewHead.next = n
+        newStartNode = ns
+        lastNode = l
+        indexNewHead = l
+    }
+};
\ No newline at end of file
diff --git a/Array/twoSum.js b/Array/twoSum.js
new file mode 100644
index 0000000..e817690
--- /dev/null
+++ b/Array/twoSum.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+// 简单的O(1)查找。
+ var twoSum = function(nums, target) {
+    let dicts = {}
+
+    for (let [index, data] of nums.entries()) {
+        dicts[data] ? dicts[data].push(index) : (dicts[data] = [index])
+    }
+
+
+    for (let i of nums) {
+        if (dicts[target - i]) {
+            if (target-i === i) {
+                if (dicts[i].length === 2) {
+                    return [dicts[i][0], dicts[i][1]]
+                } else {
+                    continue
+                }
+
+            }
+
+            return [dicts[i][0], dicts[target-i][0]]
+        }
+    }
+};
\ No newline at end of file
diff --git a/DP/ClimbingStairs.js b/DP/ClimbingStairs.js
new file mode 100644
index 0000000..1481ef0
--- /dev/null
+++ b/DP/ClimbingStairs.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+ var climbStairs = function(n) {
+    let dp = [
+        1,
+        2
+    ]
+    
+    if (n <= 2) {
+        return dp[n-1]
+    }
+
+    for (let i=2;i<n;i++) {
+        dp.push(dp[i-2]+dp[i-1])
+    }
+    return dp[n-1]
+};
\ No newline at end of file
diff --git a/DP/CombinationSum.js b/DP/CombinationSum.js
new file mode 100644
index 0000000..039312d
--- /dev/null
+++ b/DP/CombinationSum.js
@@ -0,0 +1,106 @@
+// 给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。
+
+// candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。 
+
+// 对于给定的输入，保证和为 target 的唯一组合数少于 150 个。
+
+//  
+
+// 示例 1：
+
+// 输入: candidates = [2,3,6,7], target = 7
+// 输出: [[7],[2,2,3]]
+// 示例 2：
+
+// 输入: candidates = [2,3,5], target = 8
+// 输出: [[2,2,2,2],[2,3,3],[3,5]]
+// 示例 3：
+
+// 输入: candidates = [2], target = 1
+// 输出: []
+// 示例 4：
+
+// 输入: candidates = [1], target = 1
+// 输出: [[1]]
+// 示例 5：
+
+// 输入: candidates = [1], target = 2
+// 输出: [[1,1]]
+//  
+
+// 提示：
+
+// 1 <= candidates.length <= 30
+// 1 <= candidates[i] <= 200
+// candidate 中的每个元素都是独一无二的。
+// 1 <= target <= 500
+
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+ var combinationSum = function(candidates, target) {
+    // 思路就是dp
+    // 比如target 2 的解是子问题1的解+子问题1的解，和2自己
+    // target 3 的解可以是子问题1的解+子问题1的解+子问题1的解 / 子问题1的解+子问题2的解和3自己
+    // target 4 的解就是3的解+1+自己。
+    // 变一下这个思路，7的解应该是自己(如果有) + 6 - 1中的组合。
+    // 还可继续优化。
+
+    candidates = candidates.sort((a, b) => {
+        return a - b
+    })
+
+    let _find = {}
+    
+    candidates.map((item) => {
+        _find[item] = 1
+    })
+
+    let dp = [
+    ]
+
+    if (candidates[0] === 1) {
+        dp.push({
+            num: 1,
+            sub: [[1]]
+        })
+    } else {
+        dp.push({
+            num: 1,
+            sub: []
+        })
+    }
+
+    for (let i=2; i <= target; i++) {
+        let sub = []
+        let old = {}
+        for (let j = i-1; j > 0; j--) {
+            if (dp[j-1].sub.lenght !== 0 && _find[i-j]) {
+                for (let c of dp[j-1].sub) {
+                    let temp = [...c, i-j].sort((a, b) => {
+                        return a - b
+                    })
+                    if (!old[temp.join('')]) {
+                        sub.push(temp)
+                        old[temp.join('')] = 1
+                        continue
+                    }
+
+                }
+            }
+        }
+
+        if (_find[i]) {
+            sub.push([i])
+        }
+
+        dp.push({
+            num: i,
+            sub: sub
+        })
+    }
+
+    return dp[dp.length - 1].sub
+};
\ No newline at end of file
diff --git a/DP/MinCostClimbingStairs.js b/DP/MinCostClimbingStairs.js
new file mode 100644
index 0000000..c804266
--- /dev/null
+++ b/DP/MinCostClimbingStairs.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number[]} cost
+ * @return {number}
+ * 
+ * 
+ * 
+ * 数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。
+
+每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。
+
+请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。
+
+ 
+
+示例 1：
+
+输入：cost = [10, 15, 20]
+输出：15
+解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。
+ 示例 2：
+
+输入：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
+输出：6
+解释：最低花费方式是从 cost[0] 开始，逐个经过那些 1 ，跳过 cost[3] ，一共花费 6 。
+ 
+
+提示：
+
+cost 的长度范围是 [2, 1000]。
+cost[i] 将会是一个整型数据，范围为 [0, 999] 。
+
+ */
+ var minCostClimbingStairs = function(cost) {
+    let dp = [
+        cost[0],
+        cost[1]
+    ]
+
+    if (cost.length === 2) {
+        return cost[0] < cost[1] ? cost[0] : cost[1]
+    }
+
+    for (let i=2;i<cost.length;i++) {
+        dp.push(Math.min(dp[i-1]+cost[i], dp[i-2]+cost[i]))
+    }
+
+    return Math.min(dp[dp.length-1], dp[dp.length-2])
+};
\ No newline at end of file
diff --git a/Heap/MergeKSortedLists.js b/Heap/MergeKSortedLists.js
new file mode 100644
index 0000000..4490074
--- /dev/null
+++ b/Heap/MergeKSortedLists.js
@@ -0,0 +1,49 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+
+
+ var mergeKLists = function(lists) {
+    // 这个思路是打散之后又重新生成整个ListNode。
+    // 参考价值不大。
+    if (!lists.length) {
+        return null
+    }
+
+    let newLists = []
+
+    for (let i of lists) {
+        let l = []
+        while (i && i.next) {
+            l.push(i.val)
+            i = i.next
+        }
+        
+        i && l.push(i.val)
+        newLists.push(l)
+    }
+
+
+    let x = newLists.flat().sort((a,b) => a-b)
+    if (!x.length) {
+        return null
+    }
+    let resultNode = new ListNode(x[0])
+    let indexNode = resultNode
+    x.shift()
+    while (x.length) {
+        indexNode.next = new ListNode(x[0])
+        x.shift()
+        indexNode = indexNode.next
+    }
+
+    return resultNode
+};
\ No newline at end of file
diff --git a/README.md b/README.md
index 4ca8fc0..99315b2 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-<h3 align="center">算法知识储备 Leetcode with Python</h3>
+<h3 align="center">算法知识储备 Leetcode with Python <sub>and Js<sub></h3>
 <div align="center">
     <img src="0_icons/book.png">
 </div>
@@ -8,206 +8,215 @@
 </div>
 
 ## [数组(及其相关结构)](Array/)
-* - [可容纳最多水的一组容器.py](Array/ContainerWithMostWater.py)
-* - [糖果公平交换.py](Array/FairCandySwap.py)
-* - [已排序的数组中找到第一和最后一个元素.py](Array/FindFirstAndLastPositionOfElementInSortedArray.py)
-* - [旋转过的排序数组中找到最小的元素.py](Array/FindMinimumInRotatedSortedArray.py)
-* - [旋转过的排序数组中找到最小的元素II.py](Array/FindMinimumInRotatedSortedArrayII.py)
-* - [足球粉儿~.py](Array/FootballFans.py)
-* - [水果分到篮子里.py](Array/FruitIntoBaskets.py)
-* - [三连递增的子序列.py](Array/IncreasingTripletSubsequence.py)
-* - [插入间隔.py](Array/InsertInterval.py)
-* - [能组合成的最大的数.py](Array/LargestNumber.py)
-* - [最长的连续子序列.py](Array/LongestConsecutiveSequence.py)
-* - [岛屿的最大区域.py](Array/MaxAreaOfIsland.py)
-* - [相乘最大的子数组.py](Array/MaximumProductSubarray.py)
-* - [最大的子数组.py](Array/MaximumSubarray.py)
-* - [合并数组.py](Array/MergeArray.py)
-* - [丢失的数字.py](Array/MissingNumber.py)
-* - [岛屿的数量.py](Array/NumberOfIslands.py)
-* - [数组中除自己外的相乘.py](Array/ProductOfArrayExceptSelf.py)
-* - [从链表尾中删除第N个节点.py](Array/RemoveNthNodeFromEndOfList.py)
-* - [从旋转过的排序数组中搜索某数.py](Array/SearchInRotatedSortedArray.py)
-* - [从旋转过的排序数组中搜索某数II.py](Array/SearchInRotatedSortedArrayII.py)
-* - [落单的数.py](Array/SingleNumber.py)
-* - [以数对为基准排序.py](Array/SortArrayByParity.py)
-* - [螺旋矩阵.py](Array/SpiralMatrix.py)
-* - [子数组合中最小的一个.py](Array/SumOfSubarrayMinimums.py)
-* - [3D图形的表面区域.py](Array/SurfaceAreaOf3DShapes.py)
-* - [被包围的区域.py](Array/SurroundedRegions.py)
-* - [两个链表相加II.py](Array/AddTowNumbersII.py)
-* - [两个链表相加.py](Array/AddTwoNumbers.py)
-* - [两个链表相交点.py](Array/IntersectionOfTwoLinkedLists.py)
-* - [数组中第k大个元素.py](Array/KthLargestElementInAnArray.py)
-* - [链表中的环.py](Array/LinkedListCycle.py)
-* - [保持当前城市天际线的最大可增加能容量.py](Array/max_increase_to_keep_city_skyline.py)
-* - [两个排序后的列表的中位数.py](Array/MedianOfTwoSorted.py)
-* - [合并两个排序过的列表.py](Array/MergerTwoSortedList.py)
-* - [合并排序的数组.py](Array/MergeSortedArray.py)
-* - [两个列表的(相同部分)最小索引和.py](Array/MinimumIndexSumOfTwoLists.py)
-* - [翻转对.py](Array/ReversePairs.py)
-* - [2D矩阵搜索.py](Array/Search2DMatrix.py)
-* - [2D矩阵搜索II.py](Array/Search2DMatrixII.py)
-* - [第三大的数.py](Array/ThirdMaximumNumbers.py)
-* - [3数相加.py](Array/ThreeSum.py)
-* - [最频繁的K个元素.py](Array/TopKFrequentElements.py)
-* - [两数相加II数组已排序.py](Array/TwoSumIIAlreadySorted.py)
-* - [两数相加.py](Array/two_sum.py)
-* - [多重三数相加.py](Array/3SumWithMultiplicity.py)
-* - [最佳买卖时机I_II.py](Array/BestTimeToBuyAndSellStockI_II.py)
-* - [二进制子数组和.py](Array/BinarySubarraysWithSum.py)
-* - [统计小于自身且在自身之后的数.py](Array/CountOfSmallerNumbersAfterSelf.py)
-* - [寻找极值.py](Array/FindPeakElement.py)
-* - [FizzBuzz.py](Array/FizzBuzz.py)
-* - [加油站.py](Array/GasStation.py)
-* - [本地和全局的倒置.py](Array/GlobalAndLocalInversions.py)
-* - [组团的变位词.py](Array/GroupAnagrams.py)
-* - [两数组的重叠部分.py](Array/IntersectionOfTwoArrays.py)
-* - [两数组重叠部分II.py](Array/IntersectionOfTwoArraysII.py)
-* - [跳跃游戏.py](Array/JumpGame.py)
-* - [跳跃游戏II.py](Array/JumpGameII.py)
-* - [距离最近的人的可走过的最远距离.py](Array/MaximizeDistanceToClosestPerson.py)
-* - [循环子数组的最大和.py](Array/MaximumSumCircularSubarray.py)
-* - [最小下落路径和.py](Array/MinimumFallingPathSum.py)
-* - [最小路径和.py](Array/MinimumPathSum.py)
-* - [单双链表.py](Array/OddEvenLinkedList.py)
-* - [解体大数组.py](Array/PartitionArrayIntoDisjointIntervals.py)
-* - [解体列表.py](Array/PartitionList.py)
-* - [Pascal 三角I_II.py](Array/Pascal'sTriangleI_II.py)
-* - [+1.py](Array/PlusOne.py)
-* - [从已排序的数组中删除重复数据.py](Array/RemoveDuplicatesFromSortedArray.py)
-* - [从已排序的数组中删除重复数据II.py](Array/RemoveDuplicatesFromSortedArrayII.py)
-* - [从已排序的列表中删除重复数据.py](Array/RemoveDuplicatesFromSortedList.py)
-* - [从已排序的列表中删除重复数据II.py](Array/RemoveDuplicatesFromSortedListII.py)
-* - [删除链表中的元素.py](Array/RemoveLinkedListElements.py)
-* - [旋转列表.py](Array/RotateList.py)
-* - [在矩阵中捣蛋.py](Array/SetMatrixZeroes.py)
-* - [洗牌.py](Array/ShuffleAnArray.py)
-* - [最大的滑动窗口.py](Array/SlidingWindowMaximum.py)
-* - [根据"对er"排序数组II.py](Array/SortArrayByParityII.py)
-* - [颜色颜色.py](Array/SortColors.py)
-* - [螺旋矩阵II.py](Array/SpiralMatrixII.py)
-* - [等于K的子数组.py](Array/SubarraySumEqualsK.py)
-* - [三角.py](Array/Triangle.py)
-* - [单词子集.py](Array/WordSubsets.py)
+- [可容纳最多水的一组容器.py](Array/ContainerWithMostWater.py)
+- [糖果公平交换.py](Array/FairCandySwap.py)
+- [已排序的数组中找到第一和最后一个元素.py](Array/FindFirstAndLastPositionOfElementInSortedArray.py)
+- [旋转过的排序数组中找到最小的元素.py](Array/FindMinimumInRotatedSortedArray.py)
+- [旋转过的排序数组中找到最小的元素II.py](Array/FindMinimumInRotatedSortedArrayII.py)
+- [足球粉儿~.py](Array/FootballFans.py)
+- [水果分到篮子里.py](Array/FruitIntoBaskets.py)
+- [三连递增的子序列.py](Array/IncreasingTripletSubsequence.py)
+- [插入间隔.py](Array/InsertInterval.py)
+- [能组合成的最大的数.py](Array/LargestNumber.py)
+- [最长的连续子序列.py](Array/LongestConsecutiveSequence.py)
+- [岛屿的最大区域.py](Array/MaxAreaOfIsland.py)
+- [相乘最大的子数组.py](Array/MaximumProductSubarray.py)
+- [最大的子数组.py](Array/MaximumSubarray.py)
+- [合并数组.py](Array/MergeArray.py)
+- [丢失的数字.py](Array/MissingNumber.py)
+- [岛屿的数量.py](Array/NumberOfIslands.py)
+- [数组中除自己外的相乘.py](Array/ProductOfArrayExceptSelf.py)
+- [从链表尾中删除第N个节点.py](Array/RemoveNthNodeFromEndOfList.py)
+- [从旋转过的排序数组中搜索某数.py](Array/SearchInRotatedSortedArray.py)
+- [从旋转过的排序数组中搜索某数II.py](Array/SearchInRotatedSortedArrayII.py)
+- [落单的数.py](Array/SingleNumber.py)
+- [以数对为基准排序.py](Array/SortArrayByParity.py)
+- [螺旋矩阵.py](Array/SpiralMatrix.py)
+- [子数组合中最小的一个.py](Array/SumOfSubarrayMinimums.py)
+- [3D图形的表面区域.py](Array/SurfaceAreaOf3DShapes.py)
+- [被包围的区域.py](Array/SurroundedRegions.py)
+- [两个链表相加II.py](Array/AddTowNumbersII.py)
+- [两个链表相加.py](Array/AddTwoNumbers.py)
+- [两个链表相交点.py](Array/IntersectionOfTwoLinkedLists.py)
+- [数组中第k大个元素.py](Array/KthLargestElementInAnArray.py)
+- [数组中第k大个元素.js](Array/KthLargestElementInAnArray.js)
+- [链表中的环.py](Array/LinkedListCycle.py)
+- [链表中的环.js](Array/LinkedListCycle.js)
+- [翻转链表.js](Array/ReverseLinkedList.js)
+- [K个一组翻转链表.js](Array/ReverseNodesInk-Group.js)
+- [保持当前城市天际线的最大可增加能容量.py](Array/max_increase_to_keep_city_skyline.py)
+- [两个排序后的列表的中位数.py](Array/MedianOfTwoSorted.py)
+- [合并两个排序过的列表.py](Array/MergerTwoSortedList.py)
+- [合并排序的数组.py](Array/MergeSortedArray.py)
+- [两个列表的(相同部分)最小索引和.py](Array/MinimumIndexSumOfTwoLists.py)
+- [翻转对.py](Array/ReversePairs.py)
+- [2D矩阵搜索.py](Array/Search2DMatrix.py)
+- [2D矩阵搜索II.py](Array/Search2DMatrixII.py)
+- [第三大的数.py](Array/ThirdMaximumNumbers.py)
+- [3数相加.py](Array/ThreeSum.py)
+- [最频繁的K个元素.py](Array/TopKFrequentElements.py)
+- [两数相加II数组已排序.py](Array/TwoSumIIAlreadySorted.py)
+- [两数相加.py](Array/two_sum.py)
+- [两数相加.js](Array/two_sum.js)
+- [多重三数相加.py](Array/3SumWithMultiplicity.py)
+- [最佳买卖时机I_II.py](Array/BestTimeToBuyAndSellStockI_II.py)
+- [二进制子数组和.py](Array/BinarySubarraysWithSum.py)
+- [统计小于自身且在自身之后的数.py](Array/CountOfSmallerNumbersAfterSelf.py)
+- [寻找极值.py](Array/FindPeakElement.py)
+- [FizzBuzz.py](Array/FizzBuzz.py)
+- [加油站.py](Array/GasStation.py)
+- [本地和全局的倒置.py](Array/GlobalAndLocalInversions.py)
+- [组团的变位词.py](Array/GroupAnagrams.py)
+- [两数组的重叠部分.py](Array/IntersectionOfTwoArrays.py)
+- [两数组重叠部分II.py](Array/IntersectionOfTwoArraysII.py)
+- [跳跃游戏.py](Array/JumpGame.py)
+- [跳跃游戏II.py](Array/JumpGameII.py)
+- [距离最近的人的可走过的最远距离.py](Array/MaximizeDistanceToClosestPerson.py)
+- [循环子数组的最大和.py](Array/MaximumSumCircularSubarray.py)
+- [最小下落路径和.py](Array/MinimumFallingPathSum.py)
+- [最小路径和.py](Array/MinimumPathSum.py)
+- [单双链表.py](Array/OddEvenLinkedList.py)
+- [解体大数组.py](Array/PartitionArrayIntoDisjointIntervals.py)
+- [解体列表.py](Array/PartitionList.py)
+- [Pascal 三角I_II.py](Array/Pascal'sTriangleI_II.py)
+- [+1.py](Array/PlusOne.py)
+- [从已排序的数组中删除重复数据.py](Array/RemoveDuplicatesFromSortedArray.py)
+- [从已排序的数组中删除重复数据II.py](Array/RemoveDuplicatesFromSortedArrayII.py)
+- [从已排序的列表中删除重复数据.py](Array/RemoveDuplicatesFromSortedList.py)
+- [从已排序的列表中删除重复数据II.py](Array/RemoveDuplicatesFromSortedListII.py)
+- [删除链表中的元素.py](Array/RemoveLinkedListElements.py)
+- [旋转列表.py](Array/RotateList.py)
+- [在矩阵中捣蛋.py](Array/SetMatrixZeroes.py)
+- [洗牌.py](Array/ShuffleAnArray.py)
+- [最大的滑动窗口.py](Array/SlidingWindowMaximum.py)
+- [根据"对er"排序数组II.py](Array/SortArrayByParityII.py)
+- [颜色颜色.py](Array/SortColors.py)
+- [螺旋矩阵II.py](Array/SpiralMatrixII.py)
+- [等于K的子数组.py](Array/SubarraySumEqualsK.py)
+- [三角.py](Array/Triangle.py)
+- [单词子集.py](Array/WordSubsets.py)
 
 ## [回溯](Backtracking/)
-* - [生成括号.py](Backtracking/GenerateParentheses.py)
-* - [子集.py](Backtracking/subsets.py)
+- [生成括号.py](Backtracking/GenerateParentheses.py)
+- [子集.py](Backtracking/subsets.py)
 
 ## [广度优先搜索](BFS/)
-* - [树中最靠近左下的节点的值.py](BFS/FindBottomLeftTreeValue.py)
-* - [二叉树层级遍历.py](BFS/BinaryTreeLevelOrderTraversal.py)
-* - [二叉树层级遍历II.py](BFS/BinaryTreeLevelOrderTraversalII.py)
-* - [二叉树层级 Zigzag 遍历.py](BFS/BinaryTreeZigzagLevelOrderTraversal.py)
-* - [二叉树的最大深度.py](BFS/MaximumDepthOfBinaryTree.py)
-* - [单词阶梯.py](BFS/WordLadder.py)
+- [树中最靠近左下的节点的值.py](BFS/FindBottomLeftTreeValue.py)
+- [二叉树层级遍历.py](BFS/BinaryTreeLevelOrderTraversal.py)
+- [二叉树层级遍历II.py](BFS/BinaryTreeLevelOrderTraversalII.py)
+- [二叉树层级 Zigzag 遍历.py](BFS/BinaryTreeZigzagLevelOrderTraversal.py)
+- [二叉树的最大深度.py](BFS/MaximumDepthOfBinaryTree.py)
+- [单词阶梯.py](BFS/WordLadder.py)
 
 ## [设计类](Design/)
-* - [LRU 缓存设计.py](Design/LRUCache.py)
-* - [RLE 迭代器.py](Design/RLEIterator.py)
-* - [O(1)复杂度的插入删除和取随机容器.py](Design/InsertDeleteGetRandomO(1).py)
+- [LRU 缓存设计.py](Design/LRUCache.py)
+- [RLE 迭代器.py](Design/RLEIterator.py)
+- [O(1)复杂度的插入删除和取随机容器.py](Design/InsertDeleteGetRandomO(1).py)
 
 ## [深度优先搜索](DFS/)
-* - [路径和.py](DFS/PathSum.py)
-* - [词搜索.py](DFS/WordSearch.py)
-* - [词搜索II.py](DFS/WordSearchII.py)
+- [路径和.py](DFS/PathSum.py)
+- [词搜索.py](DFS/WordSearch.py)
+- [词搜索II.py](DFS/WordSearchII.py)
 
 ## [动态规划](DP/)
-* - [交错的字符串.py](DP/InterleavingString.py)
-* - [最长的子序列.py](DP/longesSubsequence.py)
-* - [子数组的或运算.py](DP/BitwiseORsOfSubarray.py)
-* - [交换硬币.py](DP/CoinChange.py)
-* - [江洋大盗.py](DP/HouseRobber.py)
-* - [江洋大盗II.py](DP/HouseRobberII.py)
-* - [最长的连续递增子序列.py](DP/LongestContinuousIncreasingSubsequence.py)
-* - [A子数组中的最大比B子数组中最小要小的子数组.py](DP/MaxASubarrayLessThanMinBSubarray.py)
-* - [最大长度的数对链.py](DP/MaximumLengthOfPairChain.py)
-* - [最长增长子序列的个数.py](DP/NumberofLongestIncreasingSubsequence.py)
-* - [挑卡片.py](DP/PickCards.py)
-* - [唯一路径.py](DP/UniquePath.py)
-* - [唯一路径II.py](DP/UniquePathII.py)
-* - [爬楼.py](DP/ClimbingStairs.py)
-* - [解码方式.py](DP/DecodeWays.py)
-* - [在某字符串中找到所有的变位词.py](DP/FindAllAnagramsInAString.py)
-* - [转换字符串到单调递增.py](DP/FlipStringToMonotoneIncreasing.py)
-* - [小于K的子数组积.py](DP/SubarrayProductLessThanK.py)
-* - [单词中断处.py](DP/WordBreak.py)
+- [交错的字符串.py](DP/InterleavingString.py)
+- [最长的子序列.py](DP/longesSubsequence.py)
+- [子数组的或运算.py](DP/BitwiseORsOfSubarray.py)
+- [交换硬币.py](DP/CoinChange.py)
+- [江洋大盗.py](DP/HouseRobber.py)
+- [江洋大盗II.py](DP/HouseRobberII.py)
+- [最长的连续递增子序列.py](DP/LongestContinuousIncreasingSubsequence.py)
+- [A子数组中的最大比B子数组中最小要小的子数组.py](DP/MaxASubarrayLessThanMinBSubarray.py)
+- [最大长度的数对链.py](DP/MaximumLengthOfPairChain.py)
+- [最长增长子序列的个数.py](DP/NumberofLongestIncreasingSubsequence.py)
+- [挑卡片.py](DP/PickCards.py)
+- [唯一路径.py](DP/UniquePath.py)
+- [唯一路径II.py](DP/UniquePathII.py)
+- [爬楼.py](DP/ClimbingStairs.py)
+- [爬楼.js](DP/ClimbingStairs.js)
+- [最小花费爬楼.js](DP/MinCostClimbingStairs.js)
+- [组合总和.js](DP/CombinationSum.js)
+- [解码方式.py](DP/DecodeWays.py)
+- [在某字符串中找到所有的变位词.py](DP/FindAllAnagramsInAString.py)
+- [转换字符串到单调递增.py](DP/FlipStringToMonotoneIncreasing.py)
+- [小于K的子数组积.py](DP/SubarrayProductLessThanK.py)
+- [单词中断处.py](DP/WordBreak.py)
 
 ## [堆](Heap/)
-* - [排序矩阵中第k小个元素.py](Heap/KthSmallestElementInASortedMatrix.py)
-* - [合并K个已排序过的链表.py](Heap/MergeKSortedLists.py)
-* - [从数据流中找中位数.py](Heap/FindMedianFromDataStream.py)
+- [排序矩阵中第k小个元素.py](Heap/KthSmallestElementInASortedMatrix.py)
+- [合并K个已排序过的链表.py](Heap/MergeKSortedLists.py)
+- [合并K个已排序过的链表.js](Heap/MergeKSortedLists.js)
+- [从数据流中找中位数.py](Heap/FindMedianFromDataStream.py)
 
 ## [排序](Sorted/)
-* - [选择,插入,快排,归并](Sorted/sotred.py)
-* - [排序列表.py](Sorted/SortList.py)
-* - [奇怪的排序II.py](Sorted/WiggleSortII.py)
+- [选择,插入,快排,归并](Sorted/sotred.py)
+- [排序列表.py](Sorted/SortList.py)
+- [奇怪的排序II.py](Sorted/WiggleSortII.py)
 
 ## [纯数字问题](Number/)
-* - [两数相除.py](Number/DivideTwoIntegers.py)
-* - [Sqrt(x).py](Number/Sqrt(x).py)
+- [两数相除.py](Number/DivideTwoIntegers.py)
+- [Sqrt(x).py](Number/Sqrt(x).py)
 
 ## [栈](Stack/)
-* - [可取最小值的栈.py](Stack/GetMinStack.py)
-* - [使用栈模拟队列.py](Stack/ImplementQueueUsingStack.py)
-* - [使用递归翻转栈.py](Stack/ReverseAStackByRecursive.py)
-* - [直方图中最大的矩形.py](Stack/LargestRectangleInHistogram.py)
-* - [收集雨水.py](Stack/TrappingRainWater.py)
+- [可取最小值的栈.py](Stack/GetMinStack.py)
+- [使用栈模拟队列.py](Stack/ImplementQueueUsingStack.py)
+- [使用递归翻转栈.py](Stack/ReverseAStackByRecursive.py)
+- [直方图中最大的矩形.py](Stack/LargestRectangleInHistogram.py)
+- [收集雨水.py](Stack/TrappingRainWater.py)
 
 ## [字符串](String/)
-* - [找到可被模板替换的字符串.py](String/FindAndReplacePattern.py)
-* - [电话号码排列组合.py](String/LetterCombinationsOfAPhoneNumber.py)
-* - [最长的公共前缀.py](String/LongestCommonPrefix.py)
-* - [最小窗口子字符串.py](String/MinimumWindowSubstring.py)
-* - [翻转整数.py](String/ReverseInteger.py)
-* - [字符串->整数.py](String/StringToInteger.py)
-* - [有效的数字.py](String/ValidNumber.py)
-* - [有效的括号.py](String/ValidParentheses.py)
-* - [大写侦查.py](String/DetectCapital.py)
-* - [汉明距离.py](String/HammingDistance.py)
-* - [实现StrStr().py](String/ImplementStrStr().py)
-* - [同结构字符串.py](String/IsomorphicStrings.py)
-* - [Jewels和Stones.py](String/JewelsAndStones.py)
-* - [最末单词的长度.py](String/LengthOfLastWord.py)
-* - [最长的子字符串.py](String/LongesSubstrings.py)
-* - [最长的回文子字符串.py](String/LongestPalindromicSubstrings.py)
-* - [字符串中的分段数量.py](String/NumberOfSegmentsInString.py)
-* - [替换词.py](String/ReplaceWords.py)
-* - [翻转字符串.py](String/ReverseString.py)
-* - [转换至小写.py](String/ToLowerCase.py)
-* - [词模板.py](String/WordPattern.py)
-* - [字符串中最先出现的唯一字符.py](String/FirstUniqueCharacterInAString.py)
-* - [长印刷名字.py](String/LongPressedName.py)
-* - [使括号有效的最小添加数.py](String/MinimumAddToMakeParenthesesValid.py)
-* - [字符串中的全排列.py](String/PermutationInString.py)
-* - [转换单词.py](String/ShiftingLetters.py)
-* - [简化路径.py](String/SimplifyPath.py)
-* - [根据频率排序字符.py](String/SortCharactersByFrequency.py)
-* - [独一无二的邮箱地址.py](String/UniqueEmailAddresses.py)
-* - [有效变位词.py](String/ValidAnagram.py)
-* - [有效回文字符串.py](String/ValidPalindrome.py)
+- [找到可被模板替换的字符串.py](String/FindAndReplacePattern.py)
+- [电话号码排列组合.py](String/LetterCombinationsOfAPhoneNumber.py)
+- [最长的公共前缀.py](String/LongestCommonPrefix.py)
+- [最小窗口子字符串.py](String/MinimumWindowSubstring.py)
+- [翻转整数.py](String/ReverseInteger.py)
+- [字符串->整数.py](String/StringToInteger.py)
+- [有效的数字.py](String/ValidNumber.py)
+- [有效的括号.py](String/ValidParentheses.py)
+- [大写侦查.py](String/DetectCapital.py)
+- [汉明距离.py](String/HammingDistance.py)
+- [实现StrStr().py](String/ImplementStrStr().py)
+- [同结构字符串.py](String/IsomorphicStrings.py)
+- [Jewels和Stones.py](String/JewelsAndStones.py)
+- [最末单词的长度.py](String/LengthOfLastWord.py)
+- [最长的子字符串.py](String/LongesSubstrings.py)
+- [最长的回文子字符串.py](String/LongestPalindromicSubstrings.py)
+- [字符串中的分段数量.py](String/NumberOfSegmentsInString.py)
+- [替换词.py](String/ReplaceWords.py)
+- [翻转字符串.py](String/ReverseString.py)
+- [转换至小写.py](String/ToLowerCase.py)
+- [词模板.py](String/WordPattern.py)
+- [字符串中最先出现的唯一字符.py](String/FirstUniqueCharacterInAString.py)
+- [长印刷名字.py](String/LongPressedName.py)
+- [使括号有效的最小添加数.py](String/MinimumAddToMakeParenthesesValid.py)
+- [字符串中的全排列.py](String/PermutationInString.py)
+- [转换单词.py](String/ShiftingLetters.py)
+- [简化路径.py](String/SimplifyPath.py)
+- [根据频率排序字符.py](String/SortCharactersByFrequency.py)
+- [独一无二的邮箱地址.py](String/UniqueEmailAddresses.py)
+- [有效变位词.py](String/ValidAnagram.py)
+- [有效回文字符串.py](String/ValidPalindrome.py)
 
 ## [树](Tree/)
-* - [根据前序和后序的结果生成二叉树.py](Tree/ConstructBinaryTreeFromPreorderAndPostorderTraversal.py)
-* - [转换已排序的数组到二叉搜索树.py](Tree/ConvertSortedArrayToBinarySearchTree.py)
-* - [转换已排序的链表到二叉搜索树.py](Tree/ConvertSortedListToBinarySearchTree.py)
-* - [镜像树.py](Tree/SymmetricTree.py)
-* - [有效的二叉搜索树.py](Tree/ValidateBinarySearchTree.py)
-* - [二叉搜索树.py](Tree/BinarySearchTree.py)
-* - [二叉树的最大路径和.py](Tree/BinaryTreeMaximumPathSum.py)
-* - [路径和II.py](Tree/PathSumII.py)
-* - [“结”构与解构.py](Tree/serializeAndDeserialize.py)
-* - [根到叶的和.py](Tree/SumRootToLeafNumbers.py)
-* - [字典树.py](Tree/Trie.py)
-* - [所有可能的满二叉树.py](Tree/AllPossibleFullBinaryTree.py)
-* - [右边视角的二叉树.py](Tree/BinaryTreeRightSideView.py)
-* - [完整二叉树插入.py](Tree/CompleteBinaryTreeInserter.py)
-* - [根据中序和后序遍历结果中构建二叉树.py](Tree/ConstructBinaryTreeFromInorderAndPostorderTraversal.py)
-* - [根据前序和中序遍历结果中构建二叉树.py](Tree/ConstructBinaryTreeFromPreorderAndInorderTraversal.py)
-* - [一只二叉搜索树中第k小个数.py](Tree/KthSmallestElementInABST.py)
-* - [二叉搜索树中最小公共祖先.py](Tree/LowestCommonAncestorOfABinarySearchTree.py)
-* - [二叉树中最小公共祖先.py](Tree/LowestCommonAncestorOfABinaryTree.py)
-* - [为每个节点指定下一个右边指向.py](Tree/PopulatingNextRightPointersInEachNode.py)
-* - [为每个节点指定下一个右边指向II.py](Tree/PopulatingNextRightPointersInEachNodeII.py)
-* - [“结”构与解构二叉树.py](Tree/SerializeAndDeserializeBinaryTree.py)
+- [根据前序和后序的结果生成二叉树.py](Tree/ConstructBinaryTreeFromPreorderAndPostorderTraversal.py)
+- [转换已排序的数组到二叉搜索树.py](Tree/ConvertSortedArrayToBinarySearchTree.py)
+- [转换已排序的链表到二叉搜索树.py](Tree/ConvertSortedListToBinarySearchTree.py)
+- [镜像树.py](Tree/SymmetricTree.py)
+- [有效的二叉搜索树.py](Tree/ValidateBinarySearchTree.py)
+- [二叉搜索树.py](Tree/BinarySearchTree.py)
+- [二叉树的最大路径和.py](Tree/BinaryTreeMaximumPathSum.py)
+- [路径和II.py](Tree/PathSumII.py)
+- [“结”构与解构.py](Tree/serializeAndDeserialize.py)
+- [根到叶的和.py](Tree/SumRootToLeafNumbers.py)
+- [字典树.py](Tree/Trie.py)
+- [所有可能的满二叉树.py](Tree/AllPossibleFullBinaryTree.py)
+- [右边视角的二叉树.py](Tree/BinaryTreeRightSideView.py)
+- [完整二叉树插入.py](Tree/CompleteBinaryTreeInserter.py)
+- [根据中序和后序遍历结果中构建二叉树.py](Tree/ConstructBinaryTreeFromInorderAndPostorderTraversal.py)
+- [根据前序和中序遍历结果中构建二叉树.py](Tree/ConstructBinaryTreeFromPreorderAndInorderTraversal.py)
+- [一只二叉搜索树中第k小个数.py](Tree/KthSmallestElementInABST.py)
+- [二叉搜索树中最小公共祖先.py](Tree/LowestCommonAncestorOfABinarySearchTree.py)
+- [二叉树中最小公共祖先.py](Tree/LowestCommonAncestorOfABinaryTree.py)
+- [为每个节点指定下一个右边指向.py](Tree/PopulatingNextRightPointersInEachNode.py)
+- [为每个节点指定下一个右边指向II.py](Tree/PopulatingNextRightPointersInEachNodeII.py)
+- [“结”构与解构二叉树.py](Tree/SerializeAndDeserializeBinaryTree.py)