Problem/heap (#23)

* Add 215. Kth Largest Element in an Array solution

* Add 215. Kth Largest Element in an Array self-implemented heap solution

* Add 347. Top K Frequent Elements solution

* Add 347. Top K Frequent Elements bucket sort solution

* Update 15. 3Sum notes

* Update 347. Top K Frequent Elements solution

* Add 692. Top K Frequent Words min heap solution

* Add 378. Kth Smallest Element in a Sorted Matrix heap solution

* Add 378. Kth Smallest Element in a Sorted Matrix binary search solution

* Add 973. K Closest Points to Origin heap solution

* Add 767. Reorganize String solution

* Add quickselect algorithm

* Add 451. Sort Characters By Frequency solution

* Add 373. Find K Pairs with Smallest Sums solution

* Add 295. Find Median from Data Stream solution

* Add full implementation of heap

* Add array problems summary notes

* Update 295. Find Median from Data Stream solution and note

* Update 189. Rotate Array solution

* Organize the problems and solutions list

* Update heap note

Author: enginebai

README.md

@@ -14,17 +14,17 @@ The notes here are to contain all basic/fundamental/popular data strcutures and
 - [Linked List](./topics/linked-list.md)
 - [Stack & Queue](./topics/stack-queue.md)
 - [Tree](./topics/tree.md)
+- [Heap & Priority Queue](./topics/heap.md)
 - [Graph](./topics/graph.md)
 - [Shortest Path](./topics/shortest-path.md)
 - [Recursion](./topics/recursion.md)
 - [Dynamic Programming](./topics/dynamic-programming.md)
 - [Greedy](./topics/greedy.md)
 - [Sorting](./topics/sorting.md)
-- [Heap & Priority Queue](./topics/heap.md)
 - [Hash Table](./topics/hash-table.md)
 - [Searching](./topics/searching.md)
 - (TODO) [Other](./topics/other.md)
-- 👉 [Problems & Solutions](./topics/problems-solutions.md)
+- 👉 [Problems & Solutions](./problems/problems-solutions.md)
 
 ## Complexity
 ![Sequence Complexity](./media/complexity-sequence.png)

leetcode/15.3sum.md

@@ -1,6 +1,8 @@
 ## [15. 3Sum](https://leetcode.com/problems/3sum/)
 
 ### Two Pointers
+> The reason why to sort first, the way to avoid duplicate and why two pointers approach helps, you can take a [nice explanation](https://leetcode.cn/problems/3sum/solution/san-shu-zhi-he-by-leetcode-solution/)!!
+
 The array `[-1, 0, 1, 2, -1, -4]` can be sorted at first, it will become `[-4, -1, -1, 0, 1, 2]`, then we can fix the `1st` number one by one, and use two points to find the `2nd` + `3rd` number that make the three sum = 0:
 
 ```
@@ -54,13 +56,7 @@ fun threeSum(nums: IntArray): List<List<Int>> {
 * **Time Complexity**: `O(n^2)`.
 * **Space Complexity**: `O(n^2)`.
 
-#### References
-* https://www.geekxh.com/1.0.%E6%95%B0%E7%BB%84%E7%B3%BB%E5%88%97/008.html#_02%E3%80%81%E9%A2%98%E7%9B%AE%E5%88%86%E6%9E%90
-* https://www.cnblogs.com/grandyang/p/4481576.html
-* Clearer answer: https://leetcode.com/problems/3sum/discuss/143636/Java-with-set
-
-
-### First Attempt
+### First Attempt (WA)
 We fix the `1st` number, then we can find the `2nd`, `3rd` numbers from two sum solution. However, it can't avoid the duplicate tuiplets and that breaks the problem.
 
 ```kotlin

leetcode/189.rotate-array.md

@@ -18,25 +18,25 @@ k = 3
 
 ```kotlin
 fun rotate(nums: IntArray, k: Int): Unit {
-    reverse(nums)
-    val rotateIndex = k % nums.size
-    reserve(nums.slice(0, rotateIndex - 1))
-    reserve(nums.slice(rotateIndex, nums.size - 1))
+    val kk = k % nums.size
+    if (kk == 0) return
+    reverse(nums, 0, nums.size - 1)
+    reverse(nums, 0, (kk - 1))
+    reverse(nums, kk, nums.size - 1)
 }
 
-private fun reserve(nums: IntArray) {
-    var left = 0
-    var right = nums.size - 1
+private fun reverse(A: IntArray, start: Int, end: Int) {
+    var left = start
+    var right = end 
     while (left < right) {
-        swap(nums, left++, right--)
+        val temp = A[left]
+        A[left] = A[right]
+        A[right] = temp
+        
+        left++
+        right--
     }
 }
-
-private fun swap(nums: IntArray, n1: Int, n2: Int) {
-    val temp = nums[n1]
-    nums[n1] = nums[n2]
-    nums[n2] = temp
-}
 ```
 
 ### With Extra Space

leetcode/215.kth-largest-element-in-an-array.md

@@ -0,0 +1,132 @@
+## [215. Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/)
+
+### Using Build-in Heap
+```kotlin
+fun findKthLargest(nums: IntArray, k: Int): Int {
+    // Default is ascending
+    val heap = PriorityQueue<Int>(Comparator<Int> { n1, n2 ->
+        // a negative integer, zero, or a positive integer 
+        // as the first argument is less than, equal to, or greater than the second.
+        // Descending
+        // when {
+        // i > j -> -1
+        // i < j -> 1
+        // else -> 0
+        // }
+        n2 - n1
+    })
+    heap.addAll(nums.toList())
+    var i = 1
+    while (i < k) {
+        heap.poll()
+        i++
+    }
+    return heap.peek()
+}
+```
+
+### IMPORTANT!!
+The k-th element from the array `A` after `buildMaxHeap()` **CAN'T** be accessed directed by `A[k- 1]`, it should be accessed by `poll()` (it will re-heapify after this operation).
+
+```js
+Original = [3,2,3,1,2,4,5,5,6]
+Heap = [6,5,5,3,2,4,3,2,1]
+// kth = 4 is not 3!!!
+```
+
+### Implement My Heap
+* It's important to use `heapSize` for heapify and pop, since you can't change the array.
+
+```kotlin
+fun findKthLargest(nums: IntArray, k: Int): Int {
+    buildMaxHeap(nums)
+    var i = 0
+    while (i < k - 1) {
+        pop(nums, nums.size - i)
+        i++
+    }
+    return nums[0]
+}
+
+private fun buildMaxHeap(A: IntArray) {
+    for (i in A.size / 2 downTo 0) {
+        heapifyDown(A, i, A.size) 
+    }
+}
+
+private fun heapifyDown(A: IntArray, index: Int, heapSize: Int) {
+    val leftIndex = index * 2 + 1
+    val rightIndex = index * 2 + 2
+    var largestIndex = index
+    
+    if (leftIndex < heapSize && A[leftIndex] > A[largestIndex]) {
+        largestIndex = leftIndex
+    }
+    if (rightIndex < heapSize && A[rightIndex] > A[largestIndex]) {
+        largestIndex = rightIndex
+    }
+    if (largestIndex != index) {
+        swap(A, largestIndex, index)
+        heapifyDown(A, largestIndex, heapSize)
+    }
+}
+
+private fun swap(A: IntArray, i: Int, j: Int) {
+    val temp = A[i]
+    A[i] = A[j]
+    A[j] = temp
+}
+
+private fun pop(A: IntArray, heapSize: Int): Int {
+    val peek = A[0]
+    A[0] = A[heapSize - 1]
+    heapifyDown(A, 0, heapSize - 1)
+    return peek
+}
+```
+
+### Quickselect
+Idea from [Quick Sort](../topics/sorting.md#quick-sort)
+
+* Partition: `[ < X ][X][ > X]` returns `q` (the pivot index), once `q == k` then `A[X]` is what we're looking for.
+
+```kotlin
+fun findKthLargest(nums: IntArray, k: Int): Int {
+    // Top k = (size - k)-th small number
+    // Quick sort is sort ascendingly, we have find the (size - k)-th small number!!
+    return quickSelect(nums, 0, nums.size - 1, nums.size - k)
+}
+
+private fun quickSelect(A: IntArray, p: Int, r: Int, k: Int): Int {
+    val q = partition(A, p, r)
+    if (q == k) return A[q]
+    else {
+        return if (q < k) quickSelect(A, q + 1, r, k)
+        else quickSelect(A, p, q - 1, k)
+    }
+}
+
+private fun partition(A: IntArray, p: Int, r: Int): Int {
+    // We can choose pivot randomly in range p and r to avoid worst case
+    val pivot = A[p]
+    var i = p
+    for (j in p + 1..r) {
+        if (A[j] <= pivot) {
+            i++
+            swap(A, i, j)
+        }
+    }
+    swap(A, i, p)
+    return i
+}
+
+
+private fun swap(A: IntArray, i: Int, j: Int) {
+    val temp = A[i]
+    A[i] = A[j]
+    A[j] = temp
+}
+```
+
+* **Time Complexity**: `O(n)` (expected, average) but `O(n^2)` for worst case.
+* **Space Complexity**: `O(lg n)` (expected) for recursion.

leetcode/295.find-median-from-data-stream.md

@@ -0,0 +1,79 @@
+## [295. Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/)
+
+**Idea!** We use two heaps to store the numbers, min heap to store half of numbers that are greater than median and max heap to store half of numbers that are less than median.
+
+* We choose the correct heap to add (comparing with median)
+* We have to re-balance the two heaps so that its size difference will be within 1.
+
+![](../media/295.find-median-from-data-stream.png)
+
+```js
+Min Heap:
+    3
+   / \
+  4   5
+
+Max Heap:
+    2
+   / \
+  1   0
+
+Median = 3
+```
+
+```js
+Min Heap:
+    3
+   / \
+  4   5
+
+Max Heap:
+    2
+   /
+  1
+
+Median = (3 + 2) / 2
+```
+
+
+```kotlin
+class MedianFinder() {
+    
+    // We use min heap to store numbers greater than median
+    private val minHeap = PriorityQueue<Int>() { n1, n2 -> n1 - n2 }
+    // We use max heap to store numbsers less thant median
+    private val maxHeap = PriorityQueue<Int>() { n1, n2 -> n2 - n1 }
+
+    fun addNum(num: Int) {
+        if (minHeap.isEmpty() || num >= minHeap.peek()) {
+            minHeap.add(num)
+            
+            // Re-balance the two heaps to make sure that the size difference will be <= 1
+            if (minHeap.size > maxHeap.size + 1) {
+                maxHeap.add(minHeap.poll())
+            }
+        } else {
+            maxHeap.add(num)
+
+            // Re-balance two heaps
+            if (maxHeap.size > minHeap.size) {
+                minHeap.add(maxHeap.poll())
+            }
+        }
+    }
+
+    fun findMedian(): Double {
+        // For odd size
+        return if (minHeap.size > maxHeap.size) minHeap.peek().toDouble()
+        // For even size
+        else (minHeap.peek().toDouble() + maxHeap.peek().toDouble()) / 2.0
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * var obj = MedianFinder()
+ * obj.addNum(num)
+ * var param_2 = obj.findMedian()
+ */
+```

leetcode/347.top-k-frequent-elements.md

@@ -0,0 +1,82 @@
+## [347. Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/)
+
+### Heap
+* We use min heap, iterate all frequency entry, pop if the heap size > `k`, the final result of heap will be the result (in reversed order).
+
+```kotlin
+fun topKFrequent(nums: IntArray, k: Int): IntArray {
+    if (nums.size == 1) return nums
+    // Value and it frequency
+    val frequencyMap = hashMapOf<Int, Int>()
+    for (i in 0 until nums.size) {
+        if (frequencyMap.containsKey(nums[i])) {
+            frequencyMap[nums[i]] = frequencyMap[nums[i]]!! + 1
+        } else {
+            frequencyMap[nums[i]] = 1
+        }
+    }
+
+    val minHeap = PriorityQueue<Map.Entry<Int, Int>>() { e1, e2 ->
+        e1.value - e2.value
+    }
+    frequencyMap.forEach {
+        minHeap.add(it)
+        if (minHeap.size > k) {
+            minHeap.poll()
+        }
+    }
+    val results = IntArray(k)
+    var index = k - 1
+    while (index >= 0) {
+        results[index] = minHeap.poll()!!.key
+        index--
+    }
+    return results
+}
+```
+
+* **Time Complexity**: `O(n lg k)`, we iterate `n` items, and `add()` / `poll()` takes `O(lg k)` time, total takes `O(n lg k)` time.
+* **Space Complexity**: `O(n) + O(k)` for hash table and heap respectively, total takes `O(n)` time.
+
+### Bucket Sort
+```kotlin
+fun topKFrequent(nums: IntArray, k: Int): IntArray {
+    val results = mutableListOf<Int>()
+    // Value and its frequency
+    // (1, 3)
+    // (2, 2)
+    // (3, 3)
+    // (4, 1)
+    val frequencyMap = hashMapOf<Int, Int>()
+    for (i in 0 until nums.size) {
+        val value = nums[i]
+        if (frequencyMap.containsKey(value)) {
+            frequencyMap[value] = frequencyMap[value]!! + 1
+        } else {
+            frequencyMap[value] = 1
+        }
+    }
+
+    // We use frequency as index, and store its values of that frequency
+    // bucketList[0] = []
+    // bucketList[1] = [4]
+    // bucketList[2] = [2]
+    // bucketList[3] = [1, 3]
+    // bucketList[4] = []
+    // Plus 1 for zero frequency
+    val bucketList = MutableList<MutableList<Int>>(nums.size + 1) { _ -> mutableListOf() }
+    for (entry in frequencyMap) {
+        val value = entry.key
+        val frequency = entry.value
+        bucketList.get(frequency).add(value)
+    }
+    for (i in bucketList.size - 1 downTo 0) {
+        if (bucketList.getOrNull(i) == null) continue
+        else {
+            results.addAll(bucketList.get(i))
+            if (results.size >= k) break
+        }
+    }
+    return results.toIntArray()
+}
+```