Skip to content

Commit d0cbc07

Browse files
yanglbmeyanglbme
committed
feat: update solutions to lc problem: No.0020
No.0020.Valid Parentheses
1 parent 57cb9ac commit d0cbc07

File tree

8 files changed

+152
-252
lines changed

8 files changed

+152
-252
lines changed

‎solution/0000-0099/0020.Valid Parentheses/README.md

+54-90
Original file line numberDiff line numberDiff line change
@@ -52,21 +52,17 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55-
栈实现。
55+
**方法一：栈**
5656

57-
遍历括号字符串 `s`：
57+
遍历括号字符串 $s$，遇到左括号时，压入当前的左括号；遇到右括号时，弹出栈顶元素（若栈为空，直接返回 `false`），判断是否匹配，若不匹配，直接返回 `false`。
5858

59-
- 遇到左括号时，将右括号压入栈中；
60-
- 遇到右括号时，弹出栈顶元素（若栈为空，直接返回 `false`），判断是否是相等。若不匹配，直接返回 `false`。
61-
62-
也可以选择：
63-
64-
- 遇到左括号时，压入当前的左括号。
65-
- 遇到右括号时，弹出栈顶元素（若栈为空，直接返回 `false`），判断是否是匹配，若不匹配，直接返回 `false`。
59+
也可以选择遇到左括号时，将右括号压入栈中；遇到右括号时，弹出栈顶元素（若栈为空，直接返回 `false`），判断是否是相等。若不匹配，直接返回 `false`。
6660

6761
> 两者的区别仅限于括号转换时机，一个是在入栈时，一个是在出栈时。
6862
69-
遍历结束，若栈为空，说明括号字符串有效。
63+
遍历结束，若栈为空，说明括号字符串有效，返回 `true`；否则，返回 `false`。
64+
65+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为括号字符串 $s$ 的长度。
7066

7167
<!-- tabs:start -->
7268

@@ -77,14 +73,14 @@
7773
```python
7874
class Solution:
7975
def isValid(self, s: str) -> bool:
80-
q = []
81-
parentheses = {'()', '[]', '{}'}
82-
for ch in s:
83-
if ch in '([{':
84-
q.append(ch)
85-
elif not q or q.pop() + ch not in parentheses:
76+
stk = []
77+
d = {'()', '[]', '{}'}
78+
for c in s:
79+
if c in '({[':
80+
stk.append(c)
81+
elif not stk or stk.pop() + c not in d:
8682
return False
87-
return not q
83+
return not stk
8884
```
8985

