Top 'K' Numbers

Author: manastalukdar

.vscode/settings.json

@@ -168,6 +168,7 @@
     "Techer",
     "Tencent",
     "Thakur",
+    "Timsort",
     "Tushar",
     "Tweety",
     "Twilio",

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/TopKNumbers/Java/Solution.java

@@ -0,0 +1,36 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.TopKNumbers.Java;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public static void main(String[] args) {
+        List<Integer> result = findKLargestNumbers(new int[] {3, 1, 5, 12, 2, 11}, 3);
+        System.out.println("Here are the top K numbers: " + result);
+
+        result = findKLargestNumbers(new int[] {5, 12, 11, -1, 12}, 3);
+        System.out.println("Here are the top K numbers: " + result);
+    }
+
+    public static List<Integer> findKLargestNumbers(int[] nums, int k) {
+        PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>((n1, n2) -> n1 - n2);
+        // put first 'K' numbers in the min heap
+        for (int i = 0; i < k; i++)
+            minHeap.add(nums[i]);
+
+        // go through the remaining numbers of the array, if the number from the array is bigger
+        // than the
+        // top (smallest) number of the min-heap, remove the top number from heap and add the number
+        // from array
+        for (int i = k; i < nums.length; i++) {
+            if (nums[i] > minHeap.peek()) {
+                minHeap.poll();
+                minHeap.add(nums[i]);
+            }
+        }
+
+        // the heap has the top 'K' numbers, return them in a list
+        return new ArrayList<>(minHeap);
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/TopKNumbers/Java/SolutionTest.java

@@ -0,0 +1,55 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.TopKNumbers.Java;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
+public class SolutionTest {
+
+    Solution solution;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        solution = new Solution();
+    }
+
+    @AfterEach
+    public void tearDown() throws Exception {
+        solution = null;
+    }
+
+    @Test
+    public void MainFunction() {
+        assertTimeout(Duration.ofMillis(500), () -> {
+            String[] args = new String[0];
+            assertAll(() -> Solution.main(args));
+        });
+    }
+
+    @Test
+    public void TrivialCase1() {
+        int[] nums = new int[] {3, 1, 5, 12, 2, 11};
+        int k = 3;
+        assertTimeout(Duration.ofMillis(500), () -> {
+            List<Integer> expected = Arrays.asList(5, 12, 11);
+            List<Integer> actual = Solution.findKLargestNumbers(nums, k);
+            assertEquals(expected, actual);
+        });
+    }
+
+    @Test
+    public void TrivialCase2() {
+        int[] nums = new int[] {5, 12, 11, -1, 12};
+        int k = 3;
+        assertTimeout(Duration.ofMillis(500), () -> {
+            List<Integer> expected = Arrays.asList(11, 12, 12);
+            List<Integer> actual = Solution.findKLargestNumbers(nums, k);
+            assertEquals(expected, actual);
+        });
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/TopKNumbers/metadata.json

@@ -0,0 +1,33 @@
+{
+    "type": "Coding",
+    "name": "Top 'K' Numbers",
+    "origin": {
+        "name": "Educative",
+        "link": "https://www.educative.io/courses/grokking-the-coding-interview/RM535yM9DW0"
+    },
+    "companies": ["", ""],
+    "categories": [{
+            "name": "Courses",
+            "children": [{
+                "name": "Grokking the Coding Interview: Patterns for Coding Questions",
+                "children": []
+            }]
+        },
+        {
+            "name": "Difficulty",
+            "children": [{
+                "name": "Easy",
+                "children": []
+            }]
+        },
+        {
+            "name": "Pattern",
+            "children": [{
+                "name": "Top K Elements",
+                "children": []
+            }]
+        }
+    ],
+    "tags": ["Top K Elements"],
+    "buckets": []
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/TopKNumbers/readme.md

@@ -0,0 +1,59 @@
+# Problem Definition
+
+## Description
+
+Given an unsorted array of numbers, find the ‘K’ largest numbers in it.
+
+Note: For a detailed discussion about different approaches to solve this problem, take a look at **Kth Smallest Number**.
+
+Example 1:
+
+```plaintext
+Input: [3, 1, 5, 12, 2, 11], K = 3
+Output: [5, 12, 11]
+```
+
+Example 2:
+
+```plaintext
+Input: [5, 12, 11, -1, 12], K = 3
+Output: [12, 11, 12]
+```
+
+## Discussion
+
+A brute force solution could be to sort the array and return the largest K numbers. The time complexity of such an algorithm will be O(N*logN as we need to use a sorting algorithm like [Timsort](https://en.wikipedia.org/wiki/Timsort) if we use Java’s `Collection.sort()`.
+
+The best data structure that comes to mind to keep track of top ‘K’ elements is [Heap](https://en.wikipedia.org/wiki/Heap_(data_structure)). Let’s see if we can use a heap to find a better algorithm.
+
+If we iterate through the array one element at a time and keep ‘K’ largest numbers in a heap such that each time we find a larger number than the smallest number in the heap, we do two things:
+
+1. Take out the smallest number from the heap, and
+2. Insert the larger number into the heap.
+
+This will ensure that we always have ‘K’ largest numbers in the heap. The most efficient way to repeatedly find the smallest number among a set of numbers will be to use a min-heap. As we know, we can find the smallest number in a min-heap in constant time O(1), since the smallest number is always at the root of the heap. Extracting the smallest number from a min-heap will take O(logN) (if the heap has ‘N’ elements) as the heap needs to readjust after the removal of an element.
+
+Let’s take Example-1 to go through each step of our algorithm:
+
+Given array: [3, 1, 5, 12, 2, 11], and K=3
+
+1. First, let’s insert ‘K’ elements in the min-heap.
+2. After the insertion, the heap will have three numbers [3, 1, 5] with ‘1’ being the root as it is the smallest element.
+3. We’ll iterate through the remaining numbers and perform the above-mentioned two steps if we find a number larger than the root of the heap.
+4. The 4th number is ‘12’ which is larger than the root (which is ‘1’), so let’s take out ‘1’ and insert ‘12’. Now the heap will have [3, 5, 12] with ‘3’ being the root as it is the smallest element.
+5. The 5th number is ‘2’ which is not bigger than the root of the heap (‘3’), so we can skip this as we already have top three numbers in the heap.
+6. The last number is ‘11’ which is bigger than the root (which is ‘3’), so let’s take out ‘3’ and insert ‘11’. Finally, the heap has the largest three numbers: [5, 12, 11]
+
+It will take us O(logK) to extract the minimum number from the min-heap. So the overall time complexity of our algorithm will be O(K\*logK+(N-K)\*logK) since, first, we insert ‘K’ numbers in the heap and then iterate through the remaining numbers and at every step, in the worst case, we need to extract the minimum number and insert a new number in the heap. This algorithm is better than O(N*logN).
+
+### Time Complexity
+
+The time complexity of this algorithm is O(K\*logK+(N-K)\*logK), which is asymptotically equal to O(N*logK)
+
+### Space Complexity
+
+The space complexity will be O(K) since we need to store the top ‘K’ numbers in the heap.
+
+## Notes
+
+## References

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/_Introduction/readme.md

@@ -0,0 +1,5 @@
+# Introduction
+
+Any problem that asks us to find the top/smallest/frequent ‘K’ elements among a given set falls under this pattern.
+
+The best data structure that comes to mind to keep track of ‘K’ elements is [Heap](https://en.wikipedia.org/wiki/Heap_(data_structure)). This pattern will make use of the Heap to solve multiple problems dealing with ‘K’ elements at a time from a set of given elements.