add js solution for leetcode 23 215 347

Author: swiftwind0405

README.md

@@ -140,7 +140,7 @@
 |357|[Count Numbers with Unique Digits](https://leetcode.com/problems/count-numbers-with-unique-digits/) | |Medium|
 |350|[Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) | [js](./algorithms/intersectionOfTwoArraysII/intersectionOfTwoArraysII.js) |Easy|
 |349|[Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) | [js](./algorithms/intersectionOfTwoArrays/intersectionOfTwoArrays.js) |Easy|
-|347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | |Medium|
+|347|[Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) | [js](./algorithms/topKFrequentElements/Solution.js) |Medium|
 |345|[Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/) | |Easy|
 |344|[Reverse String](https://leetcode.com/problems/reverse-string/) [java](./algorithms/resverseString/Solution.java), [js](./algorithms/resverseString/resverseString.js) | |Easy|
 |343|[Integer Break](https://leetcode.com/problems/integer-break/) | |Medium|
@@ -223,7 +223,7 @@
 |218|[The Skyline Problem](https://leetcode.com/problems/the-skyline-problem/)| |Hard|
 |217|[Contains Duplicate](https://leetcode.com/problems/contains-duplicate/)| |Easy|
 |216|[Combination Sum III](https://leetcode.com/problems/combination-sum-iii/)| |Medium|
-|215|[Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/)| |Medium|
+|215|[Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/)| [js](./algorithms/KthLargestElementInAnArray/KthLargestElementInAnArray.js) |Medium|
 |214|[Shortest Palindrome](https://leetcode.com/problems/shortest-palindrome/)| |Hard|
 |213|[House Robber II](https://leetcode.com/problems/house-robber-ii/)| |Medium|
 |212|[Word Search II](https://leetcode.com/problems/word-search-ii/)| |Hard|
@@ -409,7 +409,7 @@
 |26|[Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/)|  [java](./algorithms/removeDuplicatesFromSortedArray/Solution.java)  |Easy|
 |25|[Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/)| |Hard|
 |24|[Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/)| [js](./algorithms/swapNodesInPairs/swapNodesInPairs.js) |Medium|
-|23|[Merge k Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists/)| |Hard|
+|23|[Merge k Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists/)| [js](./algorithms/mergeKSortedLists/Solution.js) |Hard|
 |22|[Generate Parentheses](https://leetcode.com/problems/generate-parentheses/)| [js](./algorithms/generateParentheses/generateParentheses.js) |Medium|
 |21|[Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/)| [java](./algorithm/mergeTwoSortedLists/Solution.java), [js](./algorithms/mergeTwoSortedLists/mergeTwoSortedLists.js) |Easy|
 |20|[Valid Parentheses](https://leetcode.com/problems/valid-parentheses/)| [js](./algorithms/validParentheses/validParentheses.js) |Easy|

algorithms/KthLargestElementInAnArray/Solution.js

@@ -0,0 +1,75 @@
+class MinHeap {
+    constructor() {
+        this.heap = [];
+    }
+
+    getParentIndex(i) {
+        return (i - 1) >> 1;
+    }
+    
+    getLeftIndex(i) {
+        return 2 * i + 1;
+    }
+
+    getRightIndex(i) {
+        return 2 * i + 2;
+    }
+
+    swap(i1, i2) {
+        const temp = this.heap[i1];
+        this.heap[i1] = this.heap[i2];
+        this.heap[i2] = temp;
+    }
+
+    shiftUp(index) {
+        if ( index === 0) return;
+        const parentIndex = this.getParentIndex(index);
+        if (this.heap[parentIndex] > this.heap[index]) {
+            this.swap(parentIndex, index);
+            this.shiftUp(parentIndex);
+        }
+    }
+
+    shiftDown(index) {
+        if (index > this.heap.length - 1) return;
+        const leftIndex = this.getLeftIndex(index);
+        const rightIndex = this.getRightIndex(index);
+        if (this.heap[leftIndex] < this.heap[index]) {
+            this.swap(leftIndex, index);
+            this.shiftDown(leftIndex);
+        }
+        if (this.heap[rightIndex] < this.heap[index]) {
+            this.swap(rightIndex, index);
+            this.shiftDown(rightIndex);
+        }
+    }
+
+    insert(value) {
+        this.heap.push(value);
+        this.shiftUp(this.heap.length - 1);
+    }
+
+    pop() {
+        this.heap[0] = this.heap.pop();
+        this.shiftDown(0)
+    }
+
+    peek() {
+        return this.heap[0];
+    }
+
+    size() {
+        return this.heap.length;
+    }
+}
+
+var findKthLargest = function(nums, k) {
+    const h = new MinHeap();
+    nums.forEach(num => {
+        h.insert(num);
+        if (h.size() > k) {
+            h.pop();
+        }
+    });
+    return h.peek();
+};

algorithms/mergeKSortedLists/Solution.js

@@ -0,0 +1,88 @@
+class MinHeap {
+    constructor() {
+        this.heap = [];
+    }
+
+    getParentIndex(i) {
+        return (i - 1) >> 1;
+    }
+    
+    getLeftIndex(i) {
+        return 2 * i + 1;
+    }
+
+    getRightIndex(i) {
+        return 2 * i + 2;
+    }
+
+    swap(i1, i2) {
+        const temp = this.heap[i1];
+        this.heap[i1] = this.heap[i2];
+        this.heap[i2] = temp;
+    }
+
+    shiftUp(index) {
+        if ( index === 0) return;
+        const parentIndex = this.getParentIndex(index);
+        if (this.heap[parentIndex] && this.heap[parentIndex].val > this.heap[index].val) {
+            this.swap(parentIndex, index);
+            this.shiftUp(parentIndex);
+        }
+    }
+
+    shiftDown(index) {
+        if (index > this.heap.length - 1) return;
+        const leftIndex = this.getLeftIndex(index);
+        const rightIndex = this.getRightIndex(index);
+        if (this.heap[leftIndex] && this.heap[leftIndex].val < this.heap[index].val) {
+            this.swap(leftIndex, index);
+            this.shiftDown(leftIndex);
+        }
+        if (this.heap[rightIndex] && this.heap[rightIndex].val < this.heap[index].val) {
+            this.swap(rightIndex, index);
+            this.shiftDown(rightIndex);
+        }
+    }
+
+    insert(value) {
+        this.heap.push(value);
+        this.shiftUp(this.heap.length - 1);
+    }
+
+    pop() {
+        if (this.size() === 1) return this.heap.shift();
+        const top = this.heap[0];
+        this.heap[0] = this.heap.pop();
+        this.shiftDown(0);
+        return top;
+    }
+
+    peek() {
+        return this.heap[0];
+    }
+
+    size() {
+        return this.heap.length;
+    }
+}
+
+var mergeKLists = function(lists) {
+    const h = new MinHeap();
+    const res = new ListNode(null);
+    let p = res;
+
+    lists.forEach(l => {
+        !!l && h.insert(l);
+    })
+
+    while (h.size()) {
+        const node = h.pop();
+        p.next = node;
+        p = p.next;
+        if (node.next) {
+            h.insert(node.next)
+        }
+    }
+
+    return res.next;
+};

algorithms/topKFrequentElements/Solution.js

@@ -0,0 +1,80 @@
+class MinHeap {
+    constructor() {
+        this.heap = [];
+    }
+
+    getParentIndex(i) {
+        return (i - 1) >> 1;
+    }
+    
+    getLeftIndex(i) {
+        return 2 * i + 1;
+    }
+
+    getRightIndex(i) {
+        return 2 * i + 2;
+    }
+
+    swap(i1, i2) {
+        const temp = this.heap[i1];
+        this.heap[i1] = this.heap[i2];
+        this.heap[i2] = temp;
+    }
+
+    shiftUp(index) {
+        if ( index === 0) return;
+        const parentIndex = this.getParentIndex(index);
+        if (this.heap[parentIndex] && this.heap[parentIndex].value > this.heap[index].value) {
+            this.swap(parentIndex, index);
+            this.shiftUp(parentIndex);
+        }
+    }
+
+    shiftDown(index) {
+        if (index > this.heap.length - 1) return;
+        const leftIndex = this.getLeftIndex(index);
+        const rightIndex = this.getRightIndex(index);
+        if (this.heap[leftIndex] && this.heap[leftIndex].value < this.heap[index].value) {
+            this.swap(leftIndex, index);
+            this.shiftDown(leftIndex);
+        }
+        if (this.heap[rightIndex] && this.heap[rightIndex].value < this.heap[index].value) {
+            this.swap(rightIndex, index);
+            this.shiftDown(rightIndex);
+        }
+    }
+
+    insert(value) {
+        this.heap.push(value);
+        this.shiftUp(this.heap.length - 1);
+    }
+
+    pop() {
+        this.heap[0] = this.heap.pop();
+        this.shiftDown(0)
+    }
+
+    peek() {
+        return this.heap[0];
+    }
+
+    size() {
+        return this.heap.length;
+    }
+}
+
+var topKFrequent = function(nums, k) {
+    const map = new Map();
+    const h = new MinHeap();
+    nums.forEach(num => {
+        map.set(num, map.has(num) ? map.get(num) + 1 : 1)
+    });
+    map.forEach((value, key) => {
+        h.insert({value, key});
+        if (h.size() > k) {
+            h.pop();
+        }
+    });
+
+    return h.heap.map(a => a.key);
+};