feat: 增加一些Js解法

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]
+};

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
+};

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
+
+    }
+};

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
+    }
+};

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]]
+        }
+    }
+};

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]
+};