solution of top k frequent elements problem based of quickselect (Lomuto, Hoare partitioning; quicksort included)

Author: emikhalev

data_structures/heap/binary_heap.go

@@ -44,7 +44,7 @@ func (h *BinaryHeap) Extract() (int, bool) {
 }
 
 rv := h.data[0]
-li := len(h.data)-1
+li := len(h.data) - 1
 h.data[0] = h.data[li]
 h.data = h.data[:li]
 
@@ -61,8 +61,8 @@ func (h *BinaryHeap) Extract() (int, bool) {
 */
 func (h *BinaryHeap) siftUp() {
 c := len(h.data) - 1
-for ;c>0; {
-p := (c-1) / 2
+for c > 0 {
+p := (c - 1) / 2
 if h.data[c] < h.data[p] {
 break
 }
@@ -80,9 +80,9 @@ func (h *BinaryHeap) siftUp() {
 1. Compare the new root with its children; if they are in the correct order, stop.
 2. If not, swap the element with one of its children and return to the previous step.
 (Swap with its smaller child in a min-heap and its larger child in a max-heap.)
- */
+*/
 func (h *BinaryHeap) siftDown(i int) {
-for ;; {
+for {
 left := 2*i + 1
 right := 2*i + 2
 largest := i

data_structures/heap/binary_heap_compare_fn.go

@@ -3,7 +3,7 @@
 package heap
 
 type BinaryHeapFn struct {
-data []int
+data  []int
 compareFn func(i, j int) int
 }
 
@@ -18,7 +18,7 @@ func (h *BinaryHeapFn) Extract() (int, bool) {
 }
 
 rv := h.data[0]
-li := len(h.data)-1
+li := len(h.data) - 1
 h.data[0] = h.data[li]
 h.data = h.data[:li]
 
@@ -28,8 +28,8 @@ func (h *BinaryHeapFn) Extract() (int, bool) {
 
 func (h *BinaryHeapFn) siftUp() {
 c := len(h.data) - 1
-for ;c>0; {
-p := (c-1) / 2
+for c > 0 {
+p := (c - 1) / 2
 if h.compareFn(h.data[c], h.data[p]) < 0 {
 break
 }
@@ -41,7 +41,7 @@ func (h *BinaryHeapFn) siftUp() {
 }
 
 func (h *BinaryHeapFn) siftDown(i int) {
-for ;; {
+for {
 left := 2*i + 1
 right := 2*i + 2
 largest := i

data_structures/heap/binary_heap_compare_fn_test.go

@@ -2,14 +2,13 @@ package heap
 
 import "testing"
 
-
 var (
-compareFnMaxHeap = func (i, j int) int {
-return i-j
+compareFnMaxHeap = func(i, j int) int {
+return i - j
 }
 
-compareFnMinHeap = func (i, j int) int {
-return j-i
+compareFnMinHeap = func(i, j int) int {
+return j - i
 }
 )
 

leetcode/top_k_frequent_elements-solution-quickselect.go

@@ -2,3 +2,105 @@
 
 // Based on algorithm: https://en.wikipedia.org/wiki/Quickselect
 package main
+
+func topKFrequent(nums []int, k int) []int {
+// O(N)
+fs := freqs(nums)
+
+// O(N)
+frV := make([]int, len(fs))
+elV := make([]int, len(fs))
+idx := 0
+for eV, fV := range fs {
+elV[idx] = eV
+frV[idx] = fV
+idx++
+}
+
+// quickselect - O(N), the worst case will be O(N^2) and we need Hoare partitioning to work with duplicates properly
+quickselect(elV, frV, 0, len(fs)-1, len(fs)-k)
+return elV[len(elV)-k:]
+}
+
+// freqs - returns map[elementValue]frequency(count of elements)
+func freqs(nums []int) map[int]int {
+res := make(map[int]int)
+for i := 0; i < len(nums); i++ {
+f, _ := res[nums[i]]
+res[nums[i]] = f + 1
+}
+return res
+}
+
+func quickselect(elV, frV []int, left, right, k int) {
+for {
+if left == right {
+return
+}
+pivotIndex := partitionLomuto(elV, frV, left, right)
+if pivotIndex == k {
+return
+}
+if k < pivotIndex {
+quickselect(elV, frV, left, pivotIndex-1, k)
+return
+} else {
+quickselect(elV, frV, pivotIndex+1, right, k)
+return
+}
+}
+}
+
+func quicksort(elV, frV []int, left, right int) {
+if left < right {
+pivotIndex := partitionLomuto(elV, frV, left, right)
+quicksort(elV, frV, left, pivotIndex-1)
+quicksort(elV, frV, pivotIndex+1, right)
+}
+}
+
+// Hoare partition
+func partitionHoare(elV, frV []int, left, right int) int {
+pivotIndex := (right + left) / 2
+pivot := frV[pivotIndex]
+for {
+for frV[left] < pivot {
+left++
+}
+for frV[right] > pivot {
+right--
+}
+
+if left >= right {
+return right
+}
+
+// swap
+swap(frV, left, right)
+swap(elV, left, right)
+left++
+right--
+}
+}
+
+// Lomuto partition
+func partitionLomuto(elV, frV []int, left, right int) int {
+pivot := frV[right]
+i := left
+for j := left; j <= right; j++ {
+if frV[j] < pivot {
+swap(frV, i, j)
+swap(elV, i, j)
+i++
+}
+}
+swap(frV, i, right)
+swap(elV, i, right)
+return i
+}
+
+func swap(n []int, i, j int) {
+t := n[i]
+n[i] = n[j]
+n[j] = t
+}