9086
### **Java**
@@ -94,16 +90,15 @@ class Solution:
9490
```java
9591
class Solution {
9692
public boolean isValid(String s) {
97-
char[] chars = s.toCharArray();
98-
Deque<Character> q = new ArrayDeque<>();
99-
for (char ch : chars) {
100-
boolean left = ch == '(' || ch == '[' || ch == '{';
101-
if (left)
102-
q.push(ch);
103-
else if (q.isEmpty() || !match(q.pop(), ch))
93+
Deque<Character> stk = new ArrayDeque<>();
94+
for (char c : s.toCharArray()) {
95+
if (c == '(' || c == '{' || c == '[') {
96+
stk.push(c);
97+
} else if (stk.isEmpty() || !match(stk.pop(), c)) {
10498
return false;
99+
}
105100
}
106-
return q.isEmpty();
101+
return stk.isEmpty();
107102
}
108103

109104
private boolean match(char l, char r) {
@@ -118,19 +113,18 @@ class Solution {
118113
class Solution {
119114
public:
120115
bool isValid(string s) {
121-
stack<char> q;
122-
for (int i = 0, n = s.length(); i < n; ++i) {
123-
if (s[i] == '{' || s[i] == '[' || s[i] == '(')
124-
q.push(s[i]);
125-
else if (q.empty() || !match(q.top(), s[i]))
116+
string stk;
117+
for (char c : s) {
118+
if (c == '(' || c == '{' || c == '[')
119+
stk.push_back(c);
120+
else if (stk.empty() || !match(stk.back(), c))
126121
return false;
127122
else
128-
q.pop();
123+
stk.pop_back();
129124
}
130-
return q.empty();
125+
return stk.empty();
131126
}
132127

133-
private:
134128
bool match(char l, char r) {
135129
return (l == '(' && r == ')') || (l == '[' && r == ']') || (l == '{' && r == '}');
136130
}
@@ -141,58 +135,21 @@ private:
141135

142136
```go
143137
func isValid(s string) bool {
144-
stack := newStack()
145-
for _, str := range s {
146-
if str == '(' || str == '[' || str == '{' {
147-
stack.push(byte(str))
148-
} else if str == ')' {
149-
if stack.pop() != (byte('(')) {
150-
return false
151-
}
152-
} else if str == ']' {
153-
if stack.pop() != (byte('[')) {
154-
return false
155-
}
156-
} else if str == '}' {
157-
if stack.pop() != (byte('{')) {
158-
return false
159-
}
138+
stk := []rune{}
139+
for _, c := range s {
140+
if c == '(' || c == '{' || c == '[' {
141+
stk = append(stk, c)
142+
} else if len(stk) == 0 || !match(stk[len(stk)-1], c) {
143+
return false
144+
} else {
145+
stk = stk[:len(stk)-1]
160146
}
161147
}
162-
return stack.size() == 0
163-
}
164-
165-
type Stack struct {
166-
data []byte
167-
index int
168-
}
169-
170-
func newStack() *Stack {
171-
return &Stack{
172-
data: make([]byte, 10),
173-
}
148+
return len(stk) == 0
174149
}
175150

176-
func (s *Stack) pop() byte {
177-
if s.index == 0 {
178-
return 0
179-
}
180-
s.index--
181-
r := s.data[s.index]
182-
return r
183-
}
184-
185-
func (s *Stack) push(b byte) {
186-
if len(s.data)-1 <= s.index {
187-
newData := make([]byte, len(s.data))
188-
s.data = append(s.data, newData[:]...)
189-
}
190-
s.data[s.index] = b
191-
s.index++
192-
}
193-
194-
func (s *Stack) size() int {
195-
return s.index
151+
func match(l, r rune) bool {
152+
return (l == '(' && r == ')') || (l == '[' && r == ']') || (l == '{' && r == '}')
196153
}
197154
```
198155

@@ -204,19 +161,26 @@ func (s *Stack) size() int {
204161
* @return {boolean}
205162
*/
206163
var isValid = function (s) {
207-
let arr = [];
208-
for (let i = 0; i < s.length; i++) {
209-
if (s[i] === '{' || s[i] === '[' || s[i] === '(') {
210-
arr.push(s[i]);
164+
let stk = [];
165+
for (const c of s) {
166+
if (c == '(' || c == '{' || c == '[') {
167+
stk.push(c);
168+
} else if (stk.length == 0 || !match(stk[stk.length - 1], c)) {
169+
return false;
211170
} else {
212-
if (s[i] === ')' && arr[arr.length - 1] === '(') arr.pop();
213-
else if (s[i] === ']' && arr[arr.length - 1] === '[') arr.pop();
214-
else if (s[i] === '}' && arr[arr.length - 1] === '{') arr.pop();
215-
else return false;
171+
stk.pop();
216172
}
217173
}
218-
return arr.length === 0;
174+
return stk.length == 0;
219175
};
176+
177+
function match(l, r) {
178+
return (
179+
(l == '(' && r == ')') ||
180+
(l == '[' && r == ']') ||
181+
(l == '{' && r == '}')
182+
);
183+
}
220184
```
221185

222186
### **Ruby**

‎solution/0000-0099/0020.Valid Parentheses/README_EN.md

+48-80
Original file line numberDiff line numberDiff line change
@@ -53,31 +53,30 @@
5353
```python
5454
class Solution:
5555
def isValid(self, s: str) -> bool:
56-
q = []
57-
parentheses = {'()', '[]', '{}'}
58-
for ch in s:
59-
if ch in '([{':
60-
q.append(ch)
61-
elif not q or q.pop() + ch not in parentheses:
56+
stk = []
57+
d = {'()', '[]', '{}'}
58+
for c in s:
59+
if c in '({[':
60+
stk.append(c)
61+
elif not stk or stk.pop() + c not in d:
6262
return False
63-
return not q
63+
return not stk
6464
```
6565

6666
### **Java**
6767

6868
```java
6969
class Solution {
7070
public boolean isValid(String s) {
71-
char[] chars = s.toCharArray();
72-
Deque<Character> q = new ArrayDeque<>();
73-
for (char ch : chars) {
74-
boolean left = ch == '(' || ch == '[' || ch == '{';
75-
if (left)
76-
q.push(ch);
77-
else if (q.isEmpty() || !match(q.pop(), ch))
71+
Deque<Character> stk = new ArrayDeque<>();
72+
for (char c : s.toCharArray()) {
73+
if (c == '(' || c == '{' || c == '[') {
74+
stk.push(c);
75+
} else if (stk.isEmpty() || !match(stk.pop(), c)) {
7876
return false;
77+
}
7978
}
80-
return q.isEmpty();
79+
return stk.isEmpty();
8180
}
8281

8382
private boolean match(char l, char r) {
@@ -92,19 +91,18 @@ class Solution {
9291
class Solution {
9392
public:
9493
bool isValid(string s) {
95-
stack<char> q;
96-
for (int i = 0, n = s.length(); i < n; ++i) {
97-
if (s[i] == '{' || s[i] == '[' || s[i] == '(')
98-
q.push(s[i]);
99-
else if (q.empty() || !match(q.top(), s[i]))
94+
string stk;
95+
for (char c : s) {
96+
if (c == '(' || c == '{' || c == '[')
97+
stk.push_back(c);
98+
else if (stk.empty() || !match(stk.back(), c))
10099
return false;
101100
else
102-
q.pop();
101+
stk.pop_back();
103102
}
104-
return q.empty();
103+
return stk.empty();
105104
}
106105

107-
private:
108106
bool match(char l, char r) {
109107
return (l == '(' && r == ')') || (l == '[' && r == ']') || (l == '{' && r == '}');
110108
}
@@ -115,58 +113,21 @@ private:
115113

116114
```go
117115
func isValid(s string) bool {
118-
stack := newStack()
119-
for _, str := range s {
120-
if str == '(' || str == '[' || str == '{' {
121-
stack.push(byte(str))
122-
} else if str == ')' {
123-
if stack.pop() != (byte('(')) {
124-
return false
125-
}
126-
} else if str == ']' {
127-
if stack.pop() != (byte('[')) {
128-
return false
129-
}
130-
} else if str == '}' {
131-
if stack.pop() != (byte('{')) {
132-
return false
133-
}
116+
stk := []rune{}
117+
for _, c := range s {
118+
if c == '(' || c == '{' || c == '[' {
119+
stk = append(stk, c)
120+
} else if len(stk) == 0 || !match(stk[len(stk)-1], c) {
121+
return false
122+
} else {
123+
stk = stk[:len(stk)-1]
134124
}
135125
}
136-
return stack.size() == 0
137-
}
138-
139-
type Stack struct {
140-
data []byte
141-
index int
142-
}
143-
144-
func newStack() *Stack {
145-
return &Stack{
146-
data: make([]byte, 10),
147-
}
148-
}
149-
150-
func (s *Stack) pop() byte {
151-
if s.index == 0 {
152-
return 0
153-
}
154-
s.index--
155-
r := s.data[s.index]
156-
return r
157-
}
158-
159-
func (s *Stack) push(b byte) {
160-
if len(s.data)-1 <= s.index {
161-
newData := make([]byte, len(s.data))
162-
s.data = append(s.data, newData[:]...)
163-
}
164-
s.data[s.index] = b
165-
s.index++
126+
return len(stk) == 0
166127
}
167128

168-
func (s *Stack) size() int {
169-
return s.index
129+
func match(l, r rune) bool {
130+
return (l == '(' && r == ')') || (l == '[' && r == ']') || (l == '{' && r == '}')
170131
}
171132
```
172133

@@ -178,19 +139,26 @@ func (s *Stack) size() int {
178139
* @return {boolean}
179140
*/
180141
var isValid = function (s) {
181-
let arr = [];
182-
for (let i = 0; i < s.length; i++) {
183-
if (s[i] === '{' || s[i] === '[' || s[i] === '(') {
184-
arr.push(s[i]);
142+
let stk = [];
143+
for (const c of s) {
144+
if (c == '(' || c == '{' || c == '[') {
145+
stk.push(c);
146+
} else if (stk.length == 0 || !match(stk[stk.length - 1], c)) {
147+
return false;
185148
} else {
186-
if (s[i] === ')' && arr[arr.length - 1] === '(') arr.pop();
187-
else if (s[i] === ']' && arr[arr.length - 1] === '[') arr.pop();
188-
else if (s[i] === '}' && arr[arr.length - 1] === '{') arr.pop();
189-
else return false;
149+
stk.pop();
190150
}
191151
}
192-
return arr.length === 0;
152+
return stk.length == 0;
193153
};
154+
155+
function match(l, r) {
156+
return (
157+
(l == '(' && r == ')') ||
158+
(l == '[' && r == ']') ||
159+
(l == '{' && r == '}')
160+
);
161+
}
194162
```
195163

196164
### **Ruby**

0 commit comments

Comments
 (0)