[Arrays & Hashing][Top K Frequent Elements] - Implement solution for Leetcode 347 (#10)

Author: javydevx

1_arrays_and_hashing/1_contains_duplicate/solution.go

@@ -15,9 +15,9 @@ func ContainsDuplicatesBruteForce(nums []int) bool {
 	return false
 }
 
-// Time complexity: O(n log n)
+// Time complexity: O(n * log n)
 // Space complexity: O(1)
-func ContainsDuplicatesSorted(nums []int) bool {
+func ContainsDuplicatesSort(nums []int) bool {
 	sort.Ints(nums)
 	for i := 1; i < len(nums); i++ {
 		if nums[i] == nums[i-1] {

1_arrays_and_hashing/1_contains_duplicate/solution_test.go

@@ -15,11 +15,11 @@ func TestContainsDuplicates(t *testing.T) {
 		{"Brute Force - Empty Slice", ContainsDuplicatesBruteForce, []int{}, false},
 		{"Brute Force - Single Element", ContainsDuplicatesBruteForce, []int{42}, false},
 
-		// ContainsDuplicatesSorted
-		{"Sorted - Duplicates", ContainsDuplicatesSorted, []int{1, 2, 3, 3}, true},
-		{"Sorted - No Duplicates", ContainsDuplicatesSorted, []int{1, 2, 3, 4}, false},
-		{"Sorted - Empty Slice", ContainsDuplicatesSorted, []int{}, false},
-		{"Sorted - Single Element", ContainsDuplicatesSorted, []int{42}, false},
+		// ContainsDuplicatesSort
+		{"Sort - Duplicates", ContainsDuplicatesSort, []int{1, 2, 3, 3}, true},
+		{"Sort - No Duplicates", ContainsDuplicatesSort, []int{1, 2, 3, 4}, false},
+		{"Sort - Empty Slice", ContainsDuplicatesSort, []int{}, false},
+		{"Sort - Single Element", ContainsDuplicatesSort, []int{42}, false},
 
 		// ContainsDuplicatesMapBool
 		{"MapBool - Duplicates", ContainsDuplicatesMapBool, []int{1, 2, 3, 3}, true},

1_arrays_and_hashing/2_valid_anagram/solution.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 )
 
-// Time complexity: O(n log n)
+// Time complexity: O(n * log n)
 // Space complexity : O(n)
 func IsAnagramSort(s, t string) bool {
 	if len(s) != len(t) {

1_arrays_and_hashing/3_two_sum/solution.go

@@ -20,7 +20,7 @@ type Pair struct {
 	idx int
 }
 
-// Time complexity: O(n log n)
+// Time complexity: O(n * log n)
 // Space complexity: O(n)
 func TwoSumSort(nums []int, target int) []int {
 	pairs := make([]Pair, len(nums))

1_arrays_and_hashing/3_two_sum/solution_test.go

@@ -16,10 +16,10 @@ func TestTwoSum(t *testing.T) {
 		// TwoSumBruteForce
 		{"Brute Force - Valid Pair", TwoSumBruteForce, []int{2, 7, 11, 15}, 9, []int{0, 1}},
 		{"Brute Force - No Pair", TwoSumBruteForce, []int{1, 2, 3}, 7, nil},
-		{"Brute - Empty", TwoSumBruteForce, []int{}, 0, nil},
-		{"Brute - Single Element", TwoSumBruteForce, []int{5}, 5, nil},
-		{"Brute - Negative Numbers", TwoSumBruteForce, []int{-3, 4, 3, 90}, 0, []int{0, 2}},
-		{"Brute - Duplicates", TwoSumBruteForce, []int{3, 3}, 6, []int{0, 1}},
+		{"Brute Force - Empty", TwoSumBruteForce, []int{}, 0, nil},
+		{"Brute Force - Single Element", TwoSumBruteForce, []int{5}, 5, nil},
+		{"Brute Force - Negative Numbers", TwoSumBruteForce, []int{-3, 4, 3, 90}, 0, []int{0, 2}},
+		{"Brute Force - Duplicates", TwoSumBruteForce, []int{3, 3}, 6, []int{0, 1}},
 
 		// Sorting (Two Pointer)
 		{"Sort - Valid Pair", TwoSumSort, []int{2, 7, 11, 15}, 9, []int{0, 1}},

1_arrays_and_hashing/5_top_k_frequent_elements/solution.go

@@ -0,0 +1,100 @@
+package topkfrequentelements
+
+import (
+	"container/heap"
+	"sort"
+)
+
+// Time complexity: O(n * log n)
+// Space complexity: O(n)
+func TopKFrequentSort(nums []int, k int) []int {
+	freqMap := make(map[int]int)
+	for _, num := range nums {
+		freqMap[num]++
+	}
+
+	type pair struct {
+		num  int
+		freq int
+	}
+
+	pairs := make([]pair, 0, len(freqMap))
+	for num, freq := range freqMap {
+		pairs = append(pairs, pair{num, freq})
+	}
+
+	sort.Slice(pairs, func(i, j int) bool {
+		return pairs[i].freq > pairs[j].freq
+	})
+
+	result := make([]int, 0, k)
+	for i := 0; i < k; i++ {
+		result = append(result, pairs[i].num)
+	}
+	return result
+}
+
+type freqPair struct {
+	num  int
+	freq int
+}
+
+type minHeap []freqPair
+
+func (h minHeap) Len() int            { return len(h) }
+func (h minHeap) Less(i, j int) bool  { return h[i].freq < h[j].freq }
+func (h minHeap) Swap(i, j int)       { h[i], h[j] = h[j], h[i] }
+func (h *minHeap) Push(x interface{}) { *h = append(*h, x.(freqPair)) }
+func (h *minHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	val := old[n-1]
+	*h = old[:n-1]
+	return val
+}
+
+// Time complexity: O(n * log k), where n is the number of elements in nums and k is the number of top frequent elements to return.
+// Space complexity: O(n)
+func TopKFrequentHeap(nums []int, k int) []int {
+	freqMap := make(map[int]int)
+	for _, num := range nums {
+		freqMap[num]++
+	}
+
+	h := &minHeap{}
+	heap.Init(h)
+
+	for num, freq := range freqMap {
+		heap.Push(h, freqPair{num, freq})
+		if h.Len() > k {
+			heap.Pop(h)
+		}
+	}
+
+	result := make([]int, 0, k)
+	for h.Len() > 0 {
+		result = append(result, heap.Pop(h).(freqPair).num)
+	}
+	return result
+}
+
+// Time complexity: O(n)
+// Space complexity: O(n)
+func TopKFrequentBucket(nums []int, k int) []int {
+	freqMap := make(map[int]int)
+	for _, num := range nums {
+		freqMap[num]++
+	}
+
+	// max possible frequency is len(nums)
+	buckets := make([][]int, len(nums)+1)
+	for num, freq := range freqMap {
+		buckets[freq] = append(buckets[freq], num)
+	}
+
+	result := []int{}
+	for i := len(buckets) - 1; i >= 0 && len(result) < k; i-- {
+		result = append(result, buckets[i]...)
+	}
+	return result[:k]
+}

1_arrays_and_hashing/5_top_k_frequent_elements/solution_test.go

@@ -0,0 +1,67 @@
+package topkfrequentelements
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func sortUnorderedResult(result []int) []int {
+	sort.Ints(result)
+	return result
+}
+
+func containsAll(target, actual []int) bool {
+	set := make(map[int]bool)
+	for _, v := range target {
+		set[v] = true
+	}
+	for _, v := range actual {
+		if !set[v] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestTopKFrequent(t *testing.T) {
+	cases := []struct {
+		name       string
+		fn         func([]int, int) []int
+		nums       []int
+		k          int
+		expected   []int
+		anyOfThese bool // if true, result can contain any subset of expected
+	}{
+		// TopKFrequentSort
+		{"Sort - Basic", TopKFrequentSort, []int{1, 1, 1, 2, 2, 3}, 2, []int{1, 2}, false},
+		{"Sort - Single", TopKFrequentSort, []int{1}, 1, []int{1}, false},
+		{"Sort - All Same Freq", TopKFrequentSort, []int{4, 4, 6, 6, 7, 7}, 2, []int{4, 6, 7}, true},
+
+		// TopKFrequentHeap
+		{"Heap - Basic", TopKFrequentHeap, []int{1, 1, 1, 2, 2, 3}, 2, []int{1, 2}, false},
+		{"Heap - Single", TopKFrequentHeap, []int{1}, 1, []int{1}, false},
+		{"Heap - All Same Freq", TopKFrequentHeap, []int{4, 4, 6, 6, 7, 7}, 2, []int{4, 6, 7}, true},
+
+		// TopKFrequentBucket
+		{"Bucket - Basic", TopKFrequentBucket, []int{1, 1, 1, 2, 2, 3}, 2, []int{1, 2}, false},
+		{"Bucket - Single", TopKFrequentBucket, []int{1}, 1, []int{1}, false},
+		{"Bucket - All Same Freq", TopKFrequentBucket, []int{4, 4, 6, 6, 7, 7}, 2, []int{4, 6, 7}, true},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := c.fn(c.nums, c.k)
+			sortedGot := sortUnorderedResult(got)
+			if c.anyOfThese {
+				if len(got) != c.k || !containsAll(c.expected, got) {
+					t.Errorf("%s failed: expected any %d of %v, got %v", c.name, c.k, c.expected, sortedGot)
+				}
+			} else {
+				if !reflect.DeepEqual(sortedGot, sortUnorderedResult(c.expected)) {
+					t.Errorf("%s failed: expected %v, got %v", c.name, c.expected, sortedGot)
+				}
+			}
+		})
+	}
+}