refactor 503

fishercoder1534 · fishercoder1534 · commit ea5c918f5b9e · 2019-05-23T07:47:57.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_503.java b/src/main/java/com/fishercoder/solutions/_503.java
@@ -3,6 +3,8 @@
 import java.util.Stack;
 
 /**
+ * 503. Next Greater Element II
+ *
  * Given a circular array (the next element of the last element is the first element of the array),
  * print the Next Greater Number for every element.
  * The Next Greater Number of a number x is the first greater number to its traversing-order next in the array,
@@ -18,45 +20,53 @@
  */
 public class _503 {
 
-    //Credit: https://discuss.leetcode.com/topic/77881/typical-ways-to-solve-circular-array-problems-java-solution
-    //Note: we store INDEX into the stack, reversely, the larger index put at the bottom of the stack, the smaller index at the top
-    public int[] nextGreaterElements(int[] nums) {
-        if (nums == null || nums.length == 0) {
-            return nums;
-        }
-        int len = nums.length;
-        Stack<Integer> stack = new Stack<>();
-        for (int i = len - 1; i >= 0; i--) {
-            stack.push(i);
-            //push all indexes into the stack reversely
-        }
-        int[] result = new int[len];
-        for (int i = len - 1; i >= 0; i--) {
-            result[i] = -1;
-            //initialize it to be -1 in case we cannot find its next greater element in the array
-            while (!stack.isEmpty() && (nums[stack.peek()] <= nums[i])) {
-                stack.pop();
+    public static class Solution1 {
+        /**
+         * Credit: https://discuss.leetcode.com/topic/77881/typical-ways-to-solve-circular-array-problems-java-solution
+         * Note: we store INDEX into the stack, reversely, the larger index put at the bottom of the stack, the smaller index at the top
+         */
+        public int[] nextGreaterElements(int[] nums) {
+            if (nums == null || nums.length == 0) {
+                return nums;
+            }
+            int len = nums.length;
+            Stack<Integer> stack = new Stack<>();
+            for (int i = len - 1; i >= 0; i--) {
+                stack.push(i);
+                //push all indexes into the stack reversely
             }
-            if (!stack.isEmpty()) {
-                result[i] = nums[stack.peek()];
+            int[] result = new int[len];
+            for (int i = len - 1; i >= 0; i--) {
+                result[i] = -1;
+                //initialize it to be -1 in case we cannot find its next greater element in the array
+                while (!stack.isEmpty() && (nums[stack.peek()] <= nums[i])) {
+                    stack.pop();
+                }
+                if (!stack.isEmpty()) {
+                    result[i] = nums[stack.peek()];
+                }
+                stack.push(i);
             }
-            stack.push(i);
+            return result;
         }
-        return result;
     }
 
-    //credit: https://leetcode.com/articles/next-greater-element-ii/
-    public int[] nextGreaterElements_editorial_solution(int[] nums) {
-        int[] result = new int[nums.length];
-        Stack<Integer> stack = new Stack<>();
-        for (int i = nums.length * 2 - 1; i >= 0; i--) {
-            while (!stack.isEmpty() && nums[stack.peek()] <= nums[i % nums.length]) {
-                stack.pop();
+    public static class Solution2 {
+        /**
+         * credit: https://leetcode.com/articles/next-greater-element-ii/
+         */
+        public int[] nextGreaterElements(int[] nums) {
+            int[] result = new int[nums.length];
+            Stack<Integer> stack = new Stack<>();
+            for (int i = nums.length * 2 - 1; i >= 0; i--) {
+                while (!stack.isEmpty() && nums[stack.peek()] <= nums[i % nums.length]) {
+                    stack.pop();
+                }
+                result[i % nums.length] = stack.isEmpty() ? -1 : nums[stack.peek()];
+                stack.push(i % nums.length);
             }
-            result[i % nums.length] = stack.isEmpty() ? -1 : nums[stack.peek()];
-            stack.push(i % nums.length);
+            return result;
         }
-        return result;
     }
 
 }
diff --git a/src/test/java/com/fishercoder/_503Test.java b/src/test/java/com/fishercoder/_503Test.java
@@ -8,14 +8,16 @@
 import static org.junit.Assert.assertArrayEquals;
 
 public class _503Test {
-    private static _503 test;
+    private static _503.Solution1 solution1;
+    private static _503.Solution2 solution2;
     private static int[] nums;
     private static int[] expected;
     private static int[] actual;
 
     @BeforeClass
     public static void setup() {
-        test = new _503();
+        solution1 = new _503.Solution1();
+        solution2 = new _503.Solution2();
     }
 
     @Before
@@ -28,7 +30,10 @@ public void setupForEachTest() {
     public void test1() {
         nums = new int[]{1, 2, 1};
         expected = new int[]{2, -1, 2};
-        actual = test.nextGreaterElements(nums);
+        actual = solution1.nextGreaterElements(nums);
+        assertArrayEquals(expected, actual);
+
+        actual = solution2.nextGreaterElements(nums);
         assertArrayEquals(expected, actual);
     }
 }
