503-next-greater-element-ii.md Adjusted the Python code position.

gazeldx · gazeldx · commit d30ebe10ff5f · 2025-02-09T15:54:37.000+08:00
diff --git a/en/1-1000/503-next-greater-element-ii.md b/en/1-1000/503-next-greater-element-ii.md
@@ -28,7 +28,7 @@ Output: [2,3,4,-1,4]
 ------------------------------------------------------------------------------------
 ```
 
-## Solution 1
+## Solution 1: Brute Force
 This problem can be solved using **Brute Force**. But if the `nums.length` is much greater, the solution will time out.
 Then We need to use a more efficient algorithm.
 
@@ -38,11 +38,51 @@ Detailed solutions will be given later, and now only the best practices in 7 lan
 * Time: `O(n * n)`.
 * Space: `O(n)`.
 
-## Solution 2: More efficient algorithm via "Monotonic Stack"
+## Solution 2: Monotonic Stack Algorithm (more efficient)
 This solution will reduce the time complexity to **O(n)**.
 
-A similar issue is [Next Greater Element I](496-next-greater-element-i.md).
-You can read it first, then checkout the `Python` section for the code.
+A similar issue is [Next Greater Element I](496-next-greater-element-i.md), you can read it first.
+
+Checkout the `Python` section bellow to view the code.
+
+## Python
+### Solution 2: Monotonic Stack
+```python
+# This is a better test case:
+# [2, 5, 3, 2, 4, 1] for `nums`
+# [2, 5, 3, 2, 4, 1, 2, 5, 3, 2, 4] for `extended_nums`
+
+class Solution:
+    def nextGreaterElements(self, nums: List[int]) -> List[int]:
+        extended_nums = nums + nums[:-1]
+        index_stack = []
+        result = [-1] * len(extended_nums)
+
+        for i, num in enumerate(extended_nums):
+            while index_stack and extended_nums[index_stack[-1]] < num:
+                result[index_stack.pop()] = num
+
+            index_stack.append(i)
+
+        return result[:len(nums)]
+```
+
+### Solution 1: Brute Force
+```python
+class Solution:
+    def nextGreaterElements(self, nums: List[int]) -> List[int]:
+        results = [-1] * len(nums)
+        nums2 = nums + nums
+
+        for i, num1 in enumerate(nums):
+            for j in range(i + 1, len(nums2)):
+                if nums2[j] > num1:
+                    results[i] = nums2[j]
+                    break
+
+        return results
+```
+
 
 ## C#
 ```c#
@@ -71,44 +111,6 @@ public class Solution
 }
 ```
 
-## Python
-### Solution 1: Brute Force
-```python
-class Solution:
-    def nextGreaterElements(self, nums: List[int]) -> List[int]:
-        results = [-1] * len(nums)
-        nums2 = nums + nums
-
-        for i, num1 in enumerate(nums):
-            for j in range(i + 1, len(nums2)):
-                if nums2[j] > num1:
-                    results[i] = nums2[j]
-                    break
-
-        return results
-```
-
-### Solution 2: Monotonic Stack
-```python
-# This is a better test case:
-# [2, 5, 3, 2, 4, 1] for `nums`
-# [2, 5, 3, 2, 4, 1, 2, 5, 3, 2, 4] for `extended_nums`
-
-class Solution:
-    def nextGreaterElements(self, nums: List[int]) -> List[int]:
-        extended_nums = nums + nums[:-1]
-        index_stack = []
-        result = [-1] * len(extended_nums)
-
-        for i, num in enumerate(extended_nums):
-            while index_stack and extended_nums[index_stack[-1]] < num:
-                result[index_stack.pop()] = num
-
-            index_stack.append(i)
-
-        return result[:len(nums)]
-```
-
 ## Java
 ```java
 class Solution {
