add a solution for 128

fishercoder1534 · fishercoder1534 · commit 371853287eb0 · 2021-11-05T07:12:25.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_128.java b/src/main/java/com/fishercoder/solutions/_128.java
@@ -2,8 +2,10 @@
 
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeSet;
 
 public class _128 {
     public static class Solution1 {
@@ -104,19 +106,22 @@ public int longestConsecutive(int[] nums) {
     }
 
     public static class Solution3 {
+        /**
+         * O(n) time complexity.
+         */
         public int longestConsecutive(int[] nums) {
-            HashSet<Integer> numSet = new HashSet<>();
+            Set<Integer> set = new HashSet<>();
             for (int num : nums) {
-                numSet.add(num);
+                set.add(num);
             }
 
             int longestStreak = 0;
-            for (int num : nums) {
-                if (!numSet.contains(num - 1)) {
+            for (int num : set) {//we'll go through this set instead of nums, this makes a big difference in time complexity, esp. based on LeetCode test cases
+                if (!set.contains(num - 1)) {
                     int currentNum = num;
                     int currentStreak = 1;
 
-                    while (numSet.contains(currentNum + 1)) {
+                    while (set.contains(currentNum + 1)) {
                         currentNum += 1;
                         currentStreak += 1;
                     }
@@ -126,4 +131,35 @@ public int longestConsecutive(int[] nums) {
             return longestStreak;
         }
     }
+
+    public static class Solution4 {
+        /**
+         * O(nlogn) time complexity
+         */
+        public int longestConsecutive(int[] nums) {
+            if (nums.length == 0) {
+                return 0;
+            }
+            TreeSet<Integer> treeSet = new TreeSet<>();
+            for (int i : nums) {
+                treeSet.add(i);//O(logn) time complexity for each add() call
+            }
+            int ans = 1;
+            Iterator<Integer> it = treeSet.iterator();
+            Integer curr = it.next();
+            int len = 1;
+            while (it.hasNext()) {
+                Integer next = it.next();
+                if (curr + 1 == next) {
+                    len++;
+                } else {
+                    len = 1;
+                }
+                curr = next;
+                ans = Math.max(ans, len);
+            }
+            ans = Math.max(ans, len);
+            return ans;
+        }
+    }
 }
diff --git a/src/test/java/com/fishercoder/_128Test.java b/src/test/java/com/fishercoder/_128Test.java
@@ -8,16 +8,19 @@
 
 public class _128Test {
     private static _128.Solution3 solution3;
+    private static _128.Solution4 solution4;
     private static int[] nums;
 
     @BeforeClass
     public static void setup() {
         solution3 = new _128.Solution3();
+        solution4 = new _128.Solution4();
     }
 
     @Test
     public void test1() {
         nums = new int[]{100, 4, 200, 1, 3, 2};
         assertEquals(4, solution3.longestConsecutive(nums));
+        assertEquals(4, solution4.longestConsecutive(nums));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -8,16 +8,19 @@`
`8`	`8`
`9`	`9`	`public class _128Test {`
`10`	`10`	`private static _128.Solution3 solution3;`
	`11`	`+ private static _128.Solution4 solution4;`
`11`	`12`	`private static int[] nums;`
`12`	`13`
`13`	`14`	`@BeforeClass`
`14`	`15`	`public static void setup() {`
`15`	`16`	`solution3 = new _128.Solution3();`
	`17`	`+ solution4 = new _128.Solution4();`
`16`	`18`	`}`
`17`	`19`
`18`	`20`	`@Test`
`19`	`21`	`public void test1() {`
`20`	`22`	`nums = new int[]{100, 4, 200, 1, 3, 2};`
`21`	`23`	`assertEquals(4, solution3.longestConsecutive(nums));`
	`24`	`+ assertEquals(4, solution4.longestConsecutive(nums));`
`22`	`25`	`}`
`23`	`26`	`}`