LeetCode 347: Top K Frequent Elements

Author: DimkaGorhover

src/main/java/org/gd/leetcode/p0215/Solution.java

@@ -0,0 +1,29 @@
+package org.gd.leetcode.p0215;
+
+import org.gd.leetcode.common.LeetCode;
+
+/**
+ * https://leetcode.com/problems/kth-largest-element-in-an-array/
+ *
+ * @author Horkhover Dmytro
+ * @see org.gd.leetcode.p0347.Solution
+ * @see org.gd.leetcode.p0692.Solution
+ * @see org.gd.leetcode.p0973.Solution
+ * @since 2020-08-10
+ */
+@SuppressWarnings("JavadocReference")
+@LeetCode(
+        name = "Kth Largest Element in an Array",
+        difficulty = LeetCode.Level.MEDIUM,
+        state = LeetCode.State.TODO,
+        tags = {
+                LeetCode.Tags.DIVIDE_AND_CONQUER,
+                LeetCode.Tags.HEAP
+        }
+)
+class Solution {
+
+    public int findKthLargest(int[] nums, int k) {
+        throw new UnsupportedOperationException(new String(new char[]{175, 92, 95, 40, 12_484, 41, 95, 47, 175}));
+    }
+}

src/main/java/org/gd/leetcode/p0347/LinkedListSolution.java

@@ -0,0 +1,199 @@
+package org.gd.leetcode.p0347;
+
+import java.util.*;
+
+/**
+ * @author Horkhover Dmytro
+ * @see SortSolution
+ * @since 2020-08-10
+ */
+class LinkedListSolution implements Solution {
+
+    private CountNode head, tail;
+
+    public int[] topKFrequent(final int[] nums, final int k) {
+
+        if (nums == null || nums.length == 0)
+            return nums;
+
+        head = tail = new CountNode(-1);
+        CountNode.connect(head, tail);
+        head.insertRight(new CountNode(0));
+
+        Map<Integer, Node> nodeMap = new HashMap<>(nums.length);
+
+        for (int num : nums) {
+
+            Node node = nodeMap.get(num);
+            if (node == null) {
+
+                node = new Node(num);
+                head.next(0).add(node);
+                nodeMap.putIfAbsent(num, node);
+
+            } else {
+
+                CountNode parent = node.parent;
+                node.unlink();
+                parent.next().add(node);
+                if (parent.isEmpty())
+                    parent.unlink();
+            }
+        }
+
+        int i = 0;
+        int[] result = new int[Math.min(k, nodeMap.size())];
+        Iterator<Node> iterator = new DownIterator(tail);
+        while (iterator.hasNext() && i < result.length)
+            result[i++] = iterator.next().value;
+
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        StringJoiner sj = new StringJoiner(", ", "[", "]");
+        CountNode next = head.next;
+        while (next != tail) {
+            sj.add(next.toString());
+            next = next.next;
+        }
+        return sj.toString();
+    }
+
+    static class CountNode {
+        final int count;
+        CountNode prev, next;
+        Node head, tail;
+
+        CountNode(int count) {
+            this.count = count;
+            head = tail = new Node(-1, this);
+            Node.connect(head, tail);
+        }
+
+        static void connect(CountNode prev, CountNode next) {
+            if (prev != null)
+                prev.next = next;
+            if (next != null)
+                next.prev = prev;
+        }
+
+        boolean isEmpty() {
+            return head.next == tail;
+        }
+
+        CountNode next() {
+            return next(count + 1);
+        }
+
+        CountNode next(int count) {
+            if (next.count == count)
+                return next;
+
+            CountNode next = new CountNode(count);
+            insertRight(next);
+            return next;
+        }
+
+        void insertRight(CountNode node) {
+            connect(node, next);
+            connect(this, node);
+        }
+
+        void add(Node node) {
+            node.parent = this;
+            head.insertRight(node);
+        }
+
+        void unlink() {
+            connect(prev, next);
+            prev = null;
+            next = null;
+        }
+
+        @Override
+        public String toString() {
+            StringJoiner sj = new StringJoiner(", ", count + " -> [", "]");
+            Node next = head.next;
+            while (next != tail) {
+                sj.add("" + next.value);
+                next = next.next;
+            }
+            return sj.toString();
+        }
+    }
+
+    static class Node {
+
+        final int value;
+        CountNode parent;
+        Node prev, next;
+
+        Node(int value) {
+            this.value = value;
+        }
+
+        Node(int value, CountNode parent) {
+            this.value = value;
+            this.parent = parent;
+        }
+
+        static void connect(Node prev, Node next) {
+            if (prev != null)
+                prev.next = next;
+            if (next != null)
+                next.prev = prev;
+        }
+
+        void insertRight(Node node) {
+            node.parent = parent;
+            Node next = this.next;
+            connect(this, node);
+            connect(node, next);
+        }
+
+        void unlink() {
+            connect(prev, next);
+            prev = null;
+            next = null;
+            parent = null;
+        }
+    }
+
+    static class DownIterator implements Iterator<Node> {
+
+        CountNode countNode;
+        Node node = null;
+
+        DownIterator(CountNode countNode) {
+            this.countNode = countNode;
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (countNode == null)
+                return false;
+
+            if (node == null)
+                node = countNode.tail.prev;
+
+            if (node != countNode.head)
+                return true;
+
+            node = null;
+            countNode = countNode.prev;
+            return hasNext();
+        }
+
+        @Override
+        public Node next() {
+            if (!hasNext())
+                throw new NoSuchElementException();
+
+            Node value = this.node;
+            this.node = this.node.prev;
+            return value;
+        }
+    }
+}

