[LEET-504] add 504

Author: fishercoder1534

leetcode-algorithms/README.md

@@ -35,6 +35,7 @@
 |506|[Relative Ranks](https://leetcode.com/problems/relative-ranks/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/RelativeRanks.java) | O(nlogn) |O(n) | Easy|
 |505|[The Maze II](https://leetcode.com/problems/the-maze-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/TheMazeII.java) | O(m*n) |O(m*n) | Medium| BFS
 |504|[Base 7](https://leetcode.com/problems/base-7/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/Base7.java) | O(1) |O(1) | Easy| 
+|503|[Next Greater Element II](https://leetcode.com/problems/next-greater-element-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/NextGreaterElementII.java) | O(n) |O(n) | Medium| Stack
 |501|[Find Mode in Binary Tree](https://leetcode.com/problems/find-mode-in-binary-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/FindModeinBinaryTree.java) | O(n) |O(k) | Easy| Binary Tree
 |500|[Keyboard Row](https://leetcode.com/problems/keyboard-row/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/KeyboardRow.java) | O(n) |O(1) | Easy|
 |499|[The Maze III](https://leetcode.com/problems/the-maze-iii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/TheMazeIII.java) | O(m*n) |O(m*n) | Hard| BFS

leetcode-algorithms/src/main/java/com/stevesun/solutions/NextGreaterElementII.java

@@ -0,0 +1,58 @@
+package com.stevesun.solutions;
+
+import java.util.Stack;
+
+/**
+ * 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,
+ * which means you could search circularly to find its next greater number. If it doesn't exist, output -1 for this number.
+
+ Example 1:
+ Input: [1,2,1]
+ Output: [2,-1,2]
+ Explanation: The first 1's next greater number is 2;
+ The number 2 can't find next greater number;
+ The second 1's next greater number needs to search circularly, which is also 2.
+ Note: The length of given array won't exceed 10000.
+ */
+public class NextGreaterElementII {
+
+    //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();
+            }
+            if (!stack.isEmpty()) {
+                result[i] = nums[stack.peek()];
+            }
+            stack.push(i);
+        }
+        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();
+            }
+            result[i%nums.length] = stack.isEmpty() ? -1 : nums[stack.peek()];
+            stack.push(i%nums.length);
+        }
+        return result;
+    }
+
+}

leetcode-algorithms/src/test/java/com/stevesun/NextGreaterElementIITest.java

@@ -0,0 +1,34 @@
+package com.stevesun;
+
+import com.stevesun.solutions.NextGreaterElementII;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class NextGreaterElementIITest {
+    private static NextGreaterElementII test;
+    private static int[] nums;
+    private static int[] expected;
+    private static int[] actual;
+
+    @BeforeClass
+    public static void setup(){
+        test = new NextGreaterElementII();
+    }
+
+    @Before
+    public void setupForEachTest(){
+        expected = new int[]{};
+        nums = new int[]{};
+    }
+
+    @Test
+    public void test1(){
+        nums = new int[]{1,2,1};
+        expected = new int[]{2, -1, 2};
+        actual = test.nextGreaterElements(nums);
+        assertArrayEquals(expected, actual);
+    }
+}