topk frequent elements

Author: rampatra

src/main/java/com/leetcode/heaps/KthLargestElementInArray.java

@@ -0,0 +1,143 @@
+package com.leetcode.heaps;
+
+import com.rampatra.base.MaxHeap;
+
+import java.util.PriorityQueue;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Level: Medium
+ * Link: https://leetcode.com/problems/kth-largest-element-in-an-array/
+ * Description:
+ * Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not
+ * the kth distinct element.
+ * <p>
+ * Example 1:
+ * Input: [3,2,1,5,6,4] and k = 2
+ * Output: 5
+ * <p>
+ * Example 2:
+ * Input: [3,2,3,1,2,4,5,5,6] and k = 4
+ * Output: 4
+ * <p>
+ * Note:
+ * You may assume k is always valid, 1 ≤ k ≤ array's length.
+ *
+ * @author rampatra
+ * @since 2019-08-19
+ */
+public class KthLargestElementInArray {
+
+    /**
+     * Runtime: <a href="https://leetcode.com/submissions/detail/252999497/">1 ms</a>.
+     *
+     * @param nums
+     * @param k
+     * @return
+     */
+    public static int findKthLargest(int[] nums, int k) {
+        return heapSortUntilK(nums, k);
+    }
+
+    /**
+     * In heapsort, after each iteration we have the max element at the end of the array. Ergo, if we run the algorithm
+     * k times then we would have our kth largest element.
+     *
+     * @param a
+     * @param k
+     * @return
+     */
+    public static int heapSortUntilK(int[] a, int k) {
+        buildMaxHeap(a);
+        int count = 0;
+
+        for (int i = a.length - 1; i > 0; i--) {
+            if (count++ == k) {
+                break;
+            }
+            swap(a, 0, i);
+            maxHeapify(a, 0, i);
+        }
+
+        return a[a.length - k];
+    }
+
+    /**
+     * Makes the array {@param a} satisfy the max heap property starting from
+     * {@param index} till {@param end} position in array.
+     * <p/>
+     * See this {@link MaxHeap#maxHeapify} for a basic version of maxHeapify.
+     * <p/>
+     * Time complexity: O(log n).
+     *
+     * @param a
+     * @param index
+     * @param end
+     */
+    public static void maxHeapify(int[] a, int index, int end) {
+        int largest = index;
+        int leftIndex = 2 * index + 1;
+        int rightIndex = 2 * index + 2;
+
+        if (leftIndex < end && a[index] < a[leftIndex]) {
+            largest = leftIndex;
+        }
+        if (rightIndex < end && a[largest] < a[rightIndex]) {
+            largest = rightIndex;
+        }
+
+        if (largest != index) {
+            swap(a, index, largest);
+            maxHeapify(a, largest, end);
+        }
+    }
+
+    /**
+     * Converts array {@param a} in to a max heap.
+     * <p/>
+     * Time complexity: O(n) and is not O(n log n).
+     */
+    private static void buildMaxHeap(int[] a) {
+        for (int i = a.length / 2 - 1; i >= 0; i--) {
+            maxHeapify(a, i, a.length);
+        }
+    }
+
+
+    /**
+     * When you poll() on a PriorityQueue the smallest number in the queue is removed. Based on this property, we can
+     * iterate over the entire array and in the end we would be left with the k largest element in the queue.
+     *
+     * @param nums
+     * @param k
+     * @return
+     */
+    public static int findKthLargestUsingPriorityQueue(int[] nums, int k) {
+        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
+
+        for (int num : nums) {
+            priorityQueue.add(num);
+
+            if (priorityQueue.size() > k) {
+                priorityQueue.poll();
+            }
+        }
+
+        return priorityQueue.isEmpty() ? -1 : priorityQueue.peek();
+    }
+
+    private static void swap(int[] a, int firstIndex, int secondIndex) {
+        a[firstIndex] = a[firstIndex] + a[secondIndex];
+        a[secondIndex] = a[firstIndex] - a[secondIndex];
+        a[firstIndex] = a[firstIndex] - a[secondIndex];
+    }
+
+    public static void main(String[] args) {
+        assertEquals(5, findKthLargest(new int[]{3, 2, 1, 5, 6, 4}, 2));
+        assertEquals(3, findKthLargest(new int[]{3, 2, 1, 5, 6, 4}, 4));
+
+        assertEquals(5, findKthLargestUsingPriorityQueue(new int[]{3, 2, 1, 5, 6, 4}, 2));
+        assertEquals(3, findKthLargestUsingPriorityQueue(new int[]{3, 2, 1, 5, 6, 4}, 4));
+    }
+}

src/main/java/com/leetcode/heaps/TopKFrequentElements.java

@@ -0,0 +1,68 @@
+package com.leetcode.heaps;
+
+import javafx.util.Pair;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Level: Medium
+ * Link: https://leetcode.com/problems/top-k-frequent-elements/
+ * Description:
+ * Given a non-empty array of integers, return the k most frequent elements.
+ * <p>
+ * Example 1:
+ * Input: nums = [1,1,1,2,2,3], k = 2
+ * Output: [1,2]
+ * <p>
+ * Example 2:
+ * Input: nums = [1], k = 1
+ * Output: [1]
+ * <p>
+ * Note:
+ * - You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
+ * - Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
+ *
+ * @author rampatra
+ * @since 2019-08-19
+ */
+public class TopKFrequentElements {
+
+    /**
+     * TODO: A faster approach without using Pair.
+     * <p>
+     * Runtime: <a href="https://leetcode.com/submissions/detail/253027938/">51 ms</a>.
+     *
+     * @param nums
+     * @param k
+     * @return
+     */
+    public static List<Integer> topKFrequent(int[] nums, int k) {
+        Map<Integer, Integer> numCount = new HashMap<>();
+        PriorityQueue<Pair<Integer, Integer>> pq = new PriorityQueue<>(Comparator.comparing(Pair::getValue));
+
+        for (int num : nums) {
+            numCount.put(num, numCount.getOrDefault(num, 0) + 1);
+        }
+
+        for (Map.Entry<Integer, Integer> entry : numCount.entrySet()) {
+            pq.add(new Pair<>(entry.getKey(), entry.getValue()));
+
+            if (pq.size() > k) {
+                pq.poll();
+            }
+        }
+
+        return pq.stream().map(Pair::getKey).collect(Collectors.toList());
+    }
+
+    public static void main(String[] args) {
+        assertEquals("[2, 1]", topKFrequent(new int[]{1, 1, 1, 2, 2, 3}, 2).toString());
+        assertEquals("[0]", topKFrequent(new int[]{3, 0, 1, 0}, 1).toString());
+        assertEquals("[1]", topKFrequent(new int[]{1}, 1).toString());
+        assertEquals("[1, 2]", topKFrequent(new int[]{1, 2}, 2).toString());
+        assertEquals("[2, -1]", topKFrequent(new int[]{4, 1, -1, 2, -1, 2, 3}, 2).toString());
+    }
+}