src/main/java/org/gd/leetcode/p0347/Solution.java

@@ -0,0 +1,25 @@
+package org.gd.leetcode.p0347;
+
+import org.gd.leetcode.common.LeetCode;
+
+/**
+ * @author Horkhover Dmytro
+ * @see org.gd.leetcode.p0215.Solution
+ * @see org.gd.leetcode.p0692.Solution
+ * @see org.gd.leetcode.p0973.Solution
+ * @since 2020-08-10
+ */
+@SuppressWarnings("JavadocReference")
+@LeetCode(
+        name = "Top K Frequent Elements",
+        difficulty = LeetCode.Level.MEDIUM,
+        state = LeetCode.State.DONE,
+        tags = {
+                LeetCode.Tags.HASH_TABLE,
+                LeetCode.Tags.HEAP
+        }
+)
+interface Solution {
+
+    int[] topKFrequent(int[] nums, int k);
+}

src/main/java/org/gd/leetcode/p0347/SortSolution.java

@@ -0,0 +1,32 @@
+package org.gd.leetcode.p0347;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author Horkhover Dmytro
+ * @see LinkedListSolution
+ * @since 2020-08-10
+ */
+class SortSolution implements Solution {
+
+    public int[] topKFrequent(int[] nums, int k) {
+
+        Integer[] arr = new Integer[nums.length];
+        Map<Integer, Integer> counts = new HashMap<>();
+        int length = 0;
+
+        for (int num : nums)
+            if (counts.compute(num, (ignored, c) -> 1 + (c == null ? 0 : c)) == 1)
+                arr[length++] = num;
+
+        Arrays.sort(arr, 0, length, (o1, o2) -> Integer.compare(counts.get(o2), counts.get(o1)));
+
+        int[] result = new int[Math.min(length, k)];
+        for (int i = 0; i < result.length; i++)
+            result[i] = arr[i];
+
+        return result;
+    }
+}

src/main/java/org/gd/leetcode/p0692/Solution.java

@@ -8,8 +8,11 @@
  * https://leetcode.com/problems/top-k-frequent-words/
  *
  * @author Horkhover Dmytro
+ * @see org.gd.leetcode.p0347.Solution
+ * @see org.gd.leetcode.p0973.Solution
  * @since 2020-08-09
  */
+@SuppressWarnings("JavadocReference")
 @LeetCode(
         name = "Top K Frequent Words",
         difficulty = LeetCode.Level.MEDIUM,

src/main/java/org/gd/leetcode/p0973/Solution.java

@@ -0,0 +1,29 @@
+package org.gd.leetcode.p0973;
+
+import org.gd.leetcode.common.LeetCode;
+
+/**
+ * https://leetcode.com/problems/k-closest-points-to-origin/
+ *
+ * @author Horkhover Dmytro
+ * @see org.gd.leetcode.p0347.Solution
+ * @see org.gd.leetcode.p0692.Solution
+ * @since 2020-08-10
+ */
+@SuppressWarnings("JavadocReference")
+@LeetCode(
+        name = "K Closest Points to Origin",
+        difficulty = LeetCode.Level.MEDIUM,
+        state = LeetCode.State.TODO,
+        tags = {
+                LeetCode.Tags.HEAP,
+                LeetCode.Tags.SORT,
+                LeetCode.Tags.DIVIDE_AND_CONQUER
+        }
+)
+class Solution {
+
+    public int[][] kClosest(int[][] points, int K) {
+        throw new UnsupportedOperationException(new String(new char[]{175, 92, 95, 40, 12_484, 41, 95, 47, 175}));
+    }
+}

src/test/java/org/gd/leetcode/p0347/SolutionTest.java

@@ -0,0 +1,51 @@
+package org.gd.leetcode.p0347;
+
+import org.gd.common.CollectionUtils;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test for {@link Solution}
+ *
+ * @author Horkhover Dmytro
+ * @since 2020-08-10
+ */
+@DisplayName("LeetCode #347: Top K Frequent Elements")
+@Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
+class SolutionTest {
+
+    private static Stream<Arguments> args() {
+        return Stream.of(
+                Arguments.of(new int[]{1, 1, 2, 2, 3}, 2, new int[]{1, 2}),
+                Arguments.of(new int[]{1, 1, 1, 2, 2, 3}, 2, new int[]{1, 2})
+        );
+    }
+
+    private static List<Integer> listOf(int[] arr) {
+        Arrays.sort(arr);
+        return CollectionUtils.listOf(arr);
+    }
+
+    @ParameterizedTest
+    @MethodSource("args")
+    @DisplayName("O( N )")
+    void test_LinkedListSolution(int[] nums, int k, int[] expected) {
+        assertEquals(listOf(expected), listOf(new LinkedListSolution().topKFrequent(nums, k)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("args")
+    @DisplayName("O( N * Log(N) )")
+    void test_SortSolution(int[] nums, int k, int[] expected) {
+        assertEquals(listOf(expected), listOf(new SortSolution().topKFrequent(nums, k)));
+    }
+}