Solve #451, #565

Author: rayworks

src/main/java/org/sean/array/NestingArray.java

@@ -0,0 +1,42 @@
+package org.sean.array;
+
+import java.util.*;
+
+/***
+ * 565. Array Nesting
+ *
+ * N is an integer within the range [1, 20,000].
+ * The elements of A are all distinct.
+ * Each element of A is an integer within the range [0, N-1].
+ */
+public class NestingArray {
+    public int arrayNesting(int[] nums) {
+        if (nums == null || nums.length == 0)
+            return 0;
+
+        int length = nums.length;
+        if (length == 1) {
+            return 1;
+        }
+
+        int max = 0;
+        Set<Integer> visitedPositions = new HashSet<>();
+
+        for (int i = 0; i < length; i++) {
+            if (!visitedPositions.contains(i)) {
+                int elem = nums[i];
+                int cnt = 0;
+                while (!visitedPositions.contains(elem)) {
+                    ++cnt;
+
+                    visitedPositions.add(elem);
+                    elem = nums[elem];
+                }
+
+                max = Math.max(max, cnt);
+            }
+        }
+
+        return max;
+    }
+}

src/main/java/org/sean/sorting/FrequencySort.java

@@ -0,0 +1,61 @@
+package org.sean.sorting;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+/***
+ * 451. Sort Characters By Frequency
+ */
+public class FrequencySort {
+    public String frequencySort(String s) {
+        if (s == null) {
+            return "";
+        }
+
+        int length = s.length();
+        if (length <= 1) {
+            return s;
+        }
+
+        PriorityQueue<String> queue = new PriorityQueue<>(new Comparator<String>() {
+            @Override
+            public int compare(String o1, String o2) { //5@a, 7@b
+                int length2 = o2.length();
+                int length1 = o1.length();
+                if(length2 > length1) {
+                    return 1;
+                } else if(length2 < length1) {
+                    return -1;
+                }
+                return o2.compareTo(o1);
+            }
+        });
+
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < length; i++) {
+            char ch = s.charAt(i);
+            if (map.containsKey(ch)) {
+                map.put(ch, map.get(ch) + 1);
+            } else {
+                map.put(ch, 1);
+            }
+        }
+
+        for (Character key : map.keySet()) {
+            queue.add(map.get(key) + "," + key);
+        }
+
+        StringBuilder builder = new StringBuilder();
+        while (!queue.isEmpty()) {
+            String str = queue.poll();
+            String[] strs = str.split(",");
+            int n = Integer.parseInt(strs[0]);
+            for (int j = 0; j < n; j++) {
+                builder.append(strs[1]);
+            }
+        }
+        return builder.toString();
+    }
+}

src/test/java/org/sean/array/NestingArrayTest.java

@@ -0,0 +1,16 @@
+package org.sean.array;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class NestingArrayTest {
+
+    @Test
+    public void arrayNesting() {
+        NestingArray array = new NestingArray();
+        int len = array.arrayNesting(new int[]{5, 4, 0, 3, 1, 6, 2});
+        Assert.assertEquals(4, len);
+    }
+}