Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 83d6171

Browse files
feat: update solutions to lc problem: No.0496 (#3797)
No.0496.Next Greater Element I
1 parent f1b58d0 commit 83d6171

File tree

15 files changed

+250
-580
lines changed

15 files changed

+250
-580
lines changed

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

Lines changed: 81 additions & 211 deletions
Original file line numberDiff line numberDiff line change
@@ -72,19 +72,13 @@ tags:
7272

7373
### 方法一:单调栈
7474

75-
单调栈常见模型:找出每个数左/右边**离它最近的**且**比它大/小的数**。模板:
75+
我们可以从右往左遍历数组 $\textit{nums2},ドル维护一个从栈顶到栈底单调递增的栈 $\textit{stk},ドル并且用哈希表 $\textit{d}$ 记录每个元素的下一个更大元素。
7676

77-
```python
78-
stk = []
79-
for i in range(n):
80-
while stk and check(stk[-1], i):
81-
stk.pop()
82-
stk.append(i)
83-
```
77+
遍历到元素 $x$ 时,如果栈不为空且栈顶元素小于 $x,ドル我们就不断弹出栈顶元素,直到栈为空或者栈顶元素大于等于 $x$。此时,如果栈不为空,栈顶元素就是 $x$ 的下一个更大元素,否则 $x$ 没有下一个更大元素。
8478

85-
对于本题,先对将 `nums2` 中的每一个元素,求出其下一个更大的元素。随后对于将这些答案放入哈希表 $m$ 中,再遍历数组 `nums1`,并直接找出答案。对于 `nums2`,可以使用单调栈来解决这个问题。
79+
最后我们遍历数组 $\textit{nums1},ドル根据哈希表 $\textit{d}$ 得到答案。
8680

87-
时间复杂度 $O(M+N),ドル其中 $M$ 和 $N$ 分别为数组 `nums1` 和 `nums2` 的长度。
81+
时间复杂度 $O(m + n),ドル空间复杂度 $O(n)$。其中 $m$ 和 $n$ 分别为数组 $\textit{nums1}$ 和 $\textit{nums2}$ 的长度。
8882

8983
<!-- tabs:start -->
9084

@@ -93,13 +87,15 @@ for i in range(n):
9387
```python
9488
class Solution:
9589
def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
96-
m = {}
9790
stk = []
98-
for v in nums2:
99-
while stk and stk[-1] < v:
100-
m[stk.pop()] = v
101-
stk.append(v)
102-
return [m.get(v, -1) for v in nums1]
91+
d = {}
92+
for x in nums2[::-1]:
93+
while stk and stk[-1] < x:
94+
stk.pop()
95+
if stk:
96+
d[x] = stk[-1]
97+
stk.append(x)
98+
return [d.get(x, -1) for x in nums1]
10399
```
104100

105101
#### Java
@@ -108,17 +104,21 @@ class Solution:
108104
class Solution {
109105
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
110106
Deque<Integer> stk = new ArrayDeque<>();
111-
Map<Integer, Integer> m = new HashMap<>();
112-
for (int v : nums2) {
113-
while (!stk.isEmpty() && stk.peek() < v) {
114-
m.put(stk.pop(), v);
107+
int m = nums1.length, n = nums2.length;
108+
Map<Integer, Integer> d = new HashMap(n);
109+
for (int i = n - 1; i >= 0; --i) {
110+
int x = nums2[i];
111+
while (!stk.isEmpty() && stk.peek() < x) {
112+
stk.pop();
113+
}
114+
if (!stk.isEmpty()) {
115+
d.put(x, stk.peek());
115116
}
116-
stk.push(v);
117+
stk.push(x);
117118
}
118-
int n = nums1.length;
119-
int[] ans = new int[n];
120-
for (int i = 0; i < n; ++i) {
121-
ans[i] = m.getOrDefault(nums1[i], -1);
119+
int[] ans = new int[m];
120+
for (int i = 0; i < m; ++i) {
121+
ans[i] = d.getOrDefault(nums1[i], -1);
122122
}
123123
return ans;
124124
}
@@ -132,16 +132,21 @@ class Solution {
132132
public:
133133
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
134134
stack<int> stk;
135-
unordered_map<int, int> m;
136-
for (int& v : nums2) {
137-
while (!stk.empty() && stk.top() < v) {
138-
m[stk.top()] = v;
135+
unordered_map<int, int> d;
136+
ranges::reverse(nums2);
137+
for (int x : nums2) {
138+
while (!stk.empty() && stk.top() < x) {
139139
stk.pop();
140140
}
141-
stk.push(v);
141+
if (!stk.empty()) {
142+
d[x] = stk.top();
143+
}
144+
stk.push(x);
142145
}
143146
vector<int> ans;
144-
for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1);
147+
for (int x : nums1) {
148+
ans.push_back(d.contains(x) ? d[x] : -1);
149+
}
145150
return ans;
146151
}
147152
};
@@ -150,41 +155,44 @@ public:
150155
#### Go
151156
152157
```go
153-
func nextGreaterElement(nums1 []int, nums2 []int) []int {
158+
func nextGreaterElement(nums1 []int, nums2 []int) (ans []int) {
154159
stk := []int{}
155-
m := map[int]int{}
156-
for _, v := range nums2 {
157-
for len(stk) > 0 && stk[len(stk)-1] < v {
158-
m[stk[len(stk)-1]] = v
160+
d := map[int]int{}
161+
for i := len(nums2) - 1; i >= 0; i-- {
162+
x := nums2[i]
163+
for len(stk) > 0 && stk[len(stk)-1] < x {
159164
stk = stk[:len(stk)-1]
160165
}
161-
stk = append(stk, v)
166+
if len(stk) > 0 {
167+
d[x] = stk[len(stk)-1]
168+
}
169+
stk = append(stk, x)
162170
}
163-
var ans []int
164-
for _, v := range nums1 {
165-
val, ok := m[v]
166-
if !ok {
167-
val = -1
171+
for _, x := range nums1 {
172+
if v, ok := d[x]; ok {
173+
ans = append(ans, v)
174+
} else {
175+
ans = append(ans, -1)
168176
}
169-
ans = append(ans, val)
170177
}
171-
return ans
178+
return
172179
}
173180
```
174181

175182
#### TypeScript
176183

177184
```ts
178185
function nextGreaterElement(nums1: number[], nums2: number[]): number[] {
179-
const map =newMap<number, number>();
180-
const stack:number[] = [Infinity];
181-
for (const num of nums2) {
182-
while (num>stack[stack.length -1]) {
183-
map.set(stack.pop(), num);
186+
const stk:number[] = [];
187+
const d:Record<number, number> = {};
188+
for (const x of nums2.reverse()) {
189+
while (stk.length &&stk.at(-1)!<x) {
190+
stk.pop();
184191
}
185-
stack.push(num);
192+
d[x] = stk.length ? stk.at(-1)! : -1;
193+
stk.push(x);
186194
}
187-
return nums1.map(num => map.get(num) ||-1);
195+
return nums1.map(x => d[x]);
188196
}
189197
```
190198

@@ -195,162 +203,26 @@ use std::collections::HashMap;
195203

196204
impl Solution {
197205
pub fn next_greater_element(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
198-
let mut map = HashMap::new();
199-
let mut stack = Vec::new();
200-
for num in nums2 {
201-
while num > *stack.last().unwrap_or(&i32::MAX) {
202-
map.insert(stack.pop().unwrap(), num);
203-
}
204-
stack.push(num);
205-
}
206-
nums1
207-
.iter()
208-
.map(|n| *map.get(n).unwrap_or(&-1))
209-
.collect::<Vec<i32>>()
210-
}
211-
}
212-
```
213-
214-
#### JavaScript
215-
216-
```js
217-
/**
218-
* @param {number[]} nums1
219-
* @param {number[]} nums2
220-
* @return {number[]}
221-
*/
222-
var nextGreaterElement = function (nums1, nums2) {
223-
let stk = [];
224-
let m = {};
225-
for (let v of nums2) {
226-
while (stk && stk[stk.length - 1] < v) {
227-
m[stk.pop()] = v;
228-
}
229-
stk.push(v);
230-
}
231-
return nums1.map(e => m[e] || -1);
232-
};
233-
```
234-
235-
<!-- tabs:end -->
236-
237-
<!-- solution:end -->
238-
239-
<!-- solution:start -->
240-
241-
### 方法二
242-
243-
<!-- tabs:start -->
244-
245-
#### Python3
246-
247-
```python
248-
class Solution:
249-
def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
250-
m = {}
251-
stk = []
252-
for v in nums2[::-1]:
253-
while stk and stk[-1] <= v:
254-
stk.pop()
255-
if stk:
256-
m[v] = stk[-1]
257-
stk.append(v)
258-
return [m.get(x, -1) for x in nums1]
259-
```
260-
261-
#### Java
262-
263-
```java
264-
class Solution {
265-
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
266-
Deque<Integer> stk = new ArrayDeque<>();
267-
Map<Integer, Integer> m = new HashMap<>();
268-
for (int i = nums2.length - 1; i >= 0; --i) {
269-
while (!stk.isEmpty() && stk.peek() <= nums2[i]) {
270-
stk.pop();
206+
let mut stk = Vec::new();
207+
let mut d = HashMap::new();
208+
for &x in nums2.iter().rev() {
209+
while let Some(&top) = stk.last() {
210+
if top <= x {
211+
stk.pop();
212+
} else {
213+
break;
214+
}
271215
}
272-
if (!stk.isEmpty()) {
273-
m.put(nums2[i], stk.peek());
216+
if letSome(&top) =stk.last() {
217+
d.insert(x, top);
274218
}
275-
stk.push(nums2[i]);
219+
stk.push(x);
276220
}
277-
int n = nums1.length;
278-
int[] ans = new int[n];
279-
for (int i = 0; i < n; ++i) {
280-
ans[i] = m.getOrDefault(nums1[i], -1);
281-
}
282-
return ans;
283-
}
284-
}
285-
```
286-
287-
#### C++
288221

289-
```cpp
290-
class Solution {
291-
public:
292-
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
293-
stack<int> stk;
294-
unordered_map<int, int> m;
295-
for (int i = nums2.size() - 1; ~i; --i) {
296-
while (!stk.empty() && stk.top() <= nums2[i]) stk.pop();
297-
if (!stk.empty()) m[nums2[i]] = stk.top();
298-
stk.push(nums2[i]);
299-
}
300-
vector<int> ans;
301-
for (int& v : nums1) ans.push_back(m.count(v) ? m[v] : -1);
302-
return ans;
303-
}
304-
};
305-
```
306-
307-
#### Go
308-
309-
```go
310-
func nextGreaterElement(nums1 []int, nums2 []int) []int {
311-
stk := []int{}
312-
m := map[int]int{}
313-
for i := len(nums2) - 1; i >= 0; i-- {
314-
for len(stk) > 0 && stk[len(stk)-1] <= nums2[i] {
315-
stk = stk[:len(stk)-1]
316-
}
317-
if len(stk) > 0 {
318-
m[nums2[i]] = stk[len(stk)-1]
319-
}
320-
stk = append(stk, nums2[i])
321-
}
322-
var ans []int
323-
for _, v := range nums1 {
324-
val, ok := m[v]
325-
if !ok {
326-
val = -1
327-
}
328-
ans = append(ans, val)
329-
}
330-
return ans
331-
}
332-
```
333-
334-
#### Rust
335-
336-
```rust
337-
impl Solution {
338-
pub fn next_greater_element(nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
339222
nums1
340-
.iter()
341-
.map(|target| {
342-
let mut res = -1;
343-
for num in nums2.iter().rev() {
344-
if num == target {
345-
break;
346-
}
347-
if num > target {
348-
res = *num;
349-
}
350-
}
351-
res
352-
})
353-
.collect::<Vec<i32>>()
223+
.into_iter()
224+
.map(|x| *d.get(&x).unwrap_or(&-1))
225+
.collect()
354226
}
355227
}
356228
```
@@ -364,18 +236,16 @@ impl Solution {
364236
* @return {number[]}
365237
*/
366238
var nextGreaterElement = function (nums1, nums2) {
367-
let stk = [];
368-
let m = {};
369-
for (let v of nums2.reverse()) {
370-
while (stk && stk[stk.length-1] <= v) {
239+
const stk = [];
240+
constd = {};
241+
for (constx of nums2.reverse()) {
242+
while (stk.length && stk.at(-1) < x) {
371243
stk.pop();
372244
}
373-
if (stk) {
374-
m[v] = stk[stk.length - 1];
375-
}
376-
stk.push(v);
245+
d[x] = stk.length ? stk.at(-1) : -1;
246+
stk.push(x);
377247
}
378-
return nums1.map(e => m[e] ||-1);
248+
return nums1.map(x => d[x]);
379249
};
380250
```
381251

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /