Skip to content

Commit 8f8dd00

Browse files
yanglbmeyanglbme
committed
feat: update solutions to lcof problem: No.33
剑指 Offer 33. 二叉搜索树的后序遍历序列
1 parent e962d61 commit 8f8dd00

File tree

7 files changed

+150
-164
lines changed

7 files changed

+150
-164
lines changed

‎README_EN.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -221,7 +221,7 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
221221
- [Design HashSet](/solution/0700-0799/0705.Design%20HashSet/README_EN.md)
222222
- [Design HashMap](/solution/0700-0799/0706.Design%20HashMap/README_EN.md)
223223

224-
## Maintainer
224+
## Maintainers
225225

226226
- [Yang Libin](https://github.com/yanglbme)
227227
- [Mao Longlong](https://github.com/MaoLongLong)

‎lcof/面试题33. 二叉搜索树的后序遍历序列/README.md

Lines changed: 74 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -49,21 +49,18 @@
4949
```python
5050
class Solution:
5151
def verifyPostorder(self, postorder: List[int]) -> bool:
52-
def verify(p1, p2):
53-
if p1 > p2:
52+
def dfs(postorder):
53+
if not postorder:
5454
return True
55-
pos = p1
56-
while pos < p2 and postorder[pos] < postorder[p2]:
57-
pos += 1
58-
p = pos
59-
while pos < p2:
60-
if postorder[pos] < postorder[p2]:
61-
return False
62-
pos += 1
63-
return verify(p1, p - 1) and verify(p, p2 - 1)
64-
if not postorder:
65-
return True
66-
return verify(0, len(postorder) - 1)
55+
v = postorder[-1]
56+
i = 0
57+
while i < len(postorder) and postorder[i] < v:
58+
i += 1
59+
if any(x < v for x in postorder[i:]):
60+
return False
61+
return dfs(postorder[:i]) and dfs(postorder[i:-1])
62+
63+
return dfs(postorder)
6764
```
6865

6966
### **Java**
@@ -73,21 +70,27 @@ class Solution:
7370
```java
7471
class Solution {
7572
public boolean verifyPostorder(int[] postorder) {
76-
int n;
77-
if (postorder == null || (n = postorder.length) == 0) return true;
78-
return verify(postorder, 0, n - 1);
73+
if (postorder == null || postorder.length < 2) {
74+
return true;
75+
}
76+
return dfs(postorder, 0, postorder.length);
7977
}
8078

81-
private boolean verify(int[] postorder, int p1, int p2) {
82-
if (p1 >= p2) return true;
83-
int pos = p1;
84-
while (pos < p2 && postorder[pos] < postorder[p2]) ++pos;
85-
int p = pos;
86-
while (pos < p2) {
87-
if (postorder[pos] < postorder[p2]) return false;
88-
++pos;
79+
private boolean dfs(int[] postorder, int i, int n) {
80+
if (n <= 0) {
81+
return true;
82+
}
83+
int v = postorder[i + n - 1];
84+
int j = i;
85+
while (j < i + n && postorder[j] < v) {
86+
++j;
87+
}
88+
for (int k = j; k < i + n; ++k) {
89+
if (postorder[k] < v) {
90+
return false;
91+
}
8992
}
90-
return verify(postorder, p1, p - 1) && verify(postorder, p, p2 - 1);
93+
return dfs(postorder, i, j - i) && dfs(postorder, j, n + i - j - 1);
9194
}
9295
}
9396
```
@@ -100,52 +103,48 @@ class Solution {
100103
* @return {boolean}
101104
*/
102105
var verifyPostorder = function (postorder) {
103-
if (!postorder || postorder.length < 2) return true;
104-
let mid = 0;
105-
let root = postorder[postorder.length - 1];
106-
for (let i = 0; i < postorder.length - 1 && postorder[i] < root; i++) {
107-
mid++;
108-
}
109-
for (let i = mid + 1; i < postorder.length - 1; i++) {
110-
if (postorder[i] < root) return false;
106+
if (postorder.length < 2) return true;
107+
function dfs(i, n) {
108+
if (n <= 0) return true;
109+
const v = postorder[i + n - 1];
110+
let j = i;
111+
while (j < i + n && postorder[j] < v) ++j;
112+
for (let k = j; k < i + n; ++k) {
113+
if (postorder[k] < v) {
114+
return false;
115+
}
116+
}
117+
return dfs(i, j - i) && dfs(j, n + i - j - 1);
111118
}
112-
return (
113-
verifyPostorder(postorder.slice(0, mid)) &&
114-
verifyPostorder(postorder.slice(mid + 1, postorder.length - 1))
115-
);
119+
return dfs(0, postorder.length);
116120
};
117121
```
118122

119123
### **Go**
120124

121125
```go
122126
func verifyPostorder(postorder []int) bool {
123-
if len(postorder) < 2 {
124-
return true
125-
}
126-
return helper(postorder, 0, len(postorder)-1)
127-
}
128-
// 递归
129-
func helper(postorder []int , left,right int) bool {
130-
if left >= right {
131-
return true
132-
}
133-
// 最后一位即根
134-
rootValue := postorder[right]
135-
// 从左开始往右遍历，直到大于根停止,小于部分是左子树
136-
i := left
137-
for i < right && postorder[i] < rootValue {
138-
i++
139-
}
140-
// 剩下部分是右子树，检查是否都大于根值
141-
for j := i; j < right; j++ {
142-
if postorder[j] < rootValue {
143-
return false
144-
}
145-
}
146-
l := helper(postorder,left,i-1) // 检查左子树，左子树i要减一
147-
r := helper(postorder,i,right-1)// 检查右子树，剔除最后一位是根
148-
return l && r
127+
if len(postorder) < 2 {
128+
return true
129+
}
130+
var dfs func(i, n int) bool
131+
dfs = func(i, n int) bool {
132+
if n <= 0 {
133+
return true
134+
}
135+
v := postorder[i+n-1]
136+
j := i
137+
for j < i+n && postorder[j] < v {
138+
j++
139+
}
140+
for k := j; k < i+n; k++ {
141+
if postorder[k] < v {
142+
return false
143+
}
144+
}
145+
return dfs(i, j-i) && dfs(j, n+i-j-1)
146+
}
147+
return dfs(0, len(postorder))
149148
}
150149
```
151150

@@ -155,25 +154,19 @@ func helper(postorder []int , left,right int) bool {
155154
class Solution {
156155
public:
157156
bool verifyPostorder(vector<int>& postorder) {
158-
return verify(postorder, 0, postorder.size() - 1);
157+
if (postorder.size() < 2) return true;
158+
return dfs(postorder, 0, postorder.size());
159159
}
160160

161-
bool verify(vector<int>& postorder, int left, int right) {
162-
if (left >= right) {
163-
return true;
164-
}
165-
int root = postorder[right], i = left;
166-
while (postorder[i] < root) {
167-
++i;
168-
}
169-
int mid = i;
170-
while (i < right) {
171-
if (postorder[i] < root) {
172-
return false;
173-
}
174-
++i;
175-
}
176-
return verify(postorder, left, mid - 1) && verify(postorder, mid, right - 1);
161+
bool dfs(vector<int>& postorder, int i, int n) {
162+
if (n <= 0) return 1;
163+
int v = postorder[i + n - 1];
164+
int j = i;
165+
while (j < i + n && postorder[j] < v) ++j;
166+
for (int k = j; k < i + n; ++k)
167+
if (postorder[k] < v)
168+
return 0;
169+
return dfs(postorder, i, j - i) && dfs(postorder, j, n + i - j - 1);
177170
}
178171
};
179172
```

‎lcof/面试题33. 二叉搜索树的后序遍历序列/Solution.cpp

Lines changed: 12 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1,24 +1,18 @@
11
class Solution {
22
public:
33
bool verifyPostorder(vector<int>& postorder) {
4-
return verify(postorder, 0, postorder.size() - 1);
4+
if (postorder.size() < 2) return true;
5+
return dfs(postorder, 0, postorder.size());
56
}
67

7-
bool verify(vector<int>& postorder, int left, int right) {
8-
if (left >= right) {
9-
return true;
10-
}
11-
int root = postorder[right], i = left;
12-
while (postorder[i] < root) {
13-
++i;
14-
}
15-
int mid = i;
16-
while (i < right) {
17-
if (postorder[i] < root) {
18-
return false;
19-
}
20-
++i;
21-
}
22-
return verify(postorder, left, mid - 1) && verify(postorder, mid, right - 1);
8+
bool dfs(vector<int>& postorder, int i, int n) {
9+
if (n <= 0) return 1;
10+
int v = postorder[i + n - 1];
11+
int j = i;
12+
while (j < i + n && postorder[j] < v) ++j;
13+
for (int k = j; k < i + n; ++k)
14+
if (postorder[k] < v)
15+
return 0;
16+
return dfs(postorder, i, j - i) && dfs(postorder, j, n + i - j - 1);
2317
}
24-
};
18+
};

‎lcof/面试题33. 二叉搜索树的后序遍历序列/Solution.go

Lines changed: 21 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,28 +1,23 @@
11
func verifyPostorder(postorder []int) bool {
2-
if len(postorder) < 2 {
3-
return true
4-
}
5-
return helper(postorder, 0, len(postorder)-1)
6-
}
7-
// 递归
8-
func helper(postorder []int , left,right int) bool {
9-
if left >= right {
10-
return true
11-
}
12-
// 最后一位即根
13-
rootValue := postorder[right]
14-
// 从左开始往右遍历，直到大于根停止,小于部分是左子树
15-
i := left
16-
for i < right && postorder[i] < rootValue {
17-
i++
18-
}
19-
// 剩下部分是右子树，检查是否都大于根值
20-
for j := i; j < right; j++ {
21-
if postorder[j] < rootValue {
22-
return false
23-
}
24-
}
25-
l := helper(postorder,left,i-1) // 检查左子树，左子树i要减一
26-
r := helper(postorder,i,right-1)// 检查右子树，剔除最后一位是根
27-
return l && r
2+
if len(postorder) < 2 {
3+
return true
4+
}
5+
var dfs func(i, n int) bool
6+
dfs = func(i, n int) bool {
7+
if n <= 0 {
8+
return true
9+
}
10+
v := postorder[i+n-1]
11+
j := i
12+
for j < i+n && postorder[j] < v {
13+
j++
14+
}
15+
for k := j; k < i+n; k++ {
16+
if postorder[k] < v {
17+
return false
18+
}
19+
}
20+
return dfs(i, j-i) && dfs(j, n+i-j-1)
21+
}
22+
return dfs(0, len(postorder))
2823
}

‎lcof/面试题33. 二叉搜索树的后序遍历序列/Solution.java

Lines changed: 18 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,25 @@
11
class Solution {
22
public boolean verifyPostorder(int[] postorder) {
3-
int n;
4-
if (postorder == null || (n = postorder.length) == 0) return true;
5-
return verify(postorder, 0, n - 1);
3+
if (postorder == null || postorder.length < 2) {
4+
return true;
5+
}
6+
return dfs(postorder, 0, postorder.length);
67
}
78

8-
private boolean verify(int[] postorder, int p1, int p2) {
9-
if (p1 >= p2) return true;
10-
int pos = p1;
11-
while (pos < p2 && postorder[pos] < postorder[p2]) ++pos;
12-
int p = pos;
13-
while (pos < p2) {
14-
if (postorder[pos] < postorder[p2]) return false;
15-
++pos;
9+
private boolean dfs(int[] postorder, int i, int n) {
10+
if (n <= 0) {
11+
return true;
12+
}
13+
int v = postorder[i + n - 1];
14+
int j = i;
15+
while (j < i + n && postorder[j] < v) {
16+
++j;
17+
}
18+
for (int k = j; k < i + n; ++k) {
19+
if (postorder[k] < v) {
20+
return false;
21+
}
1622
}
17-
return verify(postorder, p1, p - 1) && verify(postorder, p, p2 - 1);
23+
return dfs(postorder, i, j - i) && dfs(postorder, j, n + i - j - 1);
1824
}
1925
}

‎lcof/面试题33. 二叉搜索树的后序遍历序列/Solution.js

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -3,17 +3,18 @@
33
* @return {boolean}
44
*/
55
var verifyPostorder = function (postorder) {
6-
if (!postorder || postorder.length < 2) return true;
7-
let mid = 0;
8-
let root = postorder[postorder.length - 1];
9-
for (let i = 0; i < postorder.length - 1 && postorder[i] < root; i++) {
10-
mid++;
6+
if (postorder.length < 2) return true;
7+
function dfs(i, n) {
8+
if (n <= 0) return true;
9+
const v = postorder[i + n - 1];
10+
let j = i;
11+
while (j < i + n && postorder[j] < v) ++j;
12+
for (let k = j; k < i + n; ++k) {
13+
if (postorder[k] < v) {
14+
return false;
15+
}
16+
}
17+
return dfs(i, j - i) && dfs(j, n + i - j - 1);
1118
}
12-
for (let i = mid + 1; i < postorder.length - 1; i++) {
13-
if (postorder[i] < root) return false;
14-
}
15-
return (
16-
verifyPostorder(postorder.slice(0, mid)) &&
17-
verifyPostorder(postorder.slice(mid + 1, postorder.length - 1))
18-
);
19+
return dfs(0, postorder.length);
1920
};

‎lcof/面试题33. 二叉搜索树的后序遍历序列/Solution.py

Lines changed: 11 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,14 @@
11
class Solution:
22
def verifyPostorder(self, postorder: List[int]) -> bool:
3-
def verify(p1, p2):
4-
if p1 > p2:
3+
def dfs(postorder):
4+
if not postorder:
55
return True
6-
pos = p1
7-
while pos < p2 and postorder[pos] < postorder[p2]:
8-
pos += 1
9-
p = pos
10-
while pos < p2:
11-
if postorder[pos] < postorder[p2]:
12-
return False
13-
pos += 1
14-
return verify(p1, p - 1) and verify(p, p2 - 1)
15-
if not postorder:
16-
return True
17-
return verify(0, len(postorder) - 1)
6+
v = postorder[-1]
7+
i = 0
8+
while i < len(postorder) and postorder[i] < v:
9+
i += 1
10+
if any(x < v for x in postorder[i:]):
11+
return False
12+
return dfs(postorder[:i]) and dfs(postorder[i:-1])
13+
14+
return dfs(postorder)

0 commit comments

Comments
 (0)