feat: add solutions to lc problem: No.0503. Next Greater Element II

Author: yanglbme

README.md

@@ -150,6 +150,8 @@
 - [最近的请求次数](/solution/0900-0999/0933.Number%20of%20Recent%20Calls/README.md)
 - [每日温度](/solution/0700-0799/0739.Daily%20Temperatures/README.md)
 - [基本计算器 II](/solution/0200-0299/0227.Basic%20Calculator%20II/README.md)
+- [下一个更大元素 I](/solution/0400-0499/0496.Next%20Greater%20Element%20I/README.md)
+- [下一个更大元素 II](/solution/0500-0599/0503.Next%20Greater%20Element%20II/README.md)
 
 ### 动态规划
 

README_EN.md

@@ -144,6 +144,8 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 - [Number of Recent Calls](/solution/0900-0999/0933.Number%20of%20Recent%20Calls/README_EN.md)
 - [Daily Temperatures](/solution/0700-0799/0739.Daily%20Temperatures/README_EN.md)
 - [Basic Calculator II](/solution/0200-0299/0227.Basic%20Calculator%20II/README_EN.md)
+- [Next Greater Element I](/solution/0400-0499/0496.Next%20Greater%20Element%20I/README_EN.md)
+- [Next Greater Element II](/solution/0500-0599/0503.Next%20Greater%20Element%20II/README_EN.md)
 
 ### Dynamic Programming
 

solution/0400-0499/0496.Next Greater Element I/README.md

@@ -109,14 +109,14 @@ class Solution {
  */
 var nextGreaterElement = function(nums1, nums2) {
     let stack = [];
-    let nextBigger = {};
+    let nextGreater = {};
     for (let num of nums2) {
-        while(stack.length > 0 && stack[stack.length - 1] < num) {
-            nextBigger[stack.pop()] = num;
+        while (stack.length > 0 && stack[stack.length - 1] < num) {
+            nextGreater[stack.pop()] = num;
         }
         stack.push(num);
     }
-    let res = nums1.map(d => nextBigger[d] || -1);
+    let res = nums1.map(d => nextGreater[d] || -1);
     return res;
 };
 ```

solution/0400-0499/0496.Next Greater Element I/README_EN.md

@@ -94,14 +94,14 @@ class Solution {
  */
 var nextGreaterElement = function(nums1, nums2) {
     let stack = [];
-    let nextBigger = {};
+    let nextGreater = {};
     for (let num of nums2) {
-        while(stack.length > 0 && stack[stack.length - 1] < num) {
-            nextBigger[stack.pop()] = num;
+        while (stack.length > 0 && stack[stack.length - 1] < num) {
+            nextGreater[stack.pop()] = num;
         }
         stack.push(num);
     }
-    let res = nums1.map(d => nextBigger[d] || -1);
+    let res = nums1.map(d => nextGreater[d] || -1);
     return res;
 };
 ```

solution/0400-0499/0496.Next Greater Element I/Solution.js

@@ -5,13 +5,13 @@
  */
  var nextGreaterElement = function(nums1, nums2) {
     let stack = [];
-    let nextBigger = {};
+    let nextGreater = {};
     for (let num of nums2) {
-        while(stack.length > 0 && stack[stack.length - 1] < num) {
-            nextBigger[stack.pop()] = num;
+        while (stack.length > 0 && stack[stack.length - 1] < num) {
+            nextGreater[stack.pop()] = num;
         }
         stack.push(num);
     }
-    let res = nums1.map(d => nextBigger[d] || -1);
+    let res = nums1.map(d => nextGreater[d] || -1);
     return res;
 };

solution/0500-0599/0503.Next Greater Element II/README.md

@@ -20,27 +20,51 @@
 
 <p><strong>注意:</strong> 输入数组的长度不会超过 10000。</p>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+“单调栈 + 循环数组”实现。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def nextGreaterElements(self, nums: List[int]) -> List[int]:
+        stack = []
+        n = len(nums)
+        res = [-1] * n
+        for i in range(n << 1):
+            while stack and nums[stack[-1]] < nums[i % n]:
+                res[stack.pop()] = nums[i % n]
+            stack.append(i % n)
+        return res
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int[] nextGreaterElements(int[] nums) {
+        int n = nums.length;
+        int[] res = new int[n];
+        Arrays.fill(res, -1);
+        Deque<Integer> stack = new ArrayDeque<>();
+        for (int i = 0; i < (n << 1); ++i) {
+            while (!stack.isEmpty() && nums[stack.peek()] < nums[i % n]) {
+                res[stack.pop()] = nums[i % n];
+            }
+            stack.push(i % n);
+        }
+        return res;
+    }
+}
 ```
 
 ### **...**

solution/0500-0599/0503.Next Greater Element II/README_EN.md

@@ -42,13 +42,36 @@ The second 1's next greater number needs to search circularly, which is also
 ### **Python3**
 
 ```python
-
+class Solution:
+    def nextGreaterElements(self, nums: List[int]) -> List[int]:
+        stack = []
+        n = len(nums)
+        res = [-1] * n
+        for i in range(n << 1):
+            while stack and nums[stack[-1]] < nums[i % n]:
+                res[stack.pop()] = nums[i % n]
+            stack.append(i % n)
+        return res
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public int[] nextGreaterElements(int[] nums) {
+        int n = nums.length;
+        int[] res = new int[n];
+        Arrays.fill(res, -1);
+        Deque<Integer> stack = new ArrayDeque<>();
+        for (int i = 0; i < (n << 1); ++i) {
+            while (!stack.isEmpty() && nums[stack.peek()] < nums[i % n]) {
+                res[stack.pop()] = nums[i % n];
+            }
+            stack.push(i % n);
+        }
+        return res;
+    }
+}
 ```
 
 ### **...**

solution/0500-0599/0503.Next Greater Element II/Solution.java

@@ -1,21 +1,15 @@
 class Solution {
     public int[] nextGreaterElements(int[] nums) {
         int n = nums.length;
-        int len = (n << 1) - 1;
         int[] res = new int[n];
+        Arrays.fill(res, -1);
         Deque<Integer> stack = new ArrayDeque<>();
-        for (int i = 0; i < len; ++i) {
-            int x = nums[i < n ? i : i - n];
-            while (!stack.isEmpty() && x > nums[stack.peek()]) {
-                res[stack.pop()] = x;
+        for (int i = 0; i < (n << 1); ++i) {
+            while (!stack.isEmpty() && nums[stack.peek()] < nums[i % n]) {
+                res[stack.pop()] = nums[i % n];
             }
-            if (i < n) {
-                stack.push(i);
-            }
-        }
-        while (!stack.isEmpty()) {
-            res[stack.pop()] = -1;
+            stack.push(i % n);
         }
         return res;
     }
-}
+}

solution/0500-0599/0503.Next Greater Element II/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def nextGreaterElements(self, nums: List[int]) -> List[int]:
+        stack = []
+        n = len(nums)
+        res = [-1] * n
+        for i in range(n << 1):
+            while stack and nums[stack[-1]] < nums[i % n]:
+                res[stack.pop()] = nums[i % n]
+            stack.append(i % n)
+        return res