58
58
59
59
** 方法一:逆序遍历求右侧最大值**
60
60
61
- 逆序遍历数组 $height$ 每个元素 $v$,判断 $v$ 与右侧最大元素 $mx$ 的大小关系,若 $mx \lt v$,说明右侧所有元素都比当前元素小,当前位置能看到海景,加入结果数组 $ans$。
61
+ 我们逆序遍历数组 $height$ 每个元素 $v$,判断 $v$ 与右侧最大元素 $mx$ 的大小关系,若 $mx \lt v$,说明右侧所有元素都比当前元素小,当前位置能看到海景,加入结果数组 $ans$。然后我们更新 $mx$ 为 $v $。
62
62
63
- 最后逆序返回 $ans$。
63
+ 遍历结束后,逆序返回 $ans$ 即可 。
64
64
65
- 时间复杂度 $O(n)$,空间复杂度 $O(1)$。
65
+ 时间复杂度 $O(n)$,其中 $n$ 为数组长度。忽略答案数组的空间消耗, 空间复杂度 $O(1)$。
66
66
67
67
<!-- tabs:start -->
68
68
73
73
``` python
74
74
class Solution :
75
75
def findBuildings (self , heights : List[int ]) -> List[int ]:
76
- mx = 0
77
76
ans = []
77
+ mx = 0
78
78
for i in range (len (heights) - 1 , - 1 , - 1 ):
79
- v = heights[i]
80
- if mx < v:
79
+ if heights[i] > mx:
81
80
ans.append(i)
82
- mx = v
81
+ mx = heights[i]
83
82
return ans[::- 1 ]
84
83
```
85
84
@@ -90,16 +89,17 @@ class Solution:
90
89
``` java
91
90
class Solution {
92
91
public int [] findBuildings (int [] heights ) {
92
+ int n = heights. length;
93
+ List<Integer > ans = new ArrayList<> ();
93
94
int mx = 0 ;
94
- LinkedList<Integer > ans = new LinkedList<> ();
95
95
for (int i = heights. length - 1 ; i >= 0 ; -- i) {
96
- int v = heights[i];
97
- if (mx < v) {
98
- ans. addFirst(i);
99
- mx = v;
96
+ if (heights[i] > mx) {
97
+ ans. add(i);
98
+ mx = heights[i];
100
99
}
101
100
}
102
- return ans. stream(). mapToInt(i - > i). toArray();
101
+ Collections . reverse(ans);
102
+ return ans. stream(). mapToInt(Integer :: intValue). toArray();
103
103
}
104
104
}
105
105
```
@@ -110,13 +110,12 @@ class Solution {
110
110
class Solution {
111
111
public:
112
112
vector<int > findBuildings(vector<int >& heights) {
113
- int mx = 0;
114
113
vector<int > ans;
114
+ int mx = 0;
115
115
for (int i = heights.size() - 1; ~ i; --i) {
116
- int v = heights[ i] ;
117
- if (mx < v) {
116
+ if (heights[ i] > mx) {
118
117
ans.push_back(i);
119
- mx = v ;
118
+ mx = heights [ i ] ;
120
119
}
121
120
}
122
121
reverse(ans.begin(), ans.end());
@@ -128,20 +127,34 @@ public:
128
127
### **Go**
129
128
130
129
```go
131
- func findBuildings(heights []int) []int {
130
+ func findBuildings(heights []int) (ans []int) {
132
131
mx := 0
133
- ans := []int{}
134
132
for i := len(heights) - 1; i >= 0; i-- {
135
- v := heights[i]
136
- if mx < v {
133
+ if v := heights[i]; v > mx {
137
134
ans = append(ans, i)
138
135
mx = v
139
136
}
140
137
}
141
138
for i, j := 0, len(ans)-1; i < j; i, j = i+1, j-1 {
142
139
ans[i], ans[j] = ans[j], ans[i]
143
140
}
144
- return ans
141
+ return
142
+ }
143
+ ```
144
+
145
+ ### ** TypeScript**
146
+
147
+ ``` ts
148
+ function findBuildings(heights : number []): number [] {
149
+ const ans: number [] = [];
150
+ let mx = 0 ;
151
+ for (let i = heights .length - 1 ; ~ i ; -- i ) {
152
+ if (heights [i ] > mx ) {
153
+ ans .push (i );
154
+ mx = heights [i ];
155
+ }
156
+ }
157
+ return ans .reverse ();
145
158
}
146
159
```
147
160
@@ -153,13 +166,12 @@ func findBuildings(heights []int) []int {
153
166
* @return {number[]}
154
167
*/
155
168
var findBuildings = function (heights ) {
169
+ const ans = [];
156
170
let mx = 0 ;
157
- let ans = [];
158
- for (let i = heights .length - 1 ; i >= 0 ; -- i) {
159
- const v = heights[i];
160
- if (mx < v) {
171
+ for (let i = heights .length - 1 ; ~ i; -- i) {
172
+ if (heights[i] > mx) {
161
173
ans .push (i);
162
- mx = v ;
174
+ mx = heights[i] ;
163
175
}
164
176
}
165
177
return ans .reverse ();
0 commit